Home › Rules › Claude Code review

Claude Code review: /code-review vs ultrareview vs Code Review on GitHub

From Anthropic's Claude Code docs, checked Nov 2, 2026. Sources below.

• Guide
• Claude Code
• Code review
• GitHub

Short answer: Claude Code can review your code four ways. /code-review runs in your own session on any plan and comes out of your normal usage. Ultrareview (/code-review ultra) is a deeper review that runs in Anthropic's cloud: Pro, Max and Ultra get 3 free runs per account, one time, and after that a review typically costs $5 to $25 in usage credits. Code Review is a managed service that reviews every pull request on GitHub, but it's only for Team and Enterprise plans. And anyone with an API key or a subscription token can run a review in GitHub Actions. For most people working alone, /code-review is the one to use every day.

The four options side by side

1. /code-review: the everyday review

/code-review is a command you type at the Claude Code prompt. Claude looks at the changes on your branch for bugs and reports what it found in the conversation. It works on any plan, and it uses your plan's usage (or your API billing) like the rest of the session. /review does the same thing.

The review runs as a background subagent with its own context, so it doesn't fill up your conversation. You can keep working, and the findings show up when it's done. Then ask Claude to fix what it found.

Pick what it reviews

Useful flags

• --fix has Claude apply the findings to your files after the review. Edits still go through your permission mode. One catch from Anthropic's docs: /rewind won't undo every file a background --fix touched, so commit first and use git to undo if you need to.
• --comment posts the findings on a GitHub pull request as inline comments (or as one note on a GitLab merge request).
• An effort level trades coverage for confidence. /code-review low reports only what it's most sure about, so you see fewer false alarms. medium through max look wider. The level you typed last time gets reused until you type a new one.

It follows your CLAUDE.md

/code-review reads your CLAUDE.md, so that's where review rules go. It does not read REVIEW.md; that file is only for the GitHub Code Review service. Here's a short example with a review section:

# CLAUDE.md

## Project
- A small web app for [who it's for]. Stack: [for example Next.js + Supabase].
- Tests: npm test

## When you review code
- Look for bugs first: wrong logic, missing error handling, broken edge cases.
- Flag any secret, API key or password that ends up in code or logs.
- Check that every new page or API route has a test.
- Don't comment on formatting. Our linter handles that.

More starters in our CLAUDE.md examples. If you'd rather write your own reviewer, a project skill named code-review runs in place of the built-in one, or you can make a reviewer subagent (see Claude Code subagents examples and skills examples).

2. Ultrareview: the deep review in the cloud

Ultrareview sends a group of reviewer agents to look at your change in a cloud sandbox. Anthropic says every finding is reproduced and checked before it's reported, so you get real bugs instead of style notes. It's a research preview, so it can change.

• Start it: /code-review ultra reviews your branch against the default branch, including uncommitted and staged changes. /code-review ultra develop compares against another branch, and /code-review ultra 1234 reviews a pull request on github.com. Where your account has it, /ultrareview works too.
• Add a note: /code-review ultra check my auth changes still reviews your branch, and Claude ties the findings back to your note.
• Before it starts, Claude Code shows the scope, how many free runs you have left and the estimated cost, and asks you to confirm. Claude never starts an ultrareview on its own.
• While it runs (usually 5 to 15 minutes), keep working. /tasks shows running reviews and lets you stop one. A stopped review gives no partial findings.
• Size limit: a branch review can cover up to 500 changed files and 8,000 changed lines by default. If your repo is too big to upload, Anthropic suggests pushing a draft PR and reviewing that by number.

What ultrareview costs

Ultrareview doesn't come out of your plan's included usage. Pro, Max and Ultra each get 3 free runs. That's one time per account, and they don't come back. After that, a review typically costs $5 to $25 in usage credits, depending on how big the change is. You have to turn usage credits on first, or Claude Code blocks a paid review. (Run /usage-credits to check that setting.)

A run counts as soon as the cloud session starts. If you stop it early or it fails, it still uses up a free run. A paid review only bills for the part that ran. So a bigger plan doesn't get you more free ultrareviews. See how to turn on and cap usage credits.

When ultrareview isn't available

You need to be signed in with a claude.ai account; an API key alone won't do it (run /login). It isn't available through Amazon Bedrock, Google Cloud or Microsoft Foundry, or for organizations with Zero Data Retention or the HIPAA setup. In those cases /code-review ultra runs a normal local review instead.

For scripts and CI, Anthropic has a claude ultrareview command that waits for the findings and prints them. Running it again starts a new review (and uses another free run or more credits), so don't put it in a loop.

3. Code Review on GitHub (Team and Enterprise)

Anthropic's Code Review service reviews pull requests on GitHub for you. Several agents read the change and the code around it, a check step throws out false alarms, and the rest are posted as inline comments ranked by how serious they are. It also adds a check run called Claude Code Review. It never approves or blocks a pull request, so merging is still up to you.

• Who can use it: Team and Enterprise plans only, with repositories on GitHub. An Owner of the Claude organization turns it on and installs the Claude GitHub App.
• When it runs: each repository is set to review once when a PR opens, after every push, or only when someone comments @claude review. New repositories start at "After every push," which runs the most reviews.
• What the labels mean: 🔴 Important is a bug to fix before merging, 🟡 Nit is minor, and 🟣 Pre-existing is a bug that was already there before this PR.
• Cost: no flat price. It's billed to the organization in usage credits, separate from the plan, and depends on the review level (Quick, Standard or Deep) and the size of the change. An admin can set a monthly spend limit for it.

Tune it with REVIEW.md

Code Review reads your CLAUDE.md files and a REVIEW.md at the root of the repo. REVIEW.md is only for reviews. Use it to say what counts as Important, cap the nits, and list what to skip. It's read from your base or default branch, never from the pull request itself. A short one, based on Anthropic's example:

# Review instructions

## What Important means here
Only mark something Important if it would break the app, leak user data,
or stop us from rolling back. Style and naming are Nit at most.

## Cap the nits
Report at most five Nits per review.

## Do not report
- Anything our CI already checks: lint, formatting, type errors
- Lock files and anything under build/ or dist/

## Always check
- New API routes have a test
- Log lines don't include emails or passwords

4. Review pull requests with GitHub Actions

If you're not on Team or Enterprise but want every PR on GitHub reviewed, Anthropic's Claude Code GitHub Action can do it in your own workflow. The quick way: open claude in your repo and run /install-github-app. It installs the Claude GitHub App, saves a secret, and opens a pull request with the workflow. You can choose to include the review workflow. It only works for repos on github.com.

For the secret, you can paste a Claude API key (ANTHROPIC_API_KEY, billed at API rates) or make a token from your Pro, Max or Ultra subscription by running claude setup-token (CLAUDE_CODE_OAUTH_TOKEN). If you use the token, change the anthropic_api_key line in the workflow to claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}.

