The code review is dead; long live the code review

2026-06-25 · Source: Thoughtworks Insights · Field: Technology & Digital — Software Development & Engineering, Artificial Intelligence & Machine Learning, Robotics & Autonomous Systems · Depth: Intermediate, medium

Summary

Published on June 25, 2026, by Cecilia Geraldo of Thoughtworks, this article argues that the traditional asynchronous pull request (PR) review, a cornerstone of software engineering for decades, is breaking down due to the rise of generative AI. AI agents can produce hundreds of lines of code in seconds, creating a catastrophic bottleneck when human engineers still require significant time to review. This shift necessitates moving beyond line-by-line diff auditing to a "supervisory engineering" paradigm focused on constraint design. The proposed evolution includes reframing Test-Driven Development (TDD) as executable specifications for AI, designing robust architectural guardrails, and fostering continuous comprehension through synchronous practices like mob programming and AI-assisted summaries, rather than relying on post-hoc manual reviews. The core objectives of code review—shared ownership, learning, and technical excellence—remain, but the mechanics must adapt.

Key takeaway

For AI Engineers and Architects designing software delivery pipelines, the traditional pull request review is a growing bottleneck. You must transition from line-by-line auditing to "supervisory engineering" by implementing front-loaded quality checks. Focus your efforts on defining executable system constraints, reframing TDD as AI specifications, and fostering synchronous collaboration through practices like mob programming to maintain architectural integrity and shared understanding in an AI-accelerated development environment.

Key insights

The rise of AI-generated code demands a shift from traditional asynchronous code reviews to synchronous, intent-focused "supervisory engineering."

Principles

• Mentorship must shift to intent, architecture, and business domain alignment.
• Rigor should move from post-hoc review to front-loaded constraint design.
• Collective ownership requires continuous comprehension, not just diffs.

Method

The article proposes shifting from manual gatekeeping to supervisory engineering. This involves reframing TDD as executable specs for AI, designing architectural constraints, and fostering continuous comprehension via synchronous practices like mob programming.

In practice

• Reframe TDD as executable specs for AI agents.
• Design robust type systems and architectural guardrails.
• Adopt mob programming for complex design areas.

Topics

• Code Review
• Generative AI
• Supervisory Engineering
• Pull Request Workflow
• Test-Driven Development
• Collaborative Programming

Best for: CTO, VP of Engineering/Data, Director of AI/ML, Software Engineer, AI Engineer, AI Architect

Related on AIssential

• Agentic Code Review — AI agents make code writing cheap, shifting the software engineering bottleneck to human verification and review.
• Beyond Code Review — Specification-Driven Development shifts focus from code review to continuous verification against evolving specifications.
• PR reviews were already broken. AI made it worse — AI-coding agents exacerbate PR review issues by generating high-volume, low-quality code from insufficient data, demanding a layered verification approach.
• Are Code Reviews Even Necessary? — Code reviews serve distinct purposes (policy, knowledge, critique); AI's code generation demands re-evaluating their "why" and human role.
• AI Coding Assistants Haven’t Sped up Delivery Because Coding Was Never the Bottleneck — AI coding tools shift bottlenecks from coding to specification and verification, demanding new team structures and workflows.
• merge house — AI code review automates initial checks but shifts risk to critical code areas near merge.

Open in AIssential →

Editorial summary, takeaway, and curation by AIssential. Original article published by Thoughtworks Insights.