Reviewing in the Age of AI: Solving the Asymmetry of Code Generation
The advent of generative AI has fundamentally altered the software development lifecycle. While the time required to write code has plummeted, the time required to review it remains constant or even increases. This creates a dangerous asymmetry: code is being generated at a velocity that far outstrips the human capacity to audit it effectively.
When the cost of generating a pull request (PR) is near zero, the burden of ensuring quality shifts entirely to the reviewer. This shift often leads to two extremes: reviewers become overwhelmed by the sheer volume of PRs, or they succumb to "rubber-stamping," where code is merged without a critical eye simply to clear the backlog.
The Shift from Code Review to Plan Review
To combat this asymmetry, some teams are moving the point of intervention from the end of the process to the beginning. Instead of reviewing the final implementation, the focus shifts to reviewing the plan.
By collaborating and iterating on a technical plan before a single line of code is generated, teams can ensure alignment on architecture, logic, and edge cases. This reduces the risk of an AI generating a large volume of code that is fundamentally flawed in its approach, which is far more costly to review and reject than a simple plan document. When the plan is approved, the subsequent code review becomes a verification step—checking if the implementation matches the plan—rather than a discovery process for architectural flaws.
Leveraging AI Agents for Quality Assurance
While human-centric plan review is essential for high-level design, the tactical level of code review can be augmented by AI. The goal is not to replace the human reviewer, but to reduce the "cognitive load" on them.
Automated Review Passes
Some organizations are implementing a multi-layered review pipeline where code must pass through independent AI agents trained on company-specific coding standards, robustness, and quality patterns before reaching a human. This creates a filter that catches low-hanging fruit—such as docstring errors or style violations—allowing humans to focus on high-level logic.
Risk-Based Routing
Another emerging strategy is the use of "blast radius" assessment. By categorizing changes based on complexity and potential impact, teams can automate the merge process for low-risk changes while flagging high-complexity changes for rigorous human review.
"If it's low complexity / blast radius it gets auto merged. If it's high complexity / blast radius it gets flagged for human review."
AI-Augmented Human Review
Even when a human must review the code, AI can serve as a supplementary guide. Agents can generate descriptions of the code's intent and highlight potential issues for the human to investigate. This creates a symbiotic relationship where the AI handles the pedantic details that a "lazy human eye" might miss, while the human provides the final judgment on whether the flagged issues are actually concerns.
Conclusion
The traditional PR process was designed for a world where writing code was the hardest part. In the age of AI, the hardest part is now the review. By shifting left toward plan-based collaboration and utilizing AI agents to filter and augment the human review process, teams can maintain high code quality without becoming a bottleneck to the very velocity AI provides.