Rethinking code review for the age of AI agents
Robert C. Martin and industry leaders argue that engineers must shift from line-by-line code reading to reviewing intent, criteria, and architectural decisions as AI generates more software.
Robert C. Martin, widely known as Uncle Bob, recently revealed that he no longer reads 95 percent of the code produced by his AI agents. This admission marks a significant pivot in software engineering practices, suggesting that human reviewers can no longer keep pace with the speed of automated code generation. As teams integrate AI agents into their workflows, the traditional model of detailed line-by-line inspection is becoming obsolete, forcing a reevaluation of what constitutes effective oversight.
What happened
The discussion centers on a fundamental shift in how engineering teams approach code quality and review. Martin, whose book Clean Code has influenced generations of developers, argues that humans are too slow to manage code at the velocity required by modern AI agents. He suggests that maintaining high-level supervision is necessary, but direct engagement with every line of source code is now outside the human domain. This perspective challenges the long-held belief that code is primarily written for other humans to read, implying that the reader has changed from a human developer to an automated system or a higher-level abstraction.
Despite declaring code largely out of scope for human review, Martin does not abandon scrutiny entirely. Instead, he focuses on structural integrity and design patterns. He utilizes tools that visualize project architecture, allowing him to expand, collapse, and drill into specific components without wading through raw syntax. This method enables him to identify issues such as high Change Risk Anti-Patterns (CRAP) scores, low mutation-testing results, and incorrect dependency directions. By interacting with these dynamic diagrams, he can run what-if scenarios and adjust component layers before the code solidifies, effectively shifting the review process upstream from implementation to design.
Other industry voices offer nuanced perspectives on this transition. Ray Myers argues that those who claim to stop reading code are often engaging in a "lowercase" form of reading, where they selectively inspect critical areas while relying on automated verification for the rest. David Poll, who leads GitHub’s pull request and code review team, emphasizes that the goal is not to stop reading but to direct attention where it is most useful. He advocates for systems that highlight meaningful parts of a change, allowing low-confidence areas to fall away from the reviewer’s attention set. This consensus suggests that while the volume of code reviewed manually decreases, the strategic importance of the remaining review increases.
How it works
The new review model relies on three primary artifacts: intent, acceptance criteria, and decisions. Intent captures the purpose of the change, including what is in scope and what is deliberately excluded. This information is derived from the prompts and interactions between the engineer and the AI agent. Acceptance criteria are divided into specific requirements for the current change and invariant patterns from a team’s AI slop registry. A verifying agent, independent of the one that wrote the code, checks these criteria and provides evidence of compliance. Reviewers then assess whether the problem is being solved correctly within the defined constraints.
Decisions represent the architectural, behavioral, and technical choices made during development. Since AI agents handle most boilerplate, the human contribution lies in selecting libraries, defining data models, and determining error handling strategies. Reviewers focus on these decisions to ensure alignment with system goals. This approach preserves the mental model of the codebase, a concept Mitchell Hashimoto refers to as the whiteboard defense. Engineers must be able to explain why specific choices were made and where potential failures lie, ensuring that knowledge sharing remains intact even without line-by-line code familiarity.
Key details
- Robert C. Martin reports that he does not read 95 percent of the code generated by his AI agents, citing speed mismatches between humans and machines.
- The CRAP score, or Change Risk Anti-Patterns, is a metric from 2007 that combines cyclomatic complexity with test coverage to identify risky code.
- Dynamic UML-like diagrams allow reviewers to visualize dependencies and structure, enabling interactive adjustments before code is finalized.
- Verification agents check acceptance criteria against a team’s AI slop registry, providing evidence-based verdicts rather than requiring manual inspection.
- David Poll from GitHub states that the objective is to direct human attention to meaningful parts of a change, not to eliminate reading entirely.
- Ultimate responsibility for code remains with humans, as AI agents are considered entirely irresponsible and cannot own outcomes.
Why it matters
For engineering leads and developers, this shift requires a change in mindset from tactical checking to strategic oversight. The traditional code review served two purposes: ensuring alignment with standards and facilitating knowledge sharing. AI disrupts both by generating compliant code rapidly and obscuring the decision-making process. By focusing on intent, criteria, and decisions, teams can maintain quality without bottling up the development pipeline. This approach ensures that senior engineers spend their time on high-value architectural judgments rather than syntactic nitpicking.
Moreover, this model addresses the risk of knowledge silos. If only one person understands the AI-generated code, the team becomes vulnerable. By documenting decisions and requiring engineers to defend their choices, the team builds a shared mental model. This practice ensures that multiple people understand how the system works and why certain paths were chosen. It transforms code review from a gatekeeping exercise into a collaborative design session, fostering a deeper understanding of the system among all team members.
What you can do
- Implement tools that visualize code structure and dependencies, allowing reviewers to assess architecture before diving into implementation details.
- Define clear intent for each task, documenting what is in scope and what is excluded in the prompts provided to AI agents.
- Establish an AI slop registry to capture common patterns and errors, using it to automate the verification of acceptance criteria.
- Require engineers to document key technical and architectural decisions, creating a record that can be reviewed independently of the code.
- Train reviewers to focus on high-risk areas and strategic choices, using automated tests to handle routine validation tasks.
- Conduct regular whiteboard sessions where engineers explain their design choices and defend them against peer questions to reinforce shared understanding.



