Ultra Plan, Ultra Review & Ultracode

The single-subagent lesson was about delegating one task to one helper in an isolated context. This lesson goes beyond a single agent: the three 'ultra' capabilities are about coordinating many agents, and two of the three move that work off your machine entirely into Anthropic's cloud.

Hold two axes in your head:

• Where does it run? Locally in your terminal, or remotely on Claude Code on the web?
• How many agents? One reasoning pass, or a fleet working in parallel?

The three ultra modes map cleanly onto a local counterpart you already know:

So two of the three (ultraplan, ultrareview) are cloud features: they need a Claude Code on the web account, and they are not available on Bedrock, Vertex AI, Foundry, or Zero Data Retention (ZDR). The third (ultracode) is a local effort setting that turns on deep reasoning and lets Claude spin up dynamic workflows on its own. Keep that split straight and the rest of the lesson falls into place.

Ultraplan hands a planning task from your local CLI to a Claude Code on the web session running in plan mode (Opus). Claude researches your codebase and drafts the plan in the cloud while your terminal stays free for other work. When it's ready, you review it in a browser surface far richer than the terminal.

Three ways to launch:

# 1. Slash command
/ultraplan migrate the auth service from sessions to JWTs

# 2. Keyword anywhere in a normal prompt
plan this with ultraplan: migrate auth to JWTs

# 3. From a local plan: when plan mode shows the approval dialog,
#    choose "No, refine with Ultraplan on Claude Code on the web"

The command and keyword paths show a confirmation dialog first; the local-plan path skips it because picking that option already counts as confirmation.

Status, shown in your CLI prompt while the cloud works:

The browser review UI gives you what a terminal can't: inline comments on any passage, emoji reactions to signal approval or concern, and an outline sidebar to jump between sections. Ask Claude to address your comments and it revises and re-presents — iterate as many times as you want.

Three final actions once the plan looks right:

1. Execute on the web — Claude implements it in the same cloud session and opens a pull request when done; review the diff on the web.
2. Send back to terminal (teleport) — archives the cloud session and drops the approved plan into your waiting local session via an "Ultraplan approved" dialog with three options: Implement here (inject the plan and continue), Start new session (clear context, start fresh with only the plan — Claude prints a claude --resume command so you can return), or Cancel (save the plan to a file and print its path).
3. View raw script — inspect what will run before committing to it.

Ultrareview is the cloud counterpart to the local /review. Run /code-review ultra (alias /ultrareview) and Claude Code launches a fleet of reviewer agents (~16 concurrent) in a remote sandbox to hunt for bugs in your branch or PR. The signal-to-noise win comes from one rule: every reported finding is independently reproduced and verified before it's shown to you — so you get real bugs, not style nits.

# Review current branch vs the default branch (incl. uncommitted/staged changes)
/code-review ultra

# Review a specific GitHub pull request
/code-review ultra 1234

Before launching it shows a confirmation dialog with the scope (file/line count), your remaining free runs, and the estimated cost. A run typically takes 5 to 10 minutes and runs in the background; verified findings arrive as a notification, each with a file location and explanation you can hand straight to Claude to fix. Ultrareview never starts on its own — only when you invoke it.

Cost is real money, not plan usage. It bills against usage credits: roughly $5 to $20 per run depending on change size. Pro and Max get 3 free runs (a one-time allotment that does not refresh — and a run you stop early still consumes one). Team and Enterprise pay from the first run. Usage credits must be enabled in billing or the launch is blocked (/usage-credits to check). Like ultraplan, it is unavailable on Bedrock/Vertex/Foundry/ZDR and requires Claude.ai authentication (an API key alone won't do — run /login).

For pipelines, there's a non-interactive subcommand that runs the same review without an interactive session:

claude ultrareview                # current branch vs default
claude ultrareview 1234           # a specific PR
claude ultrareview origin/main    # diff against a base branch
claude ultrareview 1234 --json --timeout 20

It blocks until the remote review finishes, prints findings to stdout (use --json for the raw bugs.json), and sends progress messages and the live session URL to stderr so stdout stays parseable. --timeout <minutes> bounds the wait (default 30). Read the exit codes in CI:

Note the gotcha: exit 0 does not mean 'no bugs found' — it means the review ran successfully. If you want CI to fail on findings, parse the --json output yourself; don't rely on the exit code for that.

How it sits among the review options:

The Code Review GitHub App is the org-scale automation: it auto-reviews PRs on creation/push (or @claude review), tags comments 🔴 Important / 🟡 Nit / 🟣 Pre-existing, and is tuned via project CLAUDE.md plus a REVIEW.md that is injected as highest-priority text and overrides severity calibration. It reaches a neutral conclusion and never blocks a merge.

Ultracode is not a cloud feature and not a model 'effort level' — it's a Claude Code setting. /effort ultracode turns on two things at once: xhigh reasoning and automatic dynamic-workflow orchestration. With it set, Claude reasons deeply and decides on its own when a substantive task warrants spinning up a workflow (tens to hundreds of subagents, capped at 16 concurrent / 1,000 total per run), then deploys one autonomously.

Two properties to internalize:

• It is session-only: it resets on a new session, on --resume, and on --clear.
• You cannot decouple it from xhigh — ultracode always carries xhigh reasoning with it. Drop back to /effort high for routine work.

Where it sits on the effort spectrum:

low  <  medium  <  high  <  xhigh  <  max
                                      └─ deepest; session-only; no token limit

Per-model defaults differ: Opus 4.8 defaults to high; Opus 4.7 defaults to xhigh. You can set effort via /effort, the --effort flag, the CLAUDE_CODE_EFFORT_LEVEL env var (highest precedence; max is not allowed in settings), or effortLevel in settings.

For a one-off deep-reasoning boost without changing the session setting, drop the keyword ultrathink into a single prompt — it asks for deeper reasoning on that prompt only. (Both ultracode and ultrathink are current keywords, not deprecated.)

A crucial caveat on the workflow scripting API: official docs and third-party writeups use different names for the orchestration primitives — spawn(definition, prompt, args) in the official workflows docs, versus higher-level agent() / parallel() / pipeline() / phase() in third-party writeups. Don't memorize an API. Learn the concepts (spawn one agent → returns a string; run a batch concurrently with a barrier; pipeline batches through stages; no message bus, just string/JSON passing) and read the script Claude actually generates for your version.

Tie it together with the two questions that actually gate these features in practice: does it cost extra, and can I even run it here?

A simple cost mental model across the orchestration paradigms: a single subagent preserves your context (it hands back a summary); an agent team gives each peer a full context window (most expensive per agent); a workflow keeps intermediate state in script variables outside the context window (cheaper per-agent context, but it can spawn hundreds). Ultra modes layer cloud compute and verification on top — which is why ultrareview shows you an estimate before it runs and why you should test on a small slice first, then scale.

Track what you spend with /usage (per skill/subagent/plugin/MCP) and /insights (history and trends). The rule that never changes: prove the value on a narrow scope before you turn a paid, parallel, cloud feature loose on a big one.