LGTM Is Not a Review

Coding agents multiplied the pull requests and the number of reviewers stayed the same. Review didn't stop. The reading did, and the approvals kept coming. Here is why a silent LGTM is worse than no review, and what we do instead: review what's risky, ship the rest.

Coderbuds Team
Coderbuds Team
Author

Every engineer knows the four letters. LGTM. Looks good to me.

Sometimes it means "I read this, I understood it, and I'll stand behind it." Sometimes it means "I trust you, it's Friday, I have a meeting." The approval looks identical either way, and for years that didn't matter much, because most approvals were the first kind.

Coding agents changed the ratio. This post is about what happened to review when the pull requests multiplied, why the answer is neither "review everything" nor "review nothing", and what we now do on our own repository instead.

#Team Review Was Right

It's worth saying first: the idea was good.

A second pair of eyes catches what the author can't see. The reviewer learns a part of the codebase they didn't write. The author explains a decision before it becomes a mystery. Nobody ships alone. Those are real benefits, and teams that did review well were better for it.

But team review rested on an assumption nobody wrote down: that a person could read everything the team produced. When people wrote the code, that held, roughly. One developer's output was about what another developer could review in a day, and the queue balanced itself.

#Then the Pull Requests Multiplied

Amp, Claude Code, Codex and the rest made writing a change close to free. The reading didn't get any cheaper.

We saw it first on ourselves. In the thirty days to 13 September, 298 of our 324 merged pull requests were agent-assisted. There are one or two of us committing. Nobody could have read all of them, and nobody did. Not one was reviewed by a human.

The wider data says the same thing at scale. Faros AI's telemetry found median time in review up 441% and pull requests merged with no review at all up 31%, which we wrote up in Everyone Got Faster and Nothing Shipped Sooner.

A longitudinal study of one mid-sized company's "2×" mandate, covering 802 developers and 196,212 pull requests from January 2024 to April 2026, shows where the pressure goes. Pull request volume grew 3.1× while the pool of developers acting as reviewers grew only 1.5×, so per-reviewer load roughly doubled.

None of this is news to anyone with a review queue. What's interesting is what reviewers do about it.

#The Approval Stays, the Reading Goes

They keep approving. They just stop reading.

The same study split human review into two kinds: reviews with a written comment, and silent approvals. As volume rose, reviews with a comment fell from about 39% of pull requests to about 21%, while silent approvals held at about 50%. At the median, a reviewer's commented reviews stayed flat at around three a month and their silent approvals roughly doubled. In the authors' words, "the added load fell on bare approval rather than substantive review."

That is the rubber stamp, measured. Carnegie Mellon researchers who analysed 3,100 practitioner discussions of code review in an AI world found people describing exactly this mechanism: "Reviewers might keep up for a sprint, but they'll burn out [or] worse, start rubber-stamping reviews" (Agarwal et al.).

The ceiling on attention was known long before agents. SmartBear's 2006 study of review at Cisco covered 2,500 reviews of 3.2 million lines written by 50 developers. Its conclusion still reads well: "LOC under review should be under 200, not to exceed 400. Anything larger overwhelms reviewers and defects are not uncovered" (SmartBear). An agent will happily produce 400 lines before you've finished your coffee, and then another 400.

Here is why the rubber stamp is worse than no review at all. The record says reviewed. The author assumes someone checked. The incident review finds an approval and moves on. The audit trail shows a named person signed it off. Every system downstream treats the change as having had a second pair of eyes, when what it had was a click.

No review is at least honest about what happened. LGTM without reading is a false statement written into your history. And because AI-written code is very good at looking right, a quick glance is more likely to pass it, which we covered in Your Code Review Stopped Being a Quality Signal.

#Three Honest Options

Once you accept that people can't read everything, there are three choices left.

Stop reviewing. Amp's own team does this openly: "Our core product team pushes to main… It's no longer necessary to open PRs and get reviews to catch bugs or little mistakes" (Amp). That is a coherent position, and at least the record is honest. We ended up here ourselves without ever deciding to, which is the worst way to arrive. The wider trend is going the other way, too: the Carnegie Mellon team found the share of merged agent pull requests with no human review fell from over half in mid-2025 to roughly 12% by February 2026.

Keep a person on everything. This is the official policy at most companies, and it is the one that produces the LGTM. The rule stays on paper and the reading quietly stops.

Spend people where a mistake costs something. Most teams already do this informally. Amp's Quinn Slack says it is "very rare that I will ship something without reviewing the code", and he skips review for analysis code, visual work and client-only changes with a low blast radius (talk, July 2026). That's risk tiering done by feel. Intercom made it formal: an agent approves 19% of their pull requests, it "won't approve large PRs", and downtime from breaking changes fell 35% while deploys doubled (Intercom).