This is Anthropic's own review workflow from its docs. Save it in .github/workflows/:

name: Code Review
on:
  pull_request:
    types: [opened, synchronize, ready_for_review, reopened]
jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: read
      issues: read
      id-token: write
    steps:
      - uses: actions/checkout@v6
        with:
          fetch-depth: 1
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          plugin_marketplaces: "https://github.com/anthropics/claude-plugins-official.git"
          plugins: "code-review@claude-plugins-official"
          prompt: "/code-review:code-review --comment ${{ github.repository }}/pull/${{ github.event.pull_request.number }}"
          claude_args: '--allowedTools "mcp__github_inline_comment__create_inline_comment"'

Keep the claude_args line: Anthropic says the inline-comment tool only starts when it's listed there. Claude skips draft and closed PRs, ones it judges too small to need a review, and ones it already commented on. On public repos, GitHub doesn't give secrets to PRs from forks, so those don't get reviewed.

Which one should you use?

• Working alone on a side project: run /code-review before each commit or PR. It's included in your plan. Add --fix once you trust the findings.
• About to merge a big or risky change: that's what ultrareview is for. Use your 3 free runs on the changes that matter most, since they don't come back.
• Want every PR on GitHub reviewed: on Team or Enterprise, ask your Owner about Code Review. Otherwise, set up the GitHub Action.
• On a tight budget: stick with /code-review, and keep usage credits off or capped so a paid ultrareview can't start by surprise.

Reviews work better when Claude knows your project. A good CLAUDE.md and a quick plan before big changes (see our plan mode guide) mean fewer bugs for the review to find in the first place. If you want a check after every edit instead of at the end, a Claude Code hook can run your tests or linter automatically.

Anthropic's own note: an AI review can miss bugs and security problems, and a review with no findings doesn't mean your code is safe. Keep your tests.

Related

• Claude Pro vs Max vs Ultra (limits and usage credits)
• CLAUDE.md examples
• Claude Code subagents examples
• Claude Code skills examples
• Claude Code hooks examples
• Custom slash commands
• Plan mode guide (6 tools + 6 plan prompts)
• Cursor vs Claude Code vs Codex (real prices)

Sources

• Claude Code docs: Review locally with /code-review
• Claude Code docs: Find bugs with ultrareview
• Claude Code docs: Code Review
• Claude Code docs: Code Review costs and usage
• Claude Code docs: Customize Code Review
• Claude Code docs: Read and request reviews on a pull request
• Claude Code docs: Claude Code GitHub Actions

Everything here was checked Nov 2, 2026 against Anthropic's Claude Code docs. Ultrareview is a research preview, and Anthropic says its features, pricing and availability may change. If something here no longer matches, tell us at [email protected].