Anthropic Just Shipped the Code Reviewer That Catches What Humans Miss

84% of large PRs get findings. Less than 1% are false positives.

Anthropic released Claude Code Review yesterday.

It’s a multi-agent system that reviews every PR before your team does. The pitch: depth over speed. While your linters run in seconds, Code Review takes 20 minutes and costs $15-25 per PR.

Why would anyone pay that?

Because code output per engineer at Anthropic has grown 200% in the last year. When developers ship twice as much code, reviewers face twice the load. PRs get skims instead of deep reads. Complex changes get rubber-stamped. Bugs slip through.

Code Review is their answer. They’ve been running it internally on nearly every PR for months.

The numbers are hard to ignore.

Before Code Review, 16% of Anthropic’s PRs got substantive review comments. After: 54%.

On large PRs over 1,000 lines, 84% get findings. Average: 7.5 issues per review.

On small PRs under 50 lines, 31% get findings. Average: 0.5 issues.

The false positive rate: less than 1% of findings get marked incorrect.

How It Works

When you open a PR, Code Review dispatches multiple agents in parallel. Each agent specializes in a different class of issue. They examine the diff in context of your full codebase, not just the changed lines.

After the initial pass, a verification step checks each finding against actual code behavior. This filters out the false positives that make AI code tools annoying. The surviving findings get deduplicated, ranked by severity, and posted as inline comments.

Three severity levels:

🔴 Normal: Bug that should be fixed before merging

🟡 Nit: Minor issue, worth fixing but not blocking

🟣 Pre-existing: Bug in the codebase that wasn’t introduced by this PR

That last category is interesting. Code Review doesn’t just look at what you changed. It looks at what your changes touch. If you’re refactoring code next to a dormant bug, it flags that bug even though you didn’t create it.

The Bug That Would Have Broken Auth

Anthropic shared a case from their internal usage.

A one-line change to a production service came through. Looked routine. The kind of diff that normally gets a quick approval.

Code Review flagged it as critical.

The change would have broken authentication for the service. Easy to read past in the diff. Obvious once pointed out. The engineer who submitted it said they wouldn’t have caught it themselves.

The Bug Hiding in TrueNAS

The more revealing example comes from an early access customer.

During a ZFS encryption refactor in TrueNAS’s open-source middleware, Code Review surfaced a bug in adjacent code. A type mismatch was silently wiping the encryption key cache on every sync.

This wasn’t a bug introduced by the PR. It was a latent issue in code the PR happened to touch.

A human reviewer scanning the changeset wouldn’t have gone looking for it. The multi-agent system, examining the full context, found it anyway.

---

What’s inside the full breakdown:

→ The cost-per-bug math (when $20/review pays for itself)

→ The “every push” trap that can 10x your bill

→ Full setup walkthrough: GitHub App, repo selection, triggers

→ CLAUDE.md vs REVIEW.md configuration (with examples)

→ When to use Code Review vs the free GitHub Action

→ What Code Review won’t do (and why that matters)

This is a paid feature at premium pricing. Below: whether the ROI makes sense for your team and how to configure it without surprises.

7-day free trial. Cancel anytime. First subscribers get 50% off forever.

The Ultimate Code Review Guide 👇

1. The Cost Math