Claude Code Ultracode: The xhigh + Orchestration Mode That Rewires Your Sessions

Most effort-level guides bury the important distinction in a footnote. Here it is up front: ultracode is not a higher effort level — it is a different operating mode. Activating /effort ultracode does two things simultaneously: it locks your session to xhigh reasoning effort and turns on dynamic workflow orchestration, so Claude will automatically plan parallel subagent pipelines instead of handling large tasks in a single context window. That second part is what separates it from every other effort setting.

Ultracode shipped on June 3, 2026 alongside Claude Opus 4.7 support in Claude Code. Within a week it had become the default posture for teams doing codebase-wide migrations, security audits, and large refactors — and also the leading cause of surprise token bills for teams who forgot to test on a slice first.

What ultracode actually is

Before ultracode existed, xhigh was the ceiling: maximum extended thinking, applied to every turn. That still meant one reasoning chain, one context window, one sequential flow. For a task touching 30 files across three packages, the model would load everything into one context and work through it linearly — slower, and more likely to lose earlier context by the end.

Ultracode changes the shape of the work. When you run /effort ultracode, Claude sees each substantive task as an orchestration problem first. It writes a workflow plan — which subtasks can run in parallel, which must be sequential, what each subagent needs in its context — and then executes that plan. The parent agent orchestrates; the children do the focused work with small, clean context windows.

The full effort ladder

Claude Code has five effort settings. Knowing where ultracode sits — and what sits below it — is the only way to use the tool correctly.

/effort low       # 0.3× token baseline — fast, for mechanical tasks
/effort medium    # 1× baseline — the daily driver
/effort high      # 2–3× — harder problems, smarter code
/effort xhigh     # 5–10× — one deep reasoning chain
/effort ultracode # 10–50× — xhigh + parallel workflow orchestration

The multipliers are approximate — they scale with task scope. A large ultracode audit can hit the 50× ceiling; a small one might run at 15×. The variance is large because orchestration depth varies.

Dynamic workflow orchestration

The orchestration layer is what makes ultracode feel qualitatively different from just cranking up reasoning effort. When Claude sees a task large enough to justify it, it generates an explicit workflow plan before touching any code:

Task: Security audit of the authentication module

Workflow:
  Phase 1 (parallel):
    → agent:auth-input-audit     # validates all user-input paths
    → agent:session-audit        # checks session management
    → agent:crypto-audit         # reviews key usage and hashing

  Phase 2 (sequential):
    → agent:finding-merger       # deduplicates, ranks by severity
    → agent:fix-writer           # applies patches in priority order

  Phase 3 (sequential):
    → agent:regression-runner    # confirms existing tests still pass

Each child agent is isolated: it gets only the files and context relevant to its job, runs with xhigh effort, and returns a structured result. The parent never loses track of prior work because that work lives in the child's transcript, not the parent's context window.

This is the same architecture the subagents feature exposes when you wire pipelines manually. Ultracode automates the orchestration layer so you don't have to write the workflow spec yourself.

When to reach for ultracode

Ultracode earns its cost when the work is genuinely parallel and wide. The heuristic: if the task touches 20 or more files, spans multiple packages, or benefits from adversarial verification (one agent produces, another critiques), ultracode wins on wall-clock time even at higher token cost.

Strong ultracode use cases:

• Security audits — fan out one agent per attack surface (input validation, auth, crypto, deps), merge findings, apply ranked patches.
• Large migrations — migrate one package per agent in parallel; final agent integrates and runs tests.
• Pattern detection — scan a monorepo for an anti-pattern across 50+ files; ultracode parallelises the scan and deduplicates results.
• Competing-hypothesis analysis — spawn one agent per hypothesis, have a critic agent score them; faster than one sequential reasoning chain.
• Verification passes — implementation agent runs first; reviewer and test-writer run in parallel against the diff.

When NOT to use it

Ultracode is wasteful — and sometimes actively worse — on work that is narrow, mechanical, or requires a single careful reasoning chain.

Skip ultracode for:

• Single-file edits, no matter how complex the logic — one focused xhigh chain is better than a workflow with one agent in it.
• Mechanical refactors (rename, reformat, import sorting) — medium effort is fine and 50× cheaper.
• Debugging a specific stack trace — you need one deep reasoning pass, not a fan-out.
• Exploratory questions — "what should we do about X?" doesn't benefit from parallel workers.

The pilot rule: slice-first

The most common ultracode mistake is running it on the full codebase immediately. A 400-file repo at full ultracode scope can consume millions of tokens before you know whether the workflow plan was even right.

The fix is mechanical: always run a small slice first.

# Wrong: run the whole audit immediately
> /effort ultracode
> Audit the entire codebase for SQL injection vulnerabilities

# Right: slice first, then expand
> /effort ultracode
> Audit apps/api/src/modules/auth/ for SQL injection vulnerabilities
# Inspect the output. Is the workflow plan correct? Are findings actionable?
# If yes, expand scope.
> Now audit the remaining modules: users, payments, webhooks

The pilot run costs 5–10% of the full run and tells you whether Claude's orchestration plan is correctly scoped. If the plan is wrong, you correct it before paying for the full execution.

Token math and cost control

Ultracode sessions are session-wide. Every request in that session — including small follow-up questions — runs at xhigh effort. If you mix big audit requests with "just fix this typo" requests in the same session, you pay xhigh rates for the typo fix.

The pattern that works: open a dedicated ultracode session for the wide task, get the output, close the session, switch back to medium or high for normal work.

# Session 1 — ultracode for the audit
> /effort ultracode
> [wide audit task]
> [follow-up questions about the audit results]
> exit

# Session 2 — normal effort for everything else
> /effort medium
> [daily development work]

Task budgets — also shipped with Opus 4.7 — let you set a hard token ceiling per session. If you're running ultracode on a scope you haven't measured before, set a budget first:

# Set a session budget before running a wide ultracode task
> /budget 500000
> /effort ultracode
> [task]

Claude will stop and report when it hits the ceiling rather than continuing silently. You can then decide whether to raise the budget or accept the partial result.

/ultrareview: the companion command

Also shipped in the same June 3 release: /ultrareview. It is a dedicated code review session that opens with xhigh effort pre-loaded and a system prompt optimized for adversarial review — it defaults to "find problems, not praise."

The difference from running /effort xhigh and asking for a review manually is the system prompt. Ultrareview instructs Claude to:

• Assume the diff is wrong until proven otherwise (adversarial prior).
• Check for correctness, security, performance, and test coverage in that order.
• Report findings as a ranked list with severity, not a prose summary.
• Propose fixes, not just findings — each item includes a corrected code snippet.

# Open an ultrareview session (xhigh + adversarial review prompt)
> /ultrareview

# Feed it the diff or the file list
> Review the changes in git diff main..HEAD
# Output: ranked findings with severity + fix snippets

If you're already doing code review via skills, the review category on skills-hub.ai has SKILL.md files that pair well with ultrareview — install a review skill to give the session a structured checklist, then open /ultrareview for the execution.

The bottom line

Ultracode is genuinely powerful for wide, parallel work. It is genuinely expensive for everything else. The decision tree is short: does this task touch 20+ files or benefit from adversarial verification? Use ultracode, slice first, set a budget. Does it not? Use xhigh or medium.

The effort ladder exists because different work has different shapes. The right tool is whichever setting matches the shape of the task — not whichever one is highest on the list.

# Install the ultracode-effort skill for structured session management
npx @skills-hub-ai/cli install ultracode-effort