Claude Code Ultracode: What It Is, When to Use It, and When to Leave It Off

Ultracode is Claude Code's maximum effort level, and it changes how Claude handles complex, multi-stage engineering tasks. It debuted with Claude Opus 4.8 and now runs on Claude Opus 5, Anthropic's current flagship. For the right class of work, it eliminates the need to manually orchestrate agents or break a large task into sequential prompts. For routine work, it is an expensive way to do something simple.

Here is what ultracode actually does, how to enable it, and how to decide whether a given task warrants it.

What Is Claude Opus 5

Claude Opus 5 is Anthropic's current flagship model, released July 24, 2026. It matches, and on several benchmarks surpasses, Anthropic's most powerful commercially available model, Fable 5, at half the price: it leads on Frontier-Bench (43.3% vs 33.7%) and OSWorld 2.0 (70.6% vs 66.1%), and scores 1,861 on the GDPval knowledge-work benchmark against Fable 5's 1,747. It ships with a 1M-token context window, 128K max output, and a May 2026 knowledge cutoff, the most current of any Claude model.

Standard pricing is $5 per million input tokens and $25 per million output tokens, unchanged from Opus 4.8. Fast mode runs roughly 2.5 times faster at double the price ($10/$50 per million), which makes it the right pick for latency-sensitive steps. For the full breakdown of benchmarks, pricing, and how it stacks up against Opus 4.8 and Fable 5, see our Claude Opus 5 guide.

Its default effort level is high. Ultracode requires xhigh reasoning, which only Opus 5 and its predecessor Opus 4.8 support. Older models, including Sonnet 4.6 and Opus 4.6, do not. If you try to set ultracode on an unsupported model, Claude Code falls back silently to high.

What Is Ultra Code

Ultracode is a Claude Code session setting, not a model parameter. It does two things simultaneously:

First, it sends xhigh reasoning effort to the model on every message in the session. At xhigh, Claude allocates significantly more internal reasoning before acting, catching edge cases and architectural issues that lower effort levels skip past.

Second, it enables automatic dynamic workflow orchestration. Normally, you trigger a workflow by including the word "workflow" in your prompt, which tells Claude Code to write a JavaScript orchestration script that fans out parallel subagents for the task. With ultracode on, Claude decides on its own when a task is substantive enough to warrant that treatment. You do not need to include any keyword.

What that looks like in practice: you submit a prompt asking Claude to audit authentication across your API layer. In ultracode mode, Claude may automatically spin up one workflow to map all the routes, a second to audit each one for missing or misconfigured auth, and a third to verify the findings adversarially before producing a report. All of that happens without you specifying the workflow structure. The agents work in parallel where possible, and intermediate results live in script variables rather than Claude's context window, keeping the main context clean.

A single ultracode session can spawn hundreds of subagents. The technical ceiling is 1,000 subagents per run and 16 concurrent agents on a typical machine. Completed work is cached and resumable within the same session.

How to Enable It

Run this in Claude Code:

/effort ultracode

That is the only supported path. The CLAUDE_CODE_EFFORT_LEVEL environment variable, the --effort flag, and the effortLevel setting in configuration files accept standard effort levels only. They do not accept ultracode.

The setting is session-scoped. It resets when you start a new session. There is no persistent ultracode configuration, which is deliberate: you should be choosing it intentionally for specific tasks, not leaving it on by default.

When you are done with a complex task and returning to routine work in the same session, drop back with:

/effort high

This shift is already well underway. As Anthropic CEO Dario Amodei observed, "some of the strongest engineers I've ever met are now handing over almost all their coding to AI." Ultracode is built for exactly that kind of delegation: tasks that benefit from parallel agents, adversarial verification, and deep reasoning before acting.

Use Cases Where Ultra Code Makes Sense

The right question to ask is not "could ultracode help here?" but "does the cost of getting this wrong exceed the cost of extra compute?" When the answer is yes, ultracode earns its token spend.

Codebase-wide audits. If you need to check 200 API routes for missing authentication, or scan an entire repository for SQL injection exposure, a single-agent pass will miss things. Ultracode fans out parallel auditors, then runs a verification pass that adversarially reviews each finding before surfacing it. Without ultracode, you would manually chunk the codebase and run sequential prompts, then reconcile the results yourself.

Large-scale migrations. Renaming a pattern across 500 files, migrating from one ORM to another, or updating all usages of a deprecated API are tasks where parallel agents working across file groups outperform sequential single-agent work both in speed and in consistency. The verification layer catches cases where the rename pattern was applied correctly in 490 files and missed in 10.

Multi-source research requiring cross-checking. The built-in /deep-research workflow is a good example: fan out web searches, fetch sources in parallel, then run adversarial verification where separate agents check each other's conclusions before synthesis. For any research task where factual accuracy matters, the adversarial review step is the part that changes the quality of the output.

