AI has finished writing the code for you, but no one is willing to take a serious look at it anymore.

Author: The Pragmatic Engineer

Compiled by: TechFlow

TechFlow Editor's Note: AI is writing code faster and faster, but humans are still reviewing the code. This contradiction is evolving into a crisis: engineers are overwhelmed by AI-generated PRs, either exhaustedly reviewing them carelessly, or simply approving them if AI doesn't report errors. Large companies are building their own tools to cope, but no one has a standard answer yet.

Hi, I'm Gergely, and this is a free supplement issue of the Pragmatic Engineer Newsletter. In each issue, I report on large tech companies and startups from the perspective of senior engineers and engineering leaders. Today we discuss one of the four topics from past issues of The Pulse. Full subscribers received this article a week ago. If this email was forwarded to you, you can subscribe here.

One thing I hear many engineering leaders care about most is how to cope with the continuously growing code review load. This topic has existed for a while, and now such conversations seem to be increasing.

For me, this started in January this year, when Opus 4.5 and GPT 5.4 started writing more and better code in most companies. Around that time, director-level people started discussing that the bottleneck of software development was shifting from the coding phase to the review phase.

The Explosion of AI Code Review Tools

Since February, AI code review tools have seen explosive growth to cope with the increased load. Experiments and adoption of specialized AI code review tools such as CodeRabbit, Greptile, Qodo, SonarQube (and now Gitar) are exploding. There are also tools provided by the coding tools themselves, such as Claude Code review, Cursor review, GitHub Copilot review. Then tools that previously did not involve code review but had context on the codebase are also joining this field, such as Sentry's Seer AI reviews, Linear code reviews.

Big Companies Building Internal Tools: Uber's Code Inbox

Large companies are building internal tools to improve the code review experience. Uber's Code Inbox is one case:

Smart assignment is a feature within Code Inbox used to advance the review process:

Figure: Code Inbox's Smart assignment settings, used to advance the review process. Source: The Pragmatic Engineer

There is also the Risk Profiles feature, used to assess the impact of changes and encourage developers to pay extra attention to high-risk changes:

Figure: Code Inbox's Risk Profiles feature, estimates code change risk and prompts key focus. Source: The Pragmatic Engineer

We have reported on how Uber uses AI for software development, and not just Uber: Cloudflare (AI Code Reviewer), Faire (Fairey), HubSpot (Sidekick) and many other companies have also built tools to make their code review process smoother, because they found internal implementations work better than integrated vendor solutions.

Shifting from "Review" to "Verification"

Another approach is to think about how to verify code, rather than review code. Easier said than done; theoretically, thorough testing should be able to verify that the code works as expected. But how much testing counts as "thorough"? What type of testing are we talking about? Are integration tests and end-to-end tests included? What about fuzz testing? Formal methods? How to verify that new tests cover features as expected? How do we connect all of this with observability?

Over-Reviewing Is Dragging Down Engineers

Too much thorough code review is exhausting engineers and leading to a decline in review quality. I hear many rumors that developers see others no longer able to review code carefully; if AI code review has no substantive comments, they just approve it. Meanwhile, those developers who invest the same energy and time in code review as before feel overwhelmed by the AI junk PRs sent to them.

The Problem Exists, Solutions Remain Experimental

The problem exists, but solutions feel more like experiments.