The code review is dead; long live the code review | Thoughtworks United States

Enable javascript in your browser for better experience. Need to know to enable it?<br>Go<br>here.

Search

Close

Ask Tai

The code review is dead... long live the code review

What happens when the mechanics of the pull request change?

Blogs<br>Back

Blogs<br>Back

Close

Testing

Agile engineering practices

Blog

By

Cecilia Geraldo

Published: June 25, 2026

The code review has been a fundamental part of the practice of software engineering for decades. However, as AI writes increasingly more of our code, we need to entertain the possibility that its time may have passed. In 2026, the traditional asynchronous pull request (PR) review, the gatekeeper of the modern delivery pipeline, is breaking.

But if the code review is broken, possibly dead, what takes its place? As many of us in the industry have been reflecting on in recent months, the rigor needs to go somewhere.

The bottleneck of sudden abundance

For the last fifteen years, the pull request has been the industry’s default mechanism for quality control, mentorship and knowledge sharing. A developer writes code, packages it up and asks a peer to look it over before it merges into the main branch. When humans write code line-by-line, this workflow functions, albeit with well-documented friction. However, we’re no longer in a human-only coding environment.

With the rise of generative AI and agentic coding tools, the volume of code production has skyrocketed. An engineer can prompt an LLM to generate entire feature blocks, refactor legacy modules or spin up boilerplate services in a fraction of the time it takes to type them out.

We’re facing a crisis of the modern PR queue. If an AI agent can generate 500 lines of code in five seconds, but a human engineer still requires thirty minutes of deep cognitive focus to thoroughly review those same 500 lines, the review queue becomes a catastrophic bottleneck.

When faced with an overwhelming flood of code, human behavior adapts predictably but destructively. Reviews degrade into superficial rubber-stamping or pedantic nitpicking over style choices, the ultimate form of bike-shedding. The asynchronous wait times compound, killing the momentum of continuous integration and ballooning a team's work-in-progress (WIP). The mechanical act of a human line-by-line diff audit cannot survive the era of AI-generated software. In that sense, the traditional code review is dead.

The human core: mentorship and collaboration in a post-PR world

It’s important to acknowledge that for a generation of engineers, the PR description and its comment threads have been the primary vehicle for knowledge sharing and mentorship.

There’s a risk that losing the PR queue will deepen engineering silos and create a generation of developers who can prompt, but cannot critically evaluate system design. To prevent this, our approach to collaboration must evolve from asynchronous correction to synchronous co-creation.

Mentorship of intent, not syntax

In the past, a significant portion of code review feedback was syntactical or tactical: "Use a map here instead of a loop," or "we have a utility function for this." AI agents are already exceptional at this level of remediation, so mentorship needs to shift upward to the level of intent, architecture and business domain alignment.

Seniors must guide juniors in framing problems, evaluating trade-offs between competing architectural patterns and questioning the underlying assumptions of the product requirements. We are no longer teaching apprentices how to swing the hammer; we are teaching them how to read the blue-prints and understand the soil mechanics.

From asynchronous review to a return to mobbing

Asynchronous code reviews have always been an inefficient way to collaborate. In an AI-native world, this latency is untenable. We need, then, to leverage established synchronous practices like pair or mob programming.

Pairing changes flavor when an AI is in the room. It becomes a triad: a senior engineer, a junior engineer and an AI agent. The senior engineer models the critical thinking, the junior guides the execution and the AI accelerates the generation. This real-time collaboration ensures that knowledge is shared while the system is being shaped, rather than weeks later in a frantic rush to meet a sprint deadline.

Elevating collective ownership

When code is cheap to produce, it is easy to lose a sense of collective ownership. If you didn’t write or review it, is it really your codebase?

To maintain a healthy, shared mental model of our software, teams need to institutionalize new forms of alignment: this includes replacing stale documentation with lightweight, (perhaps AI-assisted) summaries of systemic changes and periodically reviewing parts of the codebase generated by agents as a team, not to find bugs, but to ensure everyone comprehends the system's current topology.

We need to stop treating code...