By Remco Livain in AI — 19 Jun 2026

Ultracode isn't a bigger thinking dial. It's Claude deciding how to split the work.

I assumed ultracode was just /effort high with the dial turned up. It isn't — one changes how hard Claude thinks, the other changes what it does. Here's the difference, and why it's quietly carrying my parallel workstreams.

I had this one wrong for a couple of weeks. I assumed ultracode was just /effort high with the dial cranked up another notch — same behaviour, more thinking, bigger bill. It isn't. They're not two points on the same scale. One changes how hard Claude thinks; the other changes what Claude actually does. Once that clicked, it changed how I run my week.

What /effort high actually is

/effort high is a reasoning-effort level, and that's all it is — a "how hard should I think before I answer" dial. It's the sensible default for difficult work: complex reasoning, a nasty bug, an architecture question where quality matters more than speed or token cost. Claude reasons more deeply on each message, but it still works in a single loop. It reads, it thinks, it answers. No second agent shows up to check the first one's homework.

For a lot of what I do, that's exactly right. Most days don't need more than a model that thinks carefully and stays in its lane.

What ultracode is — and why it's different in kind

Ultracode isn't a deeper rung on the effort ladder. It's a Claude Code setting that does two jobs at once: it runs the model at xhigh reasoning effort, and — the part that matters — it switches on automatic workflow orchestration. With it on, Claude looks at a substantial task and plans a workflow for it on its own, instead of waiting for me to ask. A single request can become several workflows in a row: one to understand the code, one to make the change, one to verify it, each handled by its own subagent.

That second job is the whole point. /effort high makes Claude think harder about a problem. Ultracode lets Claude decide a problem is big enough to split up — and then split it. It's the difference between a sharper single operator and a small team that self-organises around the work.

High changes how hard Claude thinks. Ultracode changes what Claude does. Those are not the same lever.

Here's the side-by-side I keep in my head:

	/effort high	ultracode
Reasoning	high	xhigh (one step up)
Extra agents	none — single loop	auto-orchestrated subagent workflows
What it changes	how hard Claude thinks	how hard it thinks and what it does
Cost & latency	contained	more tokens, slower on every task
Scope	sticks until you change it	session only; resets next session
Best for	hard single-threaded work	big, multi-stage jobs you'll let run

Where this shows up in real work

I run several workstreams in parallel — a few client builds, my own directory and marketplace projects, the admin that keeps a one-person firm legal. The thing that used to cost me was context-switching inside a single task: a big job would stall halfway because one overloaded window was trying to hold the whole thing at once. With ultracode, the work gets spread across agents — one understands, one changes, one verifies — and no single thread has to carry all of it. I've watched it work through a multi-part task while I was off doing something else entirely, and come back to something that had actually been checked, not just produced.

The honest caveat: it is not free, and it is not always better. Higher effort plus orchestration means more tokens and more time on every task in the session. Pointing it at a variable rename or a one-line fix is just lighting money on fire slowly. The skill isn't turning it on — it's knowing which jobs earn it. That judgement is the same muscle I wrote about in Claude Skills vs Claude Agents: the difference that actually matters, and it's the same reason I could stand up a full subscription business without opening the Stripe dashboard — the tool does the work, but someone still has to decide what the work is.

One thing that surprised me

You don't need an exotic model to get this. Ultracode and xhigh both run on Opus 4.8, which is what most people actually have in front of them. The "which model" question — Opus versus the pricier Mythos-tier stuff — is a genuinely separate axis from "which effort mode," and I'll take that one apart in its own post. For now: the orchestration win is sitting right there in the model you're already using.

How I actually choose

My rule of thumb is boring on purpose. /effort high for hard work that lives in one head — tricky debugging, an architecture call, a piece of analysis I want done thoroughly but in one pass. Ultracode for big, multi-stage jobs I'm willing to let run in the background — a large refactor, a migration, anything where parallel agents and an independent verification step earn back the cost. When the session's done, I drop back to /effort high so the routine stuff doesn't quietly cost triple.

The trap is treating it as a bigger hammer. It isn't a bigger hammer. It's a different tool that happens to live one click further down the same menu.

Sources & further reading

External
· Anthropic — Orchestrate subagents at scale with dynamic workflows (the official description of ultracode)
· Anthropic — Effort levels (high, xhigh, max, and why ultracode isn't an API effort level)