Claude Code Review: What It Is and How Teams Use It
Learn what Claude Code Review does, how hosted PR reviews differ from local checks, and where tests, team policy, and human approval still fit.

Claude Code Review can mean two different things. Anthropic now offers a hosted pull-request review product for Claude Team and Enterprise organizations, while anyone already using the Claude Code CLI can ask a local session to inspect a branch or run /code-review. The hosted service connects to GitHub and can review pull requests automatically or manually, based on the repository trigger. A local review runs when you invoke it. Neither one replaces tests, branch protection, or the person accountable for merging.
That distinction matters before a team changes its workflow. The hosted product is an organization-level service with repository settings. The CLI is an individual coding session. This guide explains where each fits, how to govern review policy when a pull request may touch it, and how to test a review workflow against known defects before trusting its output.
What is Claude Code Review?
Claude Code Review is Anthropic's hosted pull-request review service for Team and Enterprise organizations. An administrator enables it, installs the GitHub App, selects repositories, chooses a review depth, and configures an automatic or manual trigger. Anthropic moved the product from research preview to general availability on October 15, 2026.
The name is easy to confuse with ordinary Claude Code. If you open Claude Code in a terminal and ask it to review your current branch, that is a local session. The /code-review command is also a local workflow. It may inspect a diff and related repository context, but it is not the same service as an organization administrator installing the hosted GitHub App.
| Workflow | Where it runs | How it starts | Policy context | Best fit |
|---|---|---|---|---|
| Hosted Code Review | Anthropic's Team or Enterprise service connected to GitHub | Automatically or manually on pull requests after admin setup | Root-level repository REVIEW.md and CLAUDE.md guidance |
Consistent organization-level PR review |
Local /code-review |
Your Claude Code CLI session | A developer invokes the command | Current local repository and session instructions | Reviewing a branch before or during a PR |
| Plain local review prompt | Your Claude Code CLI session | A developer asks Claude to inspect a diff | Whatever files and instructions the session reads | A focused second pass or one-off investigation |
| Human review | Your Git provider and team workflow | A reviewer opens and evaluates the PR | Product requirements, risk, ownership, and organizational context | Approval, tradeoffs, and accountability |
Anthropic's general-availability announcement says the hosted product is available for Team and Enterprise plans. Its current Code Review product page separately describes /code-review for users on other plans. Having Claude Code already is enough to run a local review, but not proof that your account can enable hosted Code Review.
Which Claude review workflow should you use?
Use hosted Code Review when an organization wants automatic, centrally configured reviews on GitHub pull requests. Use a local Claude Code review when a developer wants feedback before opening a PR, needs to investigate one branch, or does not have the hosted product. Keep human approval for decisions the tools cannot own.
The workflows can be layered. A developer can run a local review before pushing. Deterministic tests and static analysis can run in CI. Hosted Code Review can examine the submitted PR. A human can then evaluate the findings, requirements, and operational risk before merging.
The hosted service has read-only repository access for the review and does not build or run the code. Anthropic says it posts ranked findings as inline comments, but it does not approve a pull request or block a merge. Those boundaries make CI results and a named human decision part of the workflow, not optional cleanup after the review.
Do not count the same model output as three independent checks just because it appears at three stages. If local and hosted reviews share similar context and instructions, their failures may be correlated. Independence comes from different evidence: an exact test, a type checker, a security rule, production telemetry, or a reviewer who understands the requirement.
How do you set up hosted Claude Code Review?
An organization administrator enables Code Review in Claude Code settings, installs the GitHub App, and selects the repositories to review. A repository can run a review once when a pull request opens, after every push, or manually after a top-level @claude review comment. Confirm the current permissions, supported repositories, billing, and rollout controls in the official setup guide.
A cautious rollout looks like this:
- Start with one repository whose owners can inspect every result.
- Record which branches and pull requests are in scope.
- Choose a review depth appropriate to the repository's risk and change volume.
- Add a small, behavior-focused
REVIEW.mdat the repository root, then protect changes to it. - Keep existing CI checks and required human reviewers in place.
- Track accepted findings, rejected findings, missed defects, review time, and cost separately.
- Expand only after the team can explain the observed failure modes.
Anthropic offers Quick, Standard, and Deep review depths per repository, with Standard as the default in its announcement. Anthropic also reports that most reviews now take about 6 to 10 minutes, compared with about 20 minutes during preview. Those are vendor-reported product figures, not measurements reproduced in our experiment.
As of November 2026, Anthropic's setup guide says reviews average $15 to $25, vary with pull-request size and complexity, and are billed separately through usage credits. Treat that as current vendor pricing guidance, not a fixed quote. Measure your own cost per accepted finding during the limited rollout before enabling every repository.
Review your broader Claude configuration at the same time. Our guide to Claude Code settings for teams explains how to separate shared repository settings from user preferences and centrally managed policy. Code Review adds another review surface; it does not make configuration ownership less important.
How should your team govern REVIEW.md?
Anthropic's setup guide says a root-level REVIEW.md adds review-specific guidance, including project conventions, required integration tests, and generated-code exclusions. The current official documentation does not say which version wins if a pull request edits that file. Do not assume the hosted reviewer will always use a protected base-branch copy.
That uncertainty creates a governance problem: one change could alter both the code and the instructions used to judge it. Treat REVIEW.md as policy even though it is stored as code. Require normal ownership and branch controls around policy edits, and have a person check any pull request that changes the rules and implementation together.
Turn that design into an explicit team process:
- Protect the default and release branches with your Git provider's normal controls.
- Require a separate reviewed PR for changes to
REVIEW.md. - Put the file under an appropriate
CODEOWNERSrule if your repository uses one. - Describe observable failure behavior, not vague preferences.
- Keep security, data-loss, compatibility, and state-transition rules near the top.
- Test examples at exact boundaries, including empty input, permission changes, timeouts, and state names shared across files.
REVIEW.md is not a general replacement for CLAUDE.md. The hosted product uses the former for review guidance. Local Claude Code sessions often use repository instructions from CLAUDE.md. Our guide to useful CLAUDE.md files covers that broader project context. Keep each file's job clear so an instruction written for implementation does not accidentally become an approval policy.
How can you test whether a code review catches real defects?
Seed a disposable repository with known, observable defects, preserve an independent oracle outside the reviewer's context, and score findings against a fixed rubric. Run ordinary tests first so the exercise includes defects that a shallow green test suite misses. Repeat each review condition and retain failures as well as successes.
We built a five-defect Python fixture for that purpose. A clean baseline commit, 579ae63fd3179100ad7ee96839bba0bd59f20519, was followed by a defect commit, 7f11221af27d1e4283f7b8224cecc6e3633228a4. Five ordinary smoke tests passed on the defect branch. A separate oracle then observed every planted defect:
| ID | Defect class | Observable failure |
|---|---|---|
| D1 | Authorization | A caller can retrieve another owner's invoice because ownership is not checked |
| D2 | Async ordering | A write is created but not awaited, so the immediate read returns no value |
| D3 | Boundary condition | Exact 5,000 and 10,000 cent thresholds receive the lower discount tier |
| D4 | Failure semantics | A broker timeout is swallowed and the operation reports success |
| D5 | Cross-file state mismatch | One file emits reviewed, while the merge check accepts only approved or ready |
The scoring rubric required a finding to name the affected behavior and give a technically correct reason tied to the planted change. Vague style comments did not count. Duplicate descriptions of one defect counted once. That is the same general discipline described in our AI agent testing guide: define the observable contract first, keep the oracle separate, and do not let a candidate grade its own work.
The planned comparison had three conditions, with two fresh runs each:
- A plain fresh-context review of
main...HEAD - The native local
/code-reviewworkflow - The native local
/code-reviewworkflow with a repositoryCLAUDE.mdreview policy
Each invocation was noninteractive and nonpersistent, restricted to the fixture, denied editing and web tools, and capped at $0.75. The six-run plan therefore had a hard theoretical ceiling of $4.50. The fixture ran under Claude Code 2.1.311. These conditions tested the local CLI only, not Anthropic's hosted Team or Enterprise product.
What did the five-defect benchmark show?
The benchmark verified the fixture and oracle, not Claude's review accuracy. All five planted defects were present and observable, the defect branch's five smoke tests still passed, and the repository was clean. The first review invocation then stopped at authentication, so there are no valid precision, recall, latency, or comparative performance results.
The exact CLI error was:
Failed to authenticate: OAuth session expired and could not be refreshed
The failed invocation reported $0 cost and zero input and output tokens. We did not run the second repetition or either /code-review condition after that blocker. Retrying an uncertain or failed paid operation until it produces a convenient result would damage the record, so the failure remains part of the experiment.
This is a useful boundary, not an embarrassing footnote. The independent evidence supports three statements: the fixture contains five observable defects, the smoke tests miss those cases, and the planned review execution was blocked before producing findings. It does not support a claim that Claude found zero defects, found all five, improved with policy, or outperformed a person.
To finish the experiment, refresh Claude Code authentication, resume at the first condition, preserve the original prompts, and run all six planned invocations without changing the rubric after seeing results. Report true positives, false positives, cost, and failures by condition. Keep hosted Code Review results in a separate experiment because it is a different execution surface.
Where does review fit when several coding agents share a repository?
Code review inspects a proposed change. Coordination records who is doing what, where work overlaps, and which person owns a decision. A review tool can identify a defect in a pull request without knowing that another agent is editing the same file or implementing an incompatible requirement in another branch.
For teams using Claude Code agent teams, keep these concerns separate:
- Assign a task and record its intended files and acceptance criteria.
- Isolate implementation work in a branch or worktree when practical.
- Surface overlapping intent before two agents create conflicting patches.
- Run exact tests, linters, type checks, and repository-specific validation.
- Run a local review before the PR when the author needs fast feedback.
- Let hosted Code Review inspect the submitted PR if the organization has enabled it.
- Have a person resolve disputed findings and approve or reject the merge.
When several approved agent PRs may interact, send them through a GitHub merge queue so CI verifies the combined state that would actually land.
When those pull requests depend on one another, GitHub stacked pull requests give reviewers an explicit bottom-up order before the final integration check.
SYNCStaff can support the coordination part by recording work intent, advisory file leases, overlaps, shared board state, and human decisions. Its supported hooks can block some named file-edit tools, but shell writes can bypass those hooks, and it is not a pre-commit, push, or merge gate. Claude Code Review remains a separate review system. Neither product guarantees that conflicting work or defects cannot reach a branch.
That separation keeps the handoff honest. A Code Review finding can become evidence on the shared task. The human responsible for the change can accept it, reject it with a reason, or request another test. The result should not silently change ownership or authorize deployment.
What should a person still review?
A person should still decide whether the change satisfies the intended requirement, whether residual risk is acceptable, and whether the evidence is enough to merge. Automated review can point to code, but it cannot own business tradeoffs, incident impact, legal obligations, or an undocumented product decision.
Give human reviewers the evidence they need instead of a second wall of generated prose:
- the requirement and affected users
- the diff and relevant code outside it
- deterministic test results and known coverage gaps
- Code Review findings with the triggering path
- unresolved disagreements and false positives
- migration, rollback, and observability plans when applicable
- the name of the person making the merge decision
Our human-in-the-loop guide treats approval as a defined checkpoint, not a ceremonial click. The reviewer should be able to say what evidence changed the decision and what remains untested.
For a bad change that has already merged, the GitHub rollback to previous commit guide separates a history-preserving revert from reset and fix-forward decisions.
A practical rollout decision
Use hosted Claude Code Review if your Team or Enterprise organization wants automatic GitHub PR reviews and can own the repository policy, billing, and result evaluation. Use local /code-review if you already have Claude Code and want a developer-triggered branch review. Use both only when each stage has a clear purpose.
Before expanding, run a defect pack drawn from your own failure history. Protect changes to the root-level REVIEW.md through normal code ownership and branch rules. Keep exact CI checks and required human review. Measure accepted findings, false positives, misses, delay, and cost without converting a vendor timing claim or one successful example into a reliability promise.
If several coding agents are producing pull requests at once, use SYNCStaff to record ownership, overlap, and the human merge decision. Send the PR through Claude Code Review as a separate evidence-producing step, then let the accountable reviewer decide whether the change is ready.
Frequently asked questions
What is Claude Code Review?
Claude Code Review is Anthropic's hosted pull-request review service for Team and Enterprise organizations. An administrator connects selected GitHub repositories, and reviews can run automatically or manually based on each repository's trigger. It differs from asking an ordinary Claude Code CLI session to inspect a branch or invoking the local `/code-review` command.
Can I use Claude Code Review with an individual Claude plan?
Anthropic's hosted Code Review product is documented for Team and Enterprise organizations. If you already use Claude Code individually, you can still ask a local session to review a branch or use `/code-review`. That local workflow is not the organization-configured GitHub App service described in the hosted product documentation.
What is the difference between REVIEW.md and CLAUDE.md?
Hosted Code Review uses a root-level `REVIEW.md` for review-specific guidance, such as conventions and required tests. Local Claude Code sessions use `CLAUDE.md` for broader repository instructions. Anthropic's current documentation does not say which `REVIEW.md` version wins when a pull request edits it, so protect policy changes through normal code ownership and branch rules.
Does Claude Code Review replace human code review?
No. It can inspect a pull request and produce findings, but a person still owns requirements, tradeoffs, risk acceptance, and the merge decision. Keep deterministic tests, static checks, branch protection, and required reviewers. Treat the automated review as evidence to evaluate, not as proof that a change is safe.
Did the five-defect experiment measure Claude's review accuracy?
No. The fixture and independent oracle verified that all five planted defects were observable while ordinary smoke tests passed. The first local Claude Code run stopped because its OAuth session had expired, before using tokens or producing findings. No later conditions ran, so no accuracy or performance result is claimed.