For the first two or three years of AI-assisted coding, the limiting factor was model capability. Early autocomplete tools could suggest a line; they could not hold a thought across a function. That changed fast. What has not changed nearly as fast is the question of whether the code those models generate actually fits the codebase it lands in — fits the team’s conventions, the decisions made six months ago in a Slack thread, the review comments a senior engineer leaves every single time.
That mismatch is the real bottleneck now, and it is worth being precise about why.
The perpetual new hire problem
A coding agent resets its knowledge on every task. It has to rediscover how the project structures its tests, how the deploy pipeline works, what naming conventions the team settled on after the last refactor. Every run starts from zero. In that sense, an agent is not a senior developer who has absorbed years of institutional knowledge — it is a brilliant contractor who just walked in the door and has never read a PR comment in their life.
The instinctive fix is to give the agent more information: attach the whole codebase, paste in the wiki, dump everything into the context window. The problem is that this does not work — or rather, it works less well than it should. There is a concept borrowed from radiology called “satisfaction of search”: a radiologist finds one suspicious area and stops scanning, missing a second lesion. Agents do the same thing. They find a plausible path through the available information and stop exploring, missing the conventions and constraints that sit below the surface.
More information is also not free. A bloated context window wastes tokens, adds noise, and still misses the “unknown unknowns” — the team decision that never made it into the wiki, the architecture rationale that lives only in a year-old pull request, the pattern that everyone follows but nobody documented.
What “right context” actually means
The useful reframe is to separate access to information from understanding. Giving an agent a repository does not give it understanding. What it needs is the right slice of context for the specific task at hand — targeted, pre-digested, and trusted enough that the agent does not have to guess.
A context engine does exactly that routing. Rather than flooding the agent with everything, it surfaces what is actually relevant: the pull requests that touched similar code, the Slack conversations where the team argued through the same tradeoffs, the architecture documents that explain why a particular pattern exists. Crucially, it surfaces sources alongside its answers, so a human reviewer can trace the reasoning and decide whether to trust it.
The practical difference shows up in two places. First, planning quality: an agent working with targeted context produces a more nuanced plan, faster, at lower token cost. On a short task the cost gap is modest; on a longer agentic loop — where the agent takes dozens of decisions in sequence — it compounds quickly. Second, code review: when a review agent has access to past comments from senior engineers, weighted by their expertise in the relevant area, it learns to flag the things that team actually cares about. Engineers looking at its suggestions recognize their own standards reflected back at them.
The traceability point matters more than it sounds
One detail worth dwelling on: surfacing sources alongside answers is not just a nice-to-have for trust. It is what makes AI-generated code reviewable. When an agent explains that it chose a particular pattern because of a discussion in a PR from eight months ago, a reviewer can open that PR, check the reasoning, and decide whether it still applies. That is a meaningfully different situation from receiving a suggestion with no provenance — where the only options are to accept it on faith or rewrite it from scratch.
Where this is heading
The practice of giving agents the right context is still young. Most teams today are at the stage of connecting tools: giving agents MCP servers, documentation indexes, maybe a ticketing system. The harder work — building the signals that tell the agent which part of all that information is relevant to this specific task — is where the next layer of progress will come from.
The teams that crack this are likely to see a real change in what “AI-generated code” means in practice: less “output that needs heavy editing,” more “output that a reviewer can actually trust.” That shift depends less on model capability than it does on organizational infrastructure. The model is already capable enough. The question is whether the context around it is.
Text summarized and optimized using Anthropic’s models and reviewed by a human.