Anthropic's $15–25/PR Code Review is live. Should you use it? How do you control cost? Is your code used for training? We answer the questions every developer actually has—including the ones that aren't in the marketing.
March 12, 2026 (Today)
9 min read
Anthropic just shipped automated PR reviews at $15–25 per pull request. Before you enable it—or dismiss it—here are the answers you won't find in the launch post.
Code review has become a bottleneck everywhere. At Anthropic, code output per engineer grew 200% in the last year. Many teams are in the same spot: more AI-generated code, same number of human reviewers, and PRs that get a quick skim instead of a real read. In March 2026, Anthropic launched Code Review for Claude Code—a multi-agent system that reviews every PR in depth. It's the same pipeline they run on nearly every PR at Anthropic. Now it's in research preview for Team and Enterprise.
This post answers the questions developers actually have: cost control, privacy, when it's worth it, how it compares to alternatives, and the limitations that matter for your stack.
From Anthropic's Code Review docs: once an admin enables Code Review, reviews run automatically when a pull request opens or updates. Here’s the pipeline, as described by Anthropic.
1. Parallel analysis. Multiple agents run on Anthropic’s infrastructure and analyze the diff and surrounding code in parallel. Each agent looks for a different class of issue (e.g. logic errors, security issues, edge cases, regressions).
2. Verification. A verification step checks candidate findings against actual code behavior to filter out false positives. So what you see isn’t raw model output—it’s been validated.
3. Dedupe and rank. Results are deduplicated, ranked by severity, and then posted as inline comments on the specific lines where issues were found. If no issues are found, Claude posts a short confirmation comment on the PR.
4. Scale with PR size. Review depth and cost scale with PR size and complexity. Large or complex PRs get more agents and a deeper pass; small changes get a lighter pass. Average time to completion is around 20 minutes.
Each finding is tagged with a severity level:
| Marker | Severity | Meaning |
|---|---|---|
| 🔴 | Normal | A bug that should be fixed before merging |
| 🟡 | Nit | A minor issue, worth fixing but not blocking |
| 🟣 | Pre-existing | A bug that exists in the codebase but was not introduced by this PR |
Findings also include a collapsible extended reasoning section you can expand to see why Claude flagged the issue and how it verified the problem.
Admins choose, per repository, when Code Review runs:
The official docs have full setup, customization with REVIEW.md / CLAUDE.md, and the analytics dashboard at claude.ai/analytics/code-review.
Code Review is a managed service that runs when you open a pull request. It doesn't replace your existing GitHub Action or your human reviewers. It adds a deep, multi-agent pass before (or alongside) human review.
Do you need it? If your team is already on Claude Team or Enterprise and you feel like many PRs get light review, it's worth trying. If you're on GitHub only and want depth over speed, it fits. If you're on GitLab/Bitbucket or need sub-minute reviews, it's not for you yet (see limitations below).
Pricing is per review, not per seat: about $15–25 per PR, depending on size and complexity. So 100 PRs/month might land in the $1,500–2,500 range if they're average; large refactors cost more.
Controls that actually matter:
So you can limit cost by: (1) enabling only on critical repos, (2) setting a monthly cap, and (3) using the dashboard to see where the spend goes.
Important catch: Code Review is not available for orgs with Zero Data Retention. If your company requires zero data retention with vendors, you can't use this managed Code Review. In that case your option is the open-source Claude Code GitHub Action (anthropics/claude-code-action), which you run yourself (e.g. in GitHub Actions) and which doesn't send PR content to Anthropic's managed service in the same way. Check with your security/compliance before enabling.
Short answer: for commercial use (Team/Enterprise), your data is not used for model training by default.
Code Review runs in the same commercial bucket: your PR content is processed for the review, not for training, unless you've opted into the partner program. For full assurance, confirm with your legal/compliance and Anthropic's current privacy and security docs.
| Claude Code Review | CodeRabbit | GitHub Copilot Code Review | Claude Code GitHub Action | |
|---|---|---|---|---|
| Model | Per-PR ($15–25) | Per seat (~$24/dev/mo) | Per seat (~$19/mo Business) | Free / you pay API/compute |
| Speed | ~20 min | 9+ min | ~30 sec | Depends on your runners |
| Depth | Deep, multi-agent | Strong (e.g. security) | Fast, surface-level | Configurable, you control |
| Platform | GitHub only | GitHub, GitLab, Azure DevOps, Bitbucket | GitHub | GitHub (self-hosted in Actions) |
| Focus | Logic, correctness, security | Security + general | Quick pass, refactors | Whatever you configure |
When to pick Code Review: You want depth over speed, you're on Claude Team/Enterprise, and you're okay with GitHub-only and per-PR cost. Good for high-stakes or large PRs.
When to stick with CodeRabbit: You need GitLab/Bitbucket, per-seat pricing, or committable fixes and learning from feedback.
When to use Copilot: You want fast, cheap first-pass review and are already on GitHub Copilot Business.
When to use the GitHub Action: You need full control, zero data retention, or custom triggers (e.g. only when someone tags @claude). You trade off managed UX for flexibility and data locality.
Out of the box: Code Review focuses on correctness and logic—bugs that can break production—not style or formatting. Think: data handling, boundary conditions, API misuse, regressions, and cross-file consistency.
Customization: You can steer it with two files in your repo:
REVIEW.md – What to emphasize or ignore in reviews (e.g. “Flag any new env vars,” “Don’t nitpick naming in this legacy module”).CLAUDE.md – Project context and conventions. Code Review uses this (and directory-level CLAUDE.md for touched paths) so agents align with your patterns and standards.So you can keep the default “logic and correctness” focus and add project-specific rules and context without changing product settings.
Worth considering when:
Less compelling when:
For developers: Once an admin enables Code Review and installs the GitHub App, reviews run automatically on new PRs in the selected repos. No per-PR configuration required.
For admins:
Use repo-level enablement and monthly caps so cost and scope stay under control.
Anthropic shared a concrete example: a one-line change to a production service looked routine—the kind of diff that often gets a quick approval. Code Review flagged it as critical. That change would have broken authentication for the service. The engineer said they wouldn’t have caught it on their own. It was fixed before merge.
That’s the pitch: not “AI replaces review,” but “AI catches the bugs that slip past a quick skim.” Whether that’s worth $15–25 per PR depends on your PR volume, repo criticality, and how much you trust a single fast pass today.
REVIEW.md and CLAUDE.md.If you’re evaluating it, enable it on one or two critical repos first, set a monthly cap, and compare the feedback quality and cost to your current process. That’s the only way to know if it’s worth it for your team.
Google open-sourced an agent that keeps persistent memory without vector databases or embeddings—just an LLM that reads, thinks, and writes. Here's what it is, when it fits, and when I'd still reach for a vector DB.
The right stack in 2026 isn't just fast—it's AI-native. From frontend to backend, here's the tech stack I use and recommend to build products that leverage AI from day one.
Explore how Cursor is transforming software development with AI-powered coding assistance. Learn practical workflows, advanced features, and real-world insights from my experience - I've been using Cursor since June 2025.