If you ship code with a one- or two-person team, the pull request that has no second reviewer is where the bugs get in. Code Review for Claude Code is Anthropic's answer to exactly that gap: an automated reviewer that dispatches a small team of specialized agents at every PR, scores what they find, and posts only the findings it's confident about — as inline comments, on the exact lines, on your GitHub repo. It's the same review system Anthropic says it runs on nearly every internal PR, now in research preview for Team and Enterprise plans.

The one-line version: Code Review runs five specialized agents in parallel on each PR — conventions, bugs, git-history context, prior-comment follow-through, and comment accuracy — scores every finding 0–100, and posts only those at or above the default cutoff of 80. You enable it per repo and pick when it runs. The knob that matters is the confidence threshold.

What it is, in one screen#

Code Review is a cloud service, not a local agent loop. You connect it to a GitHub repository, and from then on it reviews pull requests without you starting anything. It's depth over speed by design: rather than one model skimming a diff, it fans out into agents that each own one class of issue, then filters aggressively so you're not drowning in low-value comments. Availability today is research preview on Team and Enterprise plans, enabled by an org admin.

The five agents, and why parallel matters#

The core idea is specialization. One agent trying to catch everything skims; five agents each reading the same diff for one thing can go deep. Per Anthropic's documentation, the reviewers cover:

  1. Convention compliance — does the change follow your CLAUDE.md rules? This is the one most standalone reviewers can't do, because they don't have your house conventions written down the way Claude Code already does.
  2. Bug detection — logic errors, boundary conditions, the mistakes that compile fine and fail in production.
  3. Git-history context — reading the surrounding history so a change is judged against how the code got here, not just the diff in isolation.
  4. Prior-comment follow-through — did this push actually address the feedback left on the previous round of review?
  5. Comment accuracy — do the code comments still describe what the code does, or did they go stale?

Running these concurrently is the same "isolate the work into focused agents" pattern that shows up across the agent stack right now — it's why subagents beat one long context for bounded jobs.

The confidence gate is the whole trick#

Most AI code reviewers fail not because they miss bugs but because they cry wolf — and a reviewer you learn to ignore is worse than none. Code Review's answer is a 0–100 confidence score on every candidate finding, with a default threshold of 80: only findings that clear the bar get posted. Everything else is dropped before it ever reaches your PR.

That single number is your tuning lever:

Before anything posts, findings are deduplicated and ranked by severity, then attached as inline comments on the specific lines, with a roll-up summary in the review body. It's the same find-then-filter discipline that separates a useful automated reviewer from a linter with opinions.

How to turn it on#

  1. Be on a qualifying plan. Code Review is in research preview for Team and Enterprise. If you're on those, an organization admin does the setup.
  2. Enable it per repository from your organization's Claude Code settings and connect the GitHub app to the repos you want reviewed. It's opt-in per repo, not all-or-nothing.
  3. Pick the trigger. Per repo, choose whether it reviews on PR open, on every push, or only when explicitly requested. Push-triggered is the tightest loop; on-request is the lightest. See the setup guide for the exact toggles.
  4. Tune the threshold after a week of real PRs, once you've seen where the noise floor sits for your codebase.

Because it runs in the cloud, there's no local process to babysit — a contrast with the background-agent PR queue you'd run yourself, and part of why it fits a team with no spare reviewer.

Should you use it over a standalone?#

If you already live in Claude Code, Code Review is the low-friction pick: it's first-party, it reuses your CLAUDE.md conventions directly, and it needs no new vendor. If you're not on a Team/Enterprise plan, the standalone reviewers do the same job well — we compared CodeRabbit vs Greptile vs Qodo for exactly that decision. The honest split: pick Code Review when Claude Code is already your home and you want the reviewer that speaks your conventions; pick a standalone when you want a mature, model-agnostic tool with its own feedback-learning loop.

Either way, the pattern to steal is the one Anthropic productized here — many specialized reviewers, one confidence gate — because it's the difference between a reviewer your team reads and one it mutes.