Warp's recent post on the code review bottleneck gets close to the same place from a different direction. It scores merge risk on five criteria (verification, alignment, impact, rollback cost and error detection) so reviewers know where to look. Warp draws the line at keeping a person on every pull request: "I'm not going to suggest that we let the bots win and merge without human review; that's for a post-AGI world." That's a reasonable line to hold. Ours is one step further: for a change where little can go wrong, the score should decide whether a person is needed at all, and the record should say so plainly.

The third option is the only one where the approval means what it says. A person reviews fewer changes, and actually reads the ones they review.

#Review What's Risky, Ship the Rest

This is what Coderbuds now does, and how it works.

Every pull request gets a risk grade, based on the files it changes:

  • ⚪ Minimal: only docs or tests.
  • 🟢 Low: a small code change (up to 50 lines and 5 files), away from anything a person always reads.
  • 🟠 Elevated: more code than an AI review is trusted with, or the author's first change to the repository.
  • 🔴 High: CI or agent instruction files, a path your team marked sensitive, over your size standard, or something the analysis flagged as hard to undo, swallowing an error or weakening a safeguard.

Your review policy turns that grade into the review the change needs: none, an AI review, one person, or two people for a careful review. There are three policies. Skip trivial changes waves through docs and tests and reviews everything else. Review by risk gives small code changes an AI review, larger ones a person, and anything over your size standard or in a sensitive path two people. AI review for everything is for teams whose agents fix what the AI review finds and merge their own work.

You bring the AI reviewer: a Claude GitHub workflow, Claude Code Review, Copilot or one you already run. Coderbuds' own quality score never counts as the review. It does not grade its own homework.

Turn on Hold merges and the Review policy check fails until the review the change needs is in. Turn on Merge when ready and the coding agent that opened the pull request merges it once Coderbuds says it's ready. Coderbuds decides and the agent merges. Coderbuds never merges and needs no write access to your code.

The part that keeps it honest is the evidence. The Review tile on the dashboard shows how many changes went in on an AI review alone or needed none, and how often each kind was later reverted or fixed. If the routine changes that skipped a person start coming back, you'll see it, and you can move the line.

#What We Learned Running It on Ourselves

We run this on our own repository, on AI review for everything. In the first round of agent pull requests after review policies shipped, each took about ten minutes from opening to merge, and none needed a person.

Ten minutes is not the interesting part. The interesting part is that nobody wrote LGTM on any of them. Each one says what reviewed it: which AI reviewer, on which commit, with what result. When a person does review something now, it's because the change asked for one, and they have the time to read it properly.

And almost everything goes through that route. In the 30 days to 15 November, 111 of the 112 changes on our main branch came through a pull request, so nearly everything we ship carries a record of the review it actually had.

Two honest caveats. First, a round of pull requests on one small team is an existence proof, not a study, and the Review tile needs more than a few weeks of reverts and fixes before it tells us much. Second, a fast AI review can turn into a rubber stamp of its own if nobody checks whether it catches anything. That's why it has to be a reviewer you chose, why it has to fail when it finds a problem, and why its results sit next to what was later reverted.

#What Still Needs a Person

Some things always get a person, even under AI review for everything: CI workflows, CODEOWNERS, and the instruction files coding agents follow, such as CLAUDE.md and AGENTS.md.

The reason is simple. A pull request's own copy of those files is what reviews it. If an agent could change the review workflow, or its own instructions, and have that change approved by the review it just changed, the whole arrangement would be decoration. So those changes wait for someone who can read them, on our repository too.

Under the stricter policies the list is longer: dependency manifests, infrastructure, migrations, sign-in and permissions code, billing, and anything the analysis flags as hard to undo. That list is where a careful read pays for itself.

#Where to Start

You don't need any tool to find out whether you have this problem.

Take last month's merged pull requests and count the approvals that came with no comment at all, no inline note, nothing but the click. Then look at how large those pull requests were. If most of your approvals are silent and many of them are over a few hundred lines, your review step is mostly a record, not a read.

Then decide where you actually want a person. Write down the paths where a mistake is expensive. Put an AI reviewer on the routine changes. Let a person spend their attention on the rest, and keep a record of which changes held up so you can tell whether the line is in the right place.

If you'd like Coderbuds to do that for you, start with Review by risk without holding merges, and watch the Review tile for a week or two to see whether it calls changes the way your team would. Here's how the review policy works.

Coderbuds Team
Written by

Coderbuds Team

The Coderbuds team writes about DORA metrics, engineering velocity, and software delivery performance to help development teams improve their processes.

View all posts

You're subscribed!

Check your email for a confirmation link. You'll start receiving weekly engineering insights soon.

Want more insights like this?

Join 500+ engineering leaders getting weekly insights on DORA metrics, AI coding tools, and team performance.

We respect your privacy. Unsubscribe anytime.