What Is Claude Code Review in 2026? AI Code Reviews Explained
Claude Code Review is Anthropic's managed AI service that reviews GitHub pull requests, posting findings as inline comments in six to ten minutes.
On 15 October 2026, Anthropic moved Claude Code Review out of research preview and made it generally available to Claude Team and Enterprise organisations. Code review sits inside the daily workflow of almost every software team, so the launch is worth understanding properly. Instead of a chatbot you consult when you are stuck, Code Review is a managed service that reads your pull requests and posts its findings as inline comments. Here is what it does, what changed since the preview, and whether your team should turn it on.
The short answer: Claude Code Review is Anthropic’s managed AI review service for GitHub pull requests. Multiple AI agents examine the diff and surrounding code, verify their findings, and post comments beside the relevant lines. It is available to Claude Team and Enterprise organisations, most reviews finish in six to ten minutes, and it never approves or blocks a merge.
What Claude Code Review actually is
Claude Code Review is the multi-agent pull request review system built into Claude Code, Anthropic’s agentic coding tool. It is not a linter and not a chatbot. When a pull request opens or updates, the service examines the proposed changes and the code around them, then reports what it finds. The engineering team keeps every decision: nothing is merged, approved or blocked automatically.
How a single review runs
According to Anthropic’s documentation, each review runs on Anthropic infrastructure in four stages. Several agents examine the diff and the surrounding code in parallel, looking for potential issues. A verification step then checks each candidate finding against the code and filters out false positives. The surviving findings are deduplicated, ranked by severity, and posted to the pull request as inline comments.
What it can and cannot do
The managed service has read-only repository access. It reads the proposed changes and surrounding code but does not build, run or execute anything. Findings arrive as comments and a check result, but Code Review never approves or blocks a pull request. Anthropic is explicit: a review with no findings does not mean the code is bug free or secure. Treat it as a diligent second pair of eyes, not a guarantee.
Quick, Standard or Deep: the three review levels
The general availability release introduced three review depths that an administrator assigns per repository. Standard is the default. The choice is a trade between thoroughness, speed and token cost, since reviews are billed on usage.
| Level | Best for | What you get |
|---|---|---|
| Quick | Routine codebases, documentation, low-risk changes | A fast pass over the diff that flags the obvious problems at the lowest token cost |
| Standard | Most production repositories | The default depth: parallel agents, verification and severity ranking on every review |
| Deep | Security-sensitive code, payment logic, core infrastructure | The most thorough analysis, with more agents and verification work per finding |
Because the level is set per repository, a sensible pattern is Standard everywhere and Deep on the handful of repositories where a missed bug is expensive. An administrator can also tune how often reviews run: after every push, once after pull request creation, or only on manual request.
What changed since the research preview
Anthropic says it used the preview period to make reviews faster, sharper and easier to tune. The headline number is speed: most reviews now finish in six to ten minutes, roughly three times faster than the twenty minutes typical during the preview. Findings are also shorter by design, stating the problem, what triggers it and the fix in a few sentences rather than long essays.
Anthropic also runs Code Review on its own pull requests to find where reviews slow its engineers down. For Enterprise customers there is a financial sweetener: eligible paid Enterprise organisations can claim between $10,000 and $50,000 in Code Review credits, with claims open from 15 October 2026 through 15 January 2027. The credits expire 30 days after they are claimed, so the sensible order is to configure repositories first and claim second.
Setting it up on your repositories
Setup is an administrator task. Once enabled, developers get reviews automatically with no configuration on their side:
- Enable Code Review in the organisation’s Claude Code settings. This requires a Claude Team or Enterprise plan.
- Install the Claude GitHub App and grant it access to the repositories you want reviewed. GitHub Enterprise Server and GitHub Enterprise Cloud with data residency are supported.
- Choose a review depth per repository: Quick, Standard or Deep. Standard is the default and suits most codebases.
- Pick a review frequency. Newly added repositories start with a review after every push; you can switch to one review after pull request creation or manual requests only.
- Set the organisation-wide spending cap and, if eligible, claim the Enterprise credit offer after the repositories are configured.
Claude Code Review vs GitHub Copilot and Cursor
Code Review is not the only AI reading pull requests. GitHub Copilot has its own code review features, and Cursor has built review workflows into its agent experience. If you are evaluating the broader landscape, our roundup of AI coding assistants compares the main options, and the rise of agentic coding explains why these tools now act on your behalf rather than just completing lines.
| Dimension | Claude Code Review | GitHub Copilot code review | Cursor |
|---|---|---|---|
| Form factor | Managed service, no editor needed | Built into GitHub and the editor | Built into the Cursor editor |
| Review engine | Multiple parallel Claude agents with a verification pass | Copilot models reviewing the diff | Agent-based review inside the IDE |
| Merge control | Never approves or blocks; advisory only | Advisory comments | Advisory, developer driven |
| Configuration | Per-repo depth levels, REVIEW.md standards file | Repository custom instructions | Project rules and custom modes |
| Billing | Token usage billed to the organisation, capped | Included in Copilot plans with limits | Included in Cursor plans with usage pricing |
The practical difference is where the review lives. Copilot and Cursor meet developers inside their existing flow, while Claude Code Review is infrastructure: it runs on Anthropic’s side and covers every pull request in an enabled repository without anyone changing tools. For a detailed head to head of the two editor-based options, see our GitHub Copilot vs Cursor comparison.
Getting useful reviews: the REVIEW.md pattern
The feature that separates a generic AI review from a useful one is the REVIEW.md file, where a team writes its review standards: what counts as a blocker, which patterns are banned, how strict to be about nits. The important design detail is where the file is read from. Claude Code Review reads REVIEW.md exclusively from the pull request’s base branch or the repository’s default branch, never from the version modified inside the pull request itself.
That choice blocks an obvious attack: a developer cannot ship a friendlier REVIEW.md alongside their code to loosen the standards judging it. New rules must be merged and reviewed separately first, so the root REVIEW.md should sit on a protected branch. Teams typically pair it with a CLAUDE.md file holding project context.
Pricing, billing and who is excluded
Anthropic publishes no flat per-review price. Reviews are billed on token usage, separately from the usage included in the Team or Enterprise subscription, and depth level, change size and surrounding complexity all affect the cost. The control is the organisation-wide spending cap: it resets each billing period, and Code Review skips a review when the remaining budget is below the expected cost of one review, leaving a comment on the pull request saying so.
Not every organisation qualifies. The service needs GitHub repositories and a Claude organisation, even when developers access Claude Code through Amazon Bedrock, Google Cloud’s Agent Platform or Microsoft Foundry. It excludes organisations with Zero Data Retention, the HIPAA configuration or customer-managed encryption keys, and it is not covered by Anthropic’s Business Associate Agreement.
Frequently Asked Questions
Is Claude Code Review available to individual developers?
No. General availability covers Claude Team and Enterprise organisations only. Pro, Max and Free plans are excluded, as are trials and lapsed subscriptions. Individual developers who want AI review of their code can use the review features inside tools like GitHub Copilot or Cursor, or run Claude Code’s agent locally, but the managed service with automatic pull request reviews is an organisation feature.
Does Claude Code Review work with GitLab or Bitbucket?
No, it is GitHub only. The service is built around the Claude GitHub App and pull requests, including support for GitHub Enterprise Server and GitHub Enterprise Cloud with data residency. Teams on GitLab, Bitbucket or other hosts will need a different review tool. Anthropic has not announced support for other platforms, so GitHub-only shops are the entire addressable market for now.
How much does Claude Code Review cost?
Reviews are billed on token usage to the organisation, separately from the subscription, and Anthropic publishes no fixed per-review price. Cost depends on the review depth, the size of the change and the complexity of the surrounding code. The organisation-wide spending cap is the main control: it resets each billing period and the service skips reviews it cannot afford, posting a comment to say so.
Can Claude Code Review approve or block my pull requests?
No. The service has read-only repository access, posts its findings as inline comments and a check result, and explicitly never approves or blocks a merge. Your team keeps the merge decision in every case. Anthropic also warns that a review with no findings does not mean the code is bug free or secure, so human review remains mandatory for anything consequential.
Which models power Claude Code Review?
Anthropic has not published the exact model behind each review; the service runs on Anthropic infrastructure as part of the Claude platform. The current model family includes Claude Opus 5.5, the flagship model for demanding work, and Claude Sonnet 5.5, the mid-tier model balancing capability and speed. Reviews benefit from the same generation of models developers use in Claude Code itself.
Conclusion
Claude Code Review is the most infrastructure-shaped take on AI code review yet: no editor to install, no workflow to change, just automatic reviews on every enabled pull request. Review times of six to ten minutes, per-repository depth levels and a spending cap make it controllable, and the base-branch REVIEW.md pattern shows real thought about agent safety. The takeaway: it is a strong second reviewer for Claude Team or Enterprise shops on GitHub, and irrelevant to everyone else. Enable Standard everywhere, point Deep at your riskiest repositories, and keep humans on the merge button.
