Coding Agents Make Human Code Review Obsolete, New Paper Claims
After 50 years, LLM-powered agents can replace human inspection at lower cost and higher throughput.
Martin Monperrus, a leading software engineering researcher, has released a paper titled 'The End of Code Review: Coding Agents Supersede Human Inspection' on arXiv. The paper argues that coding agents—large language model (LLM)-based autonomous systems capable of reading, writing, testing, and repairing software—have crossed a threshold where traditional human code review is no longer a necessary component of a quality pipeline. Since Fagan formalized code inspection in 1976, human review has been the primary quality gate in software development. Monperrus contends that these agents can now serve every stated goal of code review—catching bugs, enforcing style, ensuring design consistency—at a lower cost and with significantly higher throughput than human reviewers.
The paper also warns that the naive integration model, where agents write code and humans remain mandatory reviewers, is a dead end. This hybrid approach, Monperrus argues, neither provides meaningful assurance (humans can't keep up with AI-generated changes) nor scales with the velocity of AI-assisted development. Instead, he suggests organizations should shift to agent-driven quality pipelines that include automated testing, static analysis, and agent-based review. The implications are profound: if adopted, this could eliminate a 50-year-old practice and fundamentally reshape how software teams ensure code quality, potentially reducing bottlenecks and accelerating release cycles dramatically.
- Paper argues coding agents can fulfill all goals of human code review since Fagan's 1976 formalization, at lower cost and higher throughput.
- Claims that mandatory human review as a gate for AI-written code is a dead end that neither assures quality nor scales with agent velocity.
- Suggests shifting to fully agent-driven quality pipelines with automated testing and review, bypassing human inspection entirely.
Why It Matters
Could end a 50-year software engineering staple, accelerating development but raising questions about accountability and oversight.