Writing

Claude Code Ultrareview vs CodeRabbit vs Greptile

Comparing the Trade-offs of /ultrareview, CodeRabbit, and Greptile Post v2.1.111

Rick Hightower 11 min read

Originally published on Medium.

Comparing the Trade-offs of /ultrareview, CodeRabbit, and Greptile Post v2.1.111

Claude Code Ultrareview vs CodeRabbit vs Greptile

Is /ultrareview the game-changer in code reviews, or just another tool? Dive into our latest analysis comparing it with CodeRabbit and Greptile to uncover the real trade-offs! Discover which tool best fits your workflow and why integration could be the key to your development success! #CodeReview #TechTools

Summary: The release of /ultrareview offers cloud-backed, parallel multi-agent code reviews with zero setup, optimizing for quick reviews within Claude Code. It allows fetching GitHub PRs without cloning, but lacks GitHub-native features like inline comments and automation. Compared to CodeRabbit and Greptile, it excels in speed and simplicity but falls short in team collaboration and automation. Key unanswered questions remain regarding model specifics and integration with GitHub.

Comparing the Trade-offs of /ultrareview, CodeRabbit, and Greptile Post v2.1.111

Six days. Four releases. One slash command.

In v2.1.111, Anthropic shipped /ultrareview: cloud-backed, parallel multi-agent code review you can run with zero setup. The release note is one sentence long. The more important story is how it shipped: a composable infrastructure stack that makes it easy to keep shipping more ultra* commands fast. Thus far we have ultraplan and now ultrareview.

This piece covers:

  • What /ultrareview does (and what it does not do)
  • The infrastructure arc that made it possible
  • The practical trade-offs vs CodeRabbit and Greptile
  • Where it fits today, and what would change the competitive picture

What /ultrareview Actually Is (v2.1.111)

Analysis Agent, Critique agent against PR that generates a review report

Anthropic describes /ultrareview as "comprehensive code review in the cloud using parallel multi-agent analysis and critique," with two invocation modes:

# Review current branch against base
/ultrareview

# Fetch & review a specific GitHub PR by number
/ultrareview <PR#>

Three implications matter:

  • Cloud execution: This is not "run a local linter faster." It dispatches work to a cloud review pipeline.
  • Parallel multi-agent structure: The key claim is not "it reviews code," but "analysis + critique" done by multiple agents.
  • PR-by-number fetch: For consulting and cross-repo work, "review without cloning/switching branches" is the standout operational feature.

Three Things the Changelog Still Won't Tell You

  • What the output looks like. The shape of the report (sections, severity buckets, examples, etc.) determines whether people actually adopt it.
  • Whether the critique pass is visibly distinct. "Analysis and critique" might be structurally real but not exposed as separate stages in the output.
  • Whether /effort affects /ultrareview. v2.1.111 also shipped /effort (including xhigh on Opus 4.7). It's not clear whether /ultrareview inherits the session effort setting or pins its own.

The Infrastructure Arc That Made This Possible

/ultrareview reads like a feature. It behaves like a platform milestone: a user-facing command assembled from primitives shipped in quick succession.

v2.1.101 — Cloud auto-provisioning becomes default

Remote-session features auto-create a default cloud environment instead of requiring web setup first.

v2.1.105 — Worktree isolation becomes reusable

EnterWorktree gained a path parameter, enabling orchestration across existing worktrees. For parallel agents, worktree isolation is what makes "parallel" meaningfully non-interfering.

v2.1.108 — Agents can invoke built-in slash commands

The model can discover and invoke built-in slash commands like /review and /security-review as actions. That turns "commands" into internal building blocks for higher-level orchestration.

v2.1.111 — /ultrareview lands on top

With cloud runtime + worktree isolation + invokable commands in place, /ultrareview is the first "one-command product" composed from the stack.

It is clear that this is more than a slash command. There is a lot of infrastructure underneath this. This is a platform play. Two ultra* commands. Will there be more? Seems so.

