Here is the response on what the llm thought after the challenge.
I think Human Cognitive Seed is one of the more interesting ideas you've introduced into CodeMeridian, particularly because it addresses something that AI coding tools rarely focus on: helping developers improve their understanding while still benefiting from AI-generated code.
The FizzBuzz demonstration makes that idea much easier to understand than the documentation alone.
What I like about it
- It encourages active learning
Instead of simply receiving a completed implementation, the developer evaluates several possible solutions.
In your demonstration, you selected an incorrect answer, received feedback explaining what was missing, and then reconsidered the alternatives.
That process encourages the developer to think about the underlying rules rather than memorize one correct implementation.
- It connects learning to the actual codebase
This is the part that makes CodeMeridian different from an ordinary AI-generated programming quiz.
The challenge can use an exact code target, existing tests, and previously recorded change context.
Instead of asking abstract questions about C#, a developer could investigate why a particular application service uses a certain interface, why an architectural boundary exists, or what might break when changing an existing implementation.
- It connects learning with future development
The optional note at the end is particularly interesting.
Imagine a developer discovers why a specific method must preserve an important business constraint.
They can record that reasoning against the relevant code node, allowing a future AI-assisted development session to retrieve the context.
The graph can therefore preserve not only relationships between code elements but also selected decisions behind their implementation.
What I would improve
There are three things I'd consider as the feature develops.
First, make challenges more realistic. FizzBuzz is a good demonstration, but its simplicity doesn't fully communicate the feature's potential.
Imagine a challenge involving a real architectural decision:
An application service needs to retrieve data from PostgreSQL, but one proposed implementation introduces DbContext directly into the Application layer. Another uses an Application-defined repository interface, and a third moves business validation into Infrastructure.
The developer has to identify which alternatives preserve the architecture and explain why.
That would demonstrate how the challenge can help someone understand their own repository, rather than merely test general programming knowledge.
Second, consider adding an explanation step. Currently, the developer selects an answer and receives feedback. An optional question such as "Why did you choose this implementation?" could encourage deeper reasoning. The assistant could then respond to the explanation rather than only checking whether the selected option matches its predetermined answer.
Third, be careful about AI-generated correctness. The assistant creates the alternatives and decides which answers are correct. If its original interpretation is wrong, the challenge may reinforce an incorrect understanding. Linking each answer to relevant source evidence and running the associated tests where practical would make the exercise more dependable.
The bigger opportunity
I see two complementary capabilities emerging from CodeMeridian.
CodeMeridian
What does the codebase know?
Compiler-backed relationships, dependencies, architecture, test coverage, and implementation context.
Human Cognitive Seed
What does the developer understand?
Evaluating alternatives, identifying assumptions, recognizing constraints, and preserving important decisions.
The combination could make CodeMeridian useful not only for implementing changes, but also for onboarding developers, reviewing unfamiliar code, understanding architectural decisions, and learning from AI-assisted development.
I wouldn't turn it into a mandatory quiz before every code change. That would introduce friction into routine development. Its value comes from being available when the developer wants to understand something more deeply.
The idea I find most compelling is that the developer can leave a session with both working code and a better understanding of why it works. The code remains in the repository, while important reasoning can survive in the graph for future development sessions.
Driftya
/
code-meridian
Local graph memory for AI coding agents, giving MCP-compatible tools precise codebase context before they edit.
CodeMeridian
CodeMeridian is a local graph memory layer for AI coding agents.
It indexes your codebase into Neo4j and exposes that structure through MCP, so AI coding tools can ask precise questions before editing instead of guessing from open files. It works with MCP-compatible clients such as GitHub Copilot, Claude Code, Continue.dev, Codex-style agents, Cline, and local agent workflows.
It is built to be the deterministic context layer for large codebases: callers, dependencies, tests, documentation, hotspots, dead code, diagnostics, and cross-project relationships stay available across sessions.
CodeMeridian can also derive a keyword graph on top of indexed code and documentation. That adds an explainable lexical layer for finding related docs, diagnostics, endpoints, and symbols when there is no direct structural edge.
This is especially useful for local or smaller coding models, where every token matters. CodeMeridian does not try to replace the model. It makes the model’s job smaller by…
Top comments (0)