Complex refactors where the architecture needs several angles. If you are redesigning a service boundary or extracting a shared module from tightly coupled code, having one agent draft the approach while another identifies the dependency implications before you commit to a plan produces a better starting point than a single-agent plan. The cost of an architectural mistake caught before implementation is much lower than one caught after.

Security reviews. Missing a single finding in a security audit can cost far more than the compute for a thorough one. The adversarial verification step, where agents check each other's work, is specifically valuable here because it catches cases where the primary auditor made a plausible-but-wrong assumption.

When Not to Use Ultra Code

Ultracode is genuinely overkill for most daily work, and the token cost is real. A thorough ultracode session doing a codebase-wide audit can consume more of your plan's weekly rate limit than a full day of normal Claude Code usage.

Routine single-file edits do not benefit from multi-agent orchestration. Fixing a bug in one function, renaming a variable, explaining what a block of code does, writing a unit test for a known interface: these tasks do not have the surface area that parallel agents improve. You are paying for orchestration machinery that adds latency and cost without adding quality.

Quick questions and clarifications are similarly poor fits. If you want to know what a specific function does or ask Claude to suggest a better name for a variable, ultracode adds startup overhead to something that should take seconds.

Any task where you need to interact mid-way is also a poor fit. Dynamic workflows cannot pause for user input once running. If you anticipate needing to redirect Claude partway through, a regular high-effort session where you can guide the conversation turn-by-turn is the better tool.

Ultra Code and Dynamic Workflows

Ultracode and the "workflow" keyword trigger are two independent paths to the same underlying system.

Mechanism	How	Scope	Claude decides?
workflow keyword in prompt	Include the word in your prompt	Per-prompt	No, always triggers
/effort ultracode	Session setting	Whole session	Yes, Claude decides per task

With ultracode on, Claude chains workflows automatically and may run several in sequence for one request. With the keyword approach, you explicitly request one workflow for that specific prompt. The keyword approach gives you more control; ultracode gives you more automation.

Workflows you find useful can be saved to .claude/workflows/ for project-scoped reuse or ~/.claude/workflows/ for personal cross-project use. Saved workflows become slash commands. The /deep-research workflow that ships with Claude Code is an example of what a production workflow looks like: a multi-phase fan-out with adversarial verification built into the structure.

The /workflows command opens a TUI view of running workflows. From there you can pause, restart individual agents, or stop a run entirely. Stopping mid-run halts token accumulation and preserves completed work.

Ultracode for Product Managers

Everything above applies outside of engineering work too. Ultracode does not care whether the task is code. It cares whether the task is big enough to justify parallel agents and adversarial verification, and a specific shape of PM work qualifies. It is the shape most PMs hit maybe once a week, not daily. The test: does answering this require reading across more sources than one context can hold, or is being wrong expensive? If neither, skip it.

Feedback synthesis at scale. 200 support tickets, 40 interview transcripts, six months of call notes. Ultracode fans out parallel readers by source, dedupes the pain points centrally, then runs a second pass that asks "what theme did we miss?" before ranking themes by frequency and severity, with quotes attached. This is the workload where a single context simply cannot hold the inputs.

Competitive teardowns. One agent per competitor per dimension (pricing, onboarding, positioning, changelog velocity), then a synthesis pass. Far better than sequentially reading eight sites and losing the first four by the time you reach the last. The adversarial step matters here too: a verification agent re-checks every claim against the sources before the comparison reaches you.

Audits with a checklist. Every page against a rubric, every flow against a heuristic set, every event in the tracking plan against what actually fires in production. Rubric-times-inventory work is exactly what parallel agents plus a verification pass do better than one long session.

Decisions where you want to be confident, not fast. Generate four independent approaches to a problem from different angles (risk-first, MVP-first, user-first), score them with independent judges, then synthesize the winner. This genuinely beats one plan iterated three times, because the failure mode of solo reasoning is committing early to a frame.

Just as important is where ultracode is waste for PM work. Writing a PRD, a strategy memo, or a launch recap: one coherent voice beats fifteen agents merging. Anything where the bottleneck is your judgment rather than information volume. And quick lookups: ten agents to answer a question one search answers.

One honest caveat. The failure mode is a PM who runs ultracode on everything and gets confident-sounding synthesis over shallow inputs. The value comes from the verification structure, agents actively trying to refute each finding, not from the parallelism itself. Learn the "when not to" half as hard as the "when to" half. None of this requires writing code: you describe the outcome, ultracode decides the orchestration.

Closing Thoughts

Ultra Code is not a setting to leave on. It is a mode you reach for when you have a task where missing something is more expensive than the compute required to be thorough: large audits, complex migrations, adversarial research, and security reviews where coverage is the metric that matters.

For everything else, high effort on Opus 5 delivers strong results at a fraction of the cost. The discipline of switching intentionally between effort levels is what makes ultracode useful, rather than just expensive.