What /ultrareview Actually Produces (and What It Doesn't)

What it does

  • Runs a cloud-backed review on your current branch diff, with no setup.
  • Fetches and reviews a GitHub PR by number, without you cloning or switching branches.
  • Gives you a conversational follow-up loop inside the Claude Code session.

Cost + latency (what's known as of v2.1.111)

  • Cost: /ultrareview uses premium cloud compute. Pro and Max plans include 3 free runs (one-time). After that, additional usage uses your plan's cloud compute / premium usage (pricing is plan-dependent).
  • Latency: Commonly ~5-10 minutes, and typically faster than the separate managed GitHub App "Code Review" flow.

What it does not do (today)

  • It does not write back to GitHub (no inline PR comments; no PR-thread audit trail).
  • It does not auto-trigger on PR open (you have to remember to run it).
  • It does not expose model/effort controls in a transparent way (as far as public docs say).

Paste-in slot for a real excerpt (you)

Paste a short excerpt from a real /ultrareview run directly below this heading so readers can see the actual output shape:

Real output excerpt

Launch UltraReview

❯ /ultrareview PR-1
⎿ Free ultrareview 2 of 3.
  Ultrareview launched for main (~5-10 min, runs in the cloud).
  Track: https://claude.ai/code/session_01BL8gEEr3mye2J7fDMabc
  Scope: 6 files changed, 344 insertions(+), 15 deletions(-)

⏺ Ultrareview kicked off on the PR branch diff. I'll wait for the findings to come back via notification — no polling needed.

Website to show status

Drill down on steps

Now ultrapla shows findings

Sample output as the report comes back and Claude Code reacts to it.

Remote review completed

⏺ Three legitimate findings — the reviewer caught real gaps my tests missed. Fixing all three on this branch before merging.

⏺ bug_001 first (simplest). Failing test, then factory fix.

⏺ Write(tests/unit/test_tech_debt_mcp_disable.py)
⎿ Wrote 41 lines to tests/unit/test_tech_debt_mcp_disable.py
  1 """Tests for MCP-disable coercion in tech-debt agent factories.
  2
  3 Bug: `mcp_servers=mcp_servers or ["perplexity", "context7"]` treats an empty
  4 list as falsy and silently restores the default servers. When a user sets
  5 all MCP toggles to false in config, the factory was picking the defaults.
  6
  7 Fix: distinguish `None` (caller didn't care, use defaults) from `[]`
  8 (caller explicitly wants no servers).
  9 """ … +31 lines (ctrl+o to expand)

⏺ Bash(uv run pytest tests/unit/test_tech_debt_mcp_disable.py -v 2>&1 | tail -10)
⎿ E + [ E + 'perplexity', E + 'context7', … +7 lines (ctrl+o to expand)
⎿ Allowed by auto mode classifier

⏺ Update(src/designdoc/agents/tech_debt.py)
⎿ Added 13 lines, removed 2 lines
   6 from designdoc.runner import AgentDef
   7
   8
   9 +_DEFAULT_TECHDEBT_MCP: list[str] = ["perplexity", "context7"]
  10 +
  11 +
  12 +def _resolve_mcp(mcp_servers: list[str] | None) -> list[str]:
  13 +    """None = caller didn't specify, use defaults. `[]` = caller explicitly
  14 +    wants no servers. Any other list passes through as-is."""
  15 +    if mcp_servers is None:
  16 +        return list(_DEFAULT_TECHDEBT_MCP)
  17 +    return list(mcp_servers)
  18 +
  19 +
  20  def make_tech_debt_researcher(
  21      model: str = "claude-sonnet-4-6", mcp_servers: list[str] | None = None
  22  ) -> AgentDef: ...
  26      model=model,
  27      allowed_tools=[],
  28      max_output_tokens=1024,
  18 -    mcp_servers=mcp_servers or ["perplexity", "context7"],
  29 +    mcp_servers=_resolve_mcp(mcp_servers),
  30  )
  31
  32 ...
  39      model=model,
  40      allowed_tools=[],
  41      max_output_tokens=1024,
  31 -    mcp_servers=mcp_servers or ["perplexity", "context7"],
  42 +    mcp_servers=_resolve_mcp(mcp_servers),
  43  )
  44
  45

⏺ Bash(uv run pytest tests/unit/test_tech_debt_mcp_disable.py -v 2>&1 | tail -10)
⎿ plugins: cov-7.1.0, anyio-4.13.0
  collecting ... collected 5 items … +7 lines (ctrl+o to expand)
⎿ Allowed by auto mode classifier

⏺ bug_002 next — narrow the FileNotFoundError handler.
  ✢ Wiring max_budget_usd and only_stages… (1m 6s · ↓ 1.4k tokens · thought for 17s)
⎿ ◼ Fix bug_008: wire max_budget_usd and only_stages from config
  ◼ Fix bug_002: narrow FileNotFoundError handler to config path only
  ✔ Fix bug_001: MCP disable flags silently overridden by factory or-idiom

Final response to ultrareview session

/ultrareview vs CodeRabbit vs Greptile: The Practical Trade-offs

Ultraview vs. CodeRabbit vs. Greptile vs. Manual Solution

The core distinction

  • /ultrareview optimizes for zero friction inside Claude Code.
  • CodeRabbit / Greptile optimize for team workflow inside GitHub (automation + persistence + inline comments).

Zero Friction

Ultraview is frictionless

Two zero friction ways to use ultrareview.

Summary table (high-signal version)

/ultrareview (Claude Code)

  • Setup: none (if you already use Claude Code)
  • Triggering: manual
  • Output location: Claude Code session
  • GitHub write-back: no
  • Best for: pre-push habit; consulting "review this PR now" across repos

CodeRabbit

  • Setup: GitHub App + repo configuration
  • Triggering: automatic on PR open (configurable)
  • Output location: PR thread + inline comments
  • GitHub write-back: yes
  • Best for: teams who want every PR reviewed automatically with persistent threads + auditability
  • Note: Free-tier and hourly limit details have shifted over time; verify current limits against the official plans page before publishing.

Greptile

  • Setup: indexing + configuration
  • Triggering: automatic on PR open + manual @greptileai
  • Output location: PR thread + inline comments
  • GitHub write-back: yes
  • Best for: teams who want codebase-aware review tied directly to GitHub collaboration

/ultrareview vs CodeRabbit vs Greptile: The Practical Trade-offs

Where /ultrareview Wins (Today)

  • Fastest path to "some review happened." If you're already in Claude Code, there's no integration tax.
  • Consulting mode is real. PR-by-number fetch is operationally excellent for reviewing across many repos quickly.
  • Parallel critique as default posture. Even if not fully transparent, the existence of a critique stage is the most important design choice in the feature.

Where ultrareview wins

Where /ultrareview Loses (Today)

  • No GitHub-native workflow. No inline comments, no shared team record, no threaded resolution.
  • Manual invocation is fragile. Habits degrade under deadline pressure; automation wins adoption.
  • Opaque configuration surface. Teams that care about effort/model transparency will prefer tools they can tune or at least reason about.

Where /ultrareview Loses

Where Ultrareview does not fit

Ultraplan in perspective

Five Questions Anthropic Has Not Answered Yet

  • What exact model(s) power the agents?
  • How many agents run in parallel?
  • Does /effort influence /ultrareview, or is it pinned?
  • Can output be posted to GitHub (now or later)?
  • How is quota/cost accounted for after the three free runs (tokens vs compute vs plan limits)?

Questions about Ultrareview

Takeaway (and a concrete next step)

Low fricion, high value tool

If you already live in Claude Code, /ultrareview is the easiest way to add a pre-push review habit with essentially zero setup cost (and a small number of included runs). If you need automation, persistence, and GitHub-native collaboration, CodeRabbit and Greptile still win.

Run this today:

/ultrareview

Then decide: does the output create enough value to become a habit, or do you need a tool that writes back to GitHub?

References

About the Author

Rick Hightower is a former Senior Distinguished Engineer at a fortune 100 focusing on delivering ML / AI insights to front line applications, and practitioner building multi-agent production systems. Follow him on Medium for more hands-on agent engineering content.

He created skilz, the universal agent skill installer, supporting 30+ coding agents including Claude Code, Gemini, Copilot, and Cursor, and co-founded the world's largest agentic skill marketplace. Connect with Rick Hightower on LinkedIn or Medium. Check out SpillWave, your source for AI expertise.

Rick has been actively developing generative AI systems, agents, and agentic workflows for years. He is the author of numerous agentic frameworks and developer tools and brings deep practical expertise to teams looking to adopt AI. He enjoys writing about himself in the 3rd person.

Rick also wrote a Claude Certified Architect (CCA) series of articles that have a lot of useful information on writing agentic AI systems. A lot of ideas captured in the CCA and the exam prep that Rick wrote echoes what you see in this article. If you want to improve your ability to create well-behaved AI agents, studying for the CCA Exam is a good place to start.

CCA Exam Prep on Agentic Development

Rick also wrote a series on harness engineering and how to improve agentic systems using harness engineering for feedback loops and adversarial agents. These articles also go hand in hand with this article.

Harness Engineering Articles

#Claude Code #Anthropic Claude Code #Code Review #Ai Code Review #Ai Agents In Action