Anthropic just published How the Claude Code team does code review. Addy Osmani posted it on X this week, and it passed a million views in under a day.

It deserves the attention. It is also Claude reviewing Claude, all the way down.

What They Built

Claude writes about 90% of Claude Code. From June to September, merged PRs more than doubled, and the share that had to be reverted fell by more than 40%.

The flow has seven layers:

  • Verify first. Claude runs the tests and build. A subagent reviews the diff in a fresh context.
  • AI review on every PR. Agents hunt for bugs in parallel. Other agents vote on each finding. Only the survivors get posted.
  • Security review. A separate pass. Open findings block the merge.
  • Required CI. Red blocks the merge.
  • Risk tiers. A classifier reads the change and picks zero, one or two human approvers.
  • Merge queue, flags, staged release.
  • Fast rollback.

We think “did a human read the code?” is an imprecise proxy for “what could go wrong with this change, and which check, automated or human, is the right one to catch it?”

— Addy Osmani, Morgan Westlee Lunt and Qing Wang, Anthropic

I agree with that sentence completely. My setup has most of the same layers. The big difference is who does the reviewing.

The Missing Layer

Every reviewer in Anthropic’s post is Claude. The bug hunters, the voters and the security pass are all Claude. The article never mentions a different model.

Votes from the same model are not independent. If Claude has a blind spot, five Claudes share it.

My own benchmarks show this. I replay real changes from a production monorepo and grade them with the original fix’s tests. Each model fails the same way, run after run:

  • Opus failed the same two tests on one change in all four runs on current Claude Code. Gemini 4 Argon passed them every time.
  • GPT-6 Sol dropped the same user-facing instruction in all four runs at medium, high, xhigh and max effort. GPT-6.1 Sol did it too. Sonnet never did it once in 80 runs.

Run the same model again and you get the same miss. Ask a different model and the miss often goes away. Not always: on one change, no model from any lab passed.

My loop adds a second model. After Claude reviews, Codex, Grok or Gemini reviews the same diff. Claude then checks each finding against the code and throws out the false ones.

So I checked my logs: Sep 20 to Oct 27, 597 second-model review reports.

  • 51 reviews ran on the same change (matched by PR, branch or commit) after a Claude review.
  • 45 of 51 found at least one bug that held up when Claude checked it.
  • 29 of 51 found a serious one. That is 44 serious bugs across about 10 changes.
  • About 1 in 4 second-model findings were wrong, and Claude discarded them.

What Claude passed, and the other models caught:

  • A refund counted twice after a Stripe timeout. Codex and Grok each found it on their own.
  • A local control server that took unauthenticated POSTs, so any web page could stop the app.
  • A file path that escaped its folder through encoded slashes. One user could read another user’s files.
  • An empty secrets source that passed the deploy gate, so a deploy kept stale secrets.
How rough these numbers are

My Claude reviews ran at medium effort. Some commits landed between the two reviews, so a few of those bugs are new, not missed. One big FameCake PR gives 12 of the 29 serious finds. A small model pulled the counts from the reports, and I spot-checked them. This is a signal, not a benchmark.

What They Do Better

Anthropic’s process beats mine in two places.

  • They cap the rounds. One of their PRs went through more than 50 review rounds overnight. Now the reviewer stops after three rounds and asks the author to rethink. I have no cap. That FameCake PR went round after round, and each round found more refund bugs. Many were real. Some may have come from the previous round’s fixes.
  • They score the reviewer. Every past incident becomes an eval case. Any change to the reviewer’s prompts, tools or model must raise the score, or they drop it. I backtest my code against real history, but I have never scored my reviewers. I don’t know if Grok earns its place next to Codex. I just like that it disagrees.

They also keep humans in the loop for risky paths: billing, the auto-updater, CI files. An agent’s approval never counts as a person’s. In most of my repos, no person is in the loop. I am the gate.

The Lessons

  • Add a different model. It is the cheapest layer on the stack. One CLI call, and a different set of blind spots.
  • Make the host verify. About 1 in 4 second-model findings were wrong. Without a check, you spend the next round fixing bugs that are not there.
  • Cap the loop. Two agents can keep each other busy forever. Three rounds, then step back.
  • Score your reviewers. Turn your incidents into an eval set. Otherwise you don’t know which reviewer finds the bugs and which one makes noise.

Anthropic ends the post by asking what they have wrong. Here is my answer: every vote in their stack comes from the same model. Ask a model from a different lab.

Related Posts

A Dial Worth Turning: Claude Opus 5's Prose, and the Style Guide Anthropic Wrote Against Its Own Model
[7 MIN]

A Dial Worth Turning: Claude Opus 5's Prose, and the Style Guide Anthropic Wrote Against Its Own Model

Opus 5 writes 510 words where Opus 4.5 wrote 158, with 2.3 times the em dashes and twice the 'load-bearing'. Arena measured it, Hacker News named it, Reddit downgraded over it. Anthropic's answer arrived in Fable 5.1's prompting docs: a paragraph defining 'mannered prose', with the model's own tics as the examples, for you to paste into your prompt. The vendor wrote the style guide against its own model, and shipped it as your job.

llmclaude-codeworkflow