Codistry Review: A VS Code AI Coding Assistant for Large Codebases

Modern AI coding agents can generate large amounts of code, but generation is rarely the only detail in mature projects. The harder problem is often understanding where a change belongs, which components it affects, and which conventions it must preserve. Codistry is Adronite’s attempt to put that missing repository knowledge underneath the model rather than expecting the model to rediscover the project from scratch on every task.

 

Adronite co-founder and CTO Edward Rothschild told me that the technology began as a documentation system for very large codebases, later expanded into security analysis, and eventually became the foundation of Codistry. He described the broader goal as understanding both “your code base” and “you and your ways of working.”

I tested Codistry qualitatively across several broadly anonymized codebases, using Claude Fable 5 as its operating model. One test involved asking Codistry itself to trace a feature from a natural entry point through several connected modules or services. In a second workflow, I connected Codistry to a custom harness that allowed it to supervise external coding workers. 

Codistry works as a conventional coding agent inside VS Code: it can inspect and edit files, search the workspace, run commands, use VS Code actions, and keep multiple sessions organized. Its defining feature, however, is the Context Engine.

 

It builds a local structural map of a repository, identifies relationships and dependencies, finds code by concept, selects likely relevant files at the start of a task, and can surface files that often change together. Once built, the index can refresh after commits, checkouts, and pulls. The documentation still labels the system experimental and advises treating its suggestions as orientation rather than an unquestionable source of truth.

 

In my use, the Context Engine provided a clear and consistent practical advantage. Starting from one plausible entry point in a mature project, Codistry independently expanded into the wider implementation and followed the feature through connected modules or services. It made my interaction feel less like feeding every detail to the agent and more like asking an assistant that already had a working map of the project.

 

Rothschild said the engine stores several layers of context. A human-readable context markdown file provides a high-level project map, while what Adronite calls a “relational index” records how parts of the code connect and a “temporal index” examines how the repository changes over time. Lower layers can reach individual function relationships when the task requires more detail. The idea is progressive retrieval: give the model enough context to solve the task without flooding it with the whole repository.

 

Adronite also makes a quantitative efficiency claim. Rothschild said internal comparisons found Codistry using “about half the tokens” and “half the steps” in certain tasks that both systems completed successfully. I could not independently verify the figure but using it felt like the agent didn’t need the same amount of lookups and file-reads before proceeding into the actual coding work.

Codistry is broadly model-agnostic rather than tied to a single AI provider. It supports Anthropic and OpenAI directly via API, along with custom OpenAI-compatible endpoints for local models, corporate gateways, and other deployments. Custom models must support tool calling because the agent depends on tools to read, search, edit, and execute. The default model can be changed in settings, while individual sessions can use another model that can be switched just like in GitHub Copilot or other agentic systems like Codex or Claude Code.

 

That flexibility is a real strength, but it also means Codistry cannot be judged independently of the model behind it. The Context Engine can improve what the model knows about the repository; it cannot compensate fully for weak reasoning, poor tool use, or unreliable code generation. I used Claude Fable 5 for the main Codistry agent, and my positive conclusions about repository understanding should be read in that context.

 

 

The settings are configurable like in any other conventional IDE copilot. Reasoning effort, streaming, context limits, indexing-model choice, tool permissions, and maximum iterations are available in the interface. 

Codistry was productive and generally capable during my testing. The Context Engine helped it orient itself, and its direct coding workflow was useful for normal exploration and change requests. The main weakness was not the quality of the repository context, but the interaction design around longer agent runs.

 

In the interface I tested, redirecting an active task required stopping the run and then continuing with revised instructions. Other agentic coding solutions make this easier by what they call Steering. However, functionally stopping the Codistry agent to send a new message for course-correction has basically the same effect.

 

More mature agentic interfaces make mid-run steering feel smoother and more immediate. Rothschild said Adronite was working on functionality that would allow additional direction during an active conversation.

 

This was the only major drawback I found, as I got used to steer agents a lot as new ideas come to mind as I watch an agent work.

 

It did not prevent useful work, but it made Codistry feel less polished than the strongest products in the agentic-coding category. Better steering, clearer run control, and more flexible delegation would make the strong context layer easier to exploit.

Codistry also tries to learn both the project and the developer. Custom rules can be appended to every request. Project Memory retains long-lived facts and relationships about a repository. Adaptive Learning builds an editable, versioned text profile called the Worldview, while Dynamic Skills capture repository-specific procedures such as build, test, or release routines. Official documentation says these elements are stored locally.

 

Rothschild distinguished the layers in practical terms: Project Memory records facts about the codebase, Adaptive Learning models how the user tends to approach problems, and Dynamic Skills capture how that user works in a particular repository. He said the long-term ambition is not merely to remember isolated preferences, but to make Codistry’s behavior more predictable for the individual developer. I examined these controls and the generated Worldview, but I did was not to test them profoundly in a controlled before-and-after comparison.

 

Codistry’s separate Expertise feature uses Git history to infer which areas a developer owns, shares, or knows less well, then adjusts how much it explains or defers. This is an interesting extension of the same idea, particularly for established teams with meaningful commit history.

Codistry includes a built-in general-purpose subagent and lets users define additional agents with constrained tools, command approvals, and maximum-turn limits. The main agent can delegate self-contained research or implementation tasks, while the result is returned to the main conversation. Project agents can also be stored in the repository.

 

The native system was useful, but the configuration I tested tied subagents to the main Codistry agent’s model and API setup. That is inflexible when the preferred architecture model and implementation workers should use different providers, subscriptions, reasoning levels, or command-line environments. Rothschild said Adronite is revamping subagents with per-agent model and reasoning controls, as well as triggers that can launch workflows in response to model decisions or repository events.

 

To explore the broader potential, I connected Codistry to my custom harness that exposed external Claude Code and Codex processes as workers. Codistry then operated primarily as a repository-aware supervisor and quality-control layer. It launched workers, reviewed their results using the Context Engine, and continued with corrective or follow-up delegations. It managed most of the loop autonomously, although I occasionally redirected it and retained final control.

 

For one contained feature, this arrangement produced a useful implementation that followed the project’s existing conventions and needed only limited refinement. The result was not Codistry acting alone: external workers produced much of the code, while my harness supplied the integration. What Codistry contributed was context-aware orchestration—formulating better assignments, evaluating results against the wider repository, and deciding what needed another pass.

 

This was effective and promising, but it remains a power-user workflow for users that are already using complex custom harnesses, rather than a standard product feature. Rothschild said Adronite is actively working toward making Codistry an “orchestrator for other tools.” This would make the Context Engine valuable beyond Codistry’s own agent interface.

Codistry’s Developer tier is currently free, with users normally supplying their own Anthropic, OpenAI, local, or compatible corporate endpoint and paying any model-provider costs directly. Adronite says source code is sent only to the provider selected by the user or kept local with a local endpoint; anonymous operational telemetry can be disabled in Codistry or through VS Code.

 

Disclosure: Adronite provided a free API allowance for testing Codistry. It did not pay for or sponsor this review, impose conditions on its conclusions, exercise editorial control, or receive a right to approve the article before publication.

Codistry is most compelling for experienced developers and teams working on mature or complex codebases. Its Context Engine was not just an interesting settings page in my testing: it consistently helped the agent move from a natural entry point to the wider feature or dependency flow without requiring me to assemble all relevant files manually. That is a meaningful advantage when the hardest part of a task is understanding what already exists.

 

The rest of the product is capable, flexible, and unusually open to different models and integrations, but the agent interface is not yet as fluid as the most mature alternatives in the category. Native subagent configuration also needs more flexibility before Codistry’s orchestration potential becomes widely accessible. The planned improvements Rothschild described address both areas, but they should be judged when they ship rather than counted as current strengths.

 

Rothschild said an unnamed large automotive manufacturer had found Codistry particularly trustworthy on large codebases, although that customer feedback was relayed by Adronite and was not independently verified. The product’s strongest fit nevertheless matches my own qualitative experience: its benefits become clearer as repository complexity increases. Rothschild likewise said the greatest pain tends to appear in high-scale systems, even though Codistry can also be used on smaller projects.

 

For developers who mainly want frictionless autocomplete or a highly polished conversational agent, Codistry may feel more configurable and less streamlined than necessary. For those who regularly work across interconnected services, unfamiliar modules, or long-lived repositories—and who are willing to trade some interface polish for deeper project context—it is already a distinctive and worthwhile VS Code extension.