AI-generated code is overwhelming traditional review processes, leaving teams with a new challenge: preserving the knowledge-sharing role that code reviews once played.
Code review can’t keep up with AI output
Engineers now face 500-line diffs they didn’t write, produced by models they don’t fully control, at a pace that makes careful human review impossible. The volume of AI-generated code has broken the old system. The primary concern isn’t just catching bugs—it’s losing the team’s collective understanding of what the code does.
Before AI, a junior engineer’s pull request might draw four to eight comments from a senior colleague. Those exchanges taught how to think about the codebase, weigh tradeoffs, and form a mental model of the system. Now, the same change might be generated by AI, lightly edited, reviewed by another AI, and merged without any human developing a real understanding of it.
Cognitive debt: the hidden cost of AI-driven development
Margaret-Anne Storey, who studies software teams, calls this issue cognitive debt. Unlike technical debt, which exists in the code, cognitive debt exists in people. It builds when teams no longer understand the systems they’re building—and no dashboard alerts them to the problem.
Storey first observed this with students using AI to build software. Initially, they moved quickly. Then, they hit a barrier: they couldn’t make changes. Not because the code was messy, but because they’d lost track of the product’s purpose and reasoning. One team had a single person who understood the code—not because they wrote it, but because they supervised the AI that generated it. Even that individual didn’t fully grasp what the AI had produced.
Related: AI Testing Needs Better Security Measures
Large language models can explain how code works, but they can’t answer deeper questions: Why was this implemented this way? What assumptions were made? How does this fit into the product’s roadmap? Those answers reside in the minds of the team, not in the code. When AI takes over writing, that context disappears unless deliberately preserved.
The risk isn’t theoretical. Teams moving too fast with AI may ship features they don’t understand, making future changes harder and more prone to errors. Productivity gains are real, but without maintaining shared mental models, speed creates new problems.
Shifting knowledge sharing earlier
The solution isn’t to stop using AI-generated code. It’s to rethink where and how knowledge sharing occurs. Vanitha Kumar, Market Technology Director at ThoughtWorks, created an agent to catch anti-patterns and explain them to developers unfamiliar with her team’s practices. The agent reviewed code against documented standards, flagged deviations, and clarified their importance. What began as a teaching tool evolved into a way to move knowledge sharing to an earlier stage.
Kumar realized code review—whether by humans or AI—happens too late. By the time a pull request is submitted, decisions are already finalized. The real opportunity lies in capturing those decisions as they’re made, before the code is written.
The concept isn’t entirely new. Teams have long discussed “shifting left” to move testing, security, and other checks earlier in development. However, the focus has typically been on catching bugs, not preserving understanding. With AI-generated code, the stakes change. The challenge isn’t just verifying functionality; it’s ensuring humans still grasp what they’re building and why.
Related: Top Cloud Providers Ranked by Gartner
Intent-driven verification as a solution
Some teams are adopting intent-driven verification. Instead of reviewing hundreds of lines of code, engineers document the decisions behind the implementation: architectural choices, tradeoffs, and acceptance criteria. These become the focus of the review, not the code itself.
Tools like Aviator Verify let engineers record the intent behind changes before submission. A reviewer sees a brief description of scope, a list of acceptance criteria, and notes on what’s excluded. The task shifts from “Does this code look right?” to “Are we solving the right problem with the right constraints?”
This method offers two advantages. First, it speeds up reviews. A senior engineer doesn’t need to read every line of a 600-line diff; they only need to understand the intent. Second, it preserves the knowledge-sharing function of code review. By documenting decisions upfront, teams build a shared understanding of what they’re building.
The change isn’t just about efficiency. It’s necessary for survival. Teams relying on AI to write code without capturing intent risk becoming dependent on tools they don’t understand. The person who supervised the AI might be the only one who knows how the system works—and even they may not fully grasp it. That’s an unstable way to build software.
Intent-driven verification won’t fix every issue. But it provides a way to retain the benefits of AI-generated code without losing the team’s collective understanding. The alternative—moving fast while understanding less—isn’t viable. Eventually, the speed itself becomes the obstacle.
