Agent-written code breaks what code review was for
Code review was never mainly about catching bugs. It kept the team's mental model aligned, and agent-written code breaks that loop before anyone has built the replacement.
Written by
-
Benedikt Stemmildt Founder & Co-CEO
Published: 18 March 2026 Updated: 2 min read
Code review was never about catching bugs. It was about keeping the team’s mental model aligned.
When Bob changes the accounting subsystem, Amy reviews it so her understanding stays current. She asks questions. Bob clarifies design decisions. A month later, Amy changes that same subsystem without reading everything from scratch.
That is the real value: mental alignment, design discussion, shared ownership. Bug catching was secondary. Style was the least important part.
AI-generated code breaks this entire model.
The scale problem
In Faros AI’s telemetry, developers on teams with high AI adoption complete 21% more tasks and merge 98% more pull requests. PR review time increases 91%.
The number of changes and the size of changes are both scaling exponentially. There is no way to win this with manual review.
The deeper problem
The mental alignment model assumed humans wrote the code. Amy reviewing Bob’s work means Amy and Bob now share an understanding of that subsystem. Amy reviewing an agent’s output? She gains no insight into how the next change will be made. The agent has no memory of her feedback. No learning curve. No relationship.
The knowledge transfer loop is broken.
Move the checkpoint from the diff to the intent
The human checkpoint has to move upstream, from reviewing code to reviewing intent.
- Review the spec, not the diff. If the spec is right and the verification is automated, the code is an artifact.
- Define acceptance criteria before the agent writes anything, from the spec, not from the implementation.
- Layer your trust: deterministic guardrails, adversarial verification (one agent builds, another breaks), scoped permissions.
- Use code review for what still matters: “Are we solving the right problem with the right constraints?”
The old hierarchy and the new one
The old code review hierarchy, from most to least important:
- Mental alignment between team members
- Correct solution verification
- Design discussion
- Bug finding
- Style consistency
The new context review hierarchy:
- Intent alignment: does the spec capture what we actually need?
- Constraint verification: are the guardrails catching what humans used to catch?
- Architecture fitness: does this fit how our system should evolve? (Not new, just promoted because the layers below disappeared.)
- Context completeness: did the agent have everything it needed?
- Knowledge preservation: how do we keep a shared understanding without the review loop?
The problem still open
That last one is the hard problem nobody has solved yet. Code review was our primary knowledge-sharing mechanism. We killed it before we built the replacement.
How is your team handling the knowledge transfer gap? Or are you still pretending manual review scales?
(Source: Faros AI, The AI Productivity Paradox Report 2025 (opens in a new tab), July 2025, telemetry from more than 10,000 developers on 1,255 teams.)
Further reading
Written by
-
Benedikt Stemmildt · Founder & Co-CEO
More on Specification and review
- AI velocity without engineering discipline fires slop A framework sorts tech roles into four archetypes, and it reads like a raid party. AI rollouts without engineering discipline add damage output with no tank and no healer. Agentic engineering balances the party.
- AI writes your tests, but not the one for the right problem A suite at 94% coverage, every test green, for a feature no user completed. The test that checks the business need depends on context only humans can supply.
- Cheap code makes engineering discipline worth more Generating code got cheap, and anyone can do it. Engineering systems that hold up in production is the skill that gained value.
Test the constraint in your system
The Factory Readiness Assessment connects this research to your value stream, your data, and the next decision.
Training on this topic: Agentic Engineering for Developers and QAWant to check one team first? The self-check: twelve yes or no questions, three minutes, instant result, no account. Take the self-check