The Claude Code team at Anthropic doesn’t do code review the way you probably do it. They don’t treat it as a gate at the end of the pull request. They don’t wait for a colleague to read your diff before merging. Instead, they ask a different question: what could actually go wrong with this change, and what’s the right check to catch it?

That shift sounds subtle, but it changed when review happens and who (or what) does it. Most code gets reviewed by Claude at least once before any human looks at it. Review runs continuously while you write, more like a spellcheck than a checkpoint.

The team wrote about their approach this week, and it’s worth reading if you’ve ever wondered what happens when the people building AI coding tools actually use them on their own codebase. The core insight is that “did a human read the code?” is a proxy metric, and not a great one. Some changes need human judgment. Others need automated checks that humans are bad at. Lumping everything into a single PR review process treats all risk the same.

So they split it up. AI catches the mechanical stuff early: style inconsistencies, obvious bugs, missed edge cases, tests that should exist. Humans focus on architecture decisions, API design, whether the change actually solves the problem. The review that needs to happen before you write the code happens before you write it. The review that can happen after you commit happens after you commit.

This isn’t just Anthropic moving fast and breaking things because they can. It’s a bet that the “review everything in a PR” model was always a compromise, and that we kept doing it because we didn’t have better tools. Now we do.

What this actually looks like

The details matter here. Continuous review means Claude is checking your code while you write it, flagging issues in real time. By the time you’re ready to open a PR, you’ve already addressed the mechanical problems. The human reviewer sees cleaner code and can focus on harder questions.

It also means review doesn’t block merging for every change. Low-risk changes, already vetted by automated checks, can go straight in. High-risk changes still get human eyes, but the humans aren’t spending time on formatting and missing semicolons.

The shift required rethinking what review is for. Traditional code review bundles together quality checks, knowledge sharing, consistency enforcement, and risk mitigation. Anthropic pulled those apart and assigned each to the right tool. Some things AI is legitimately better at. Some things still need a person.

The benchmark gap

Speaking of things AI is better at: Mercor Research released findings this week showing that 90% of US working hours are spent on tasks not covered well by current AI benchmarks.

That’s a problem if you’re trying to figure out whether AI can actually do your job. Benchmarks like HumanEval and MMLU test narrow, well-defined tasks. Real work is messier. It involves context-switching, dealing with incomplete information, coordinating with other people, making judgment calls when the requirements are vague.

Code review, as it turns out, is exactly the kind of task that doesn’t fit neatly into a benchmark. It’s not “can you spot the bug in this function” (though that’s part of it). It’s “does this change make sense given what we’re trying to build, and what problems might it cause six months from now?”

That’s why Anthropic’s approach is interesting. They’re not trying to automate code review entirely. They’re automating the parts that benchmarks actually measure, and leaving the rest to humans. The 90% problem isn’t that benchmarks lie. It’s that they measure the 10% of work that’s easiest to measure, and we forget about the rest.

What this means for your team

You probably can’t copy Anthropic’s setup directly. They build the AI tools they use. They can customize Claude to understand their codebase in ways you can’t. But the principles transfer.

Ask what could go wrong with a change instead of whether a human read it. Run checks earlier in the process instead of batching them at the end. Split review into pieces and assign each piece to whoever (or whatever) can do it best. Stop treating all changes as equally risky.

The tooling is getting there. GitHub Copilot, Cursor, and other AI coding assistants already catch obvious issues while you write. CI systems can run deeper analysis before humans get involved. The missing piece isn’t the technology. It’s the process that puts it all together.

Anthropic’s team built that process. Whether it works outside Anthropic is an open question, but it’s worth watching. If the people building AI coding tools think traditional code review is broken, that’s a signal the rest of us should probably pay attention to.