The Effort Dial Is the Most Important Opus 4.8 Feature Nobody Reads the Manual For

Quick Navigation

Difficulty: Intermediate
Estimated Time: 10-15 minutes
Prerequisites: Familiarity with Claude models, Basic understanding of LLM reasoning tokens, Access to claude.ai or Claude Code, Awareness of cost and latency trade-offs in LLM usage

When Anthropic released Claude Opus 4.8 on May 28, 2026, the benchmark charts got the attention: agentic coding up to 69.2%, an 84% score on Online-Mind2Web that made it the strongest computer-use model in their testing. But the change that alters how you actually use the model day to day isn't on those charts. It's a small dropdown.

Opus 4.8 puts a control called effort directly in the claude.ai sidebar, next to the model selector, and it's available on every plan. Effort decides how much Claude thinks before it answers — which means it's also the single biggest lever you have over speed, cost, and quality. Crank it up on a one-line task and you're lighting tokens on fire. Leave it low on a genuinely hard problem and you get a confident, shallow answer that you'll have to redo.

The launch coverage named the levels. Almost none of it told you which one to pick when, and a lot of it got the levels themselves wrong. So here's the part that's missing: what the dial does, which setting fits which job, and the handful of cases where reaching for the top is just paying more to wait longer.

What "Effort" Actually Controls

Opus 4.8 is a hybrid reasoning model. It can answer fast and intuitively, or it can stop and reason step by step before producing output. Effort governs that second mode — how much of a thinking budget the model gives itself before it commits to an answer.

This isn't a separate model or a quality toggle in the marketing sense. It's a budget for deliberation. More effort means more internal reasoning tokens spent working through a problem before the first word of the response appears. Less effort means Claude scopes its thinking to what the task plainly needs and moves on.

"Higher effrt isn't a 'better model.' It's the same model given more room to think — which only helps when the problem actually needs thinking."

One detail worth internalizing early: the model doesn't always spend the whole budget. At high and max effort, Claude will almost always think. At lower levels, it may skip extended thinking entirely for problems that don't warrant it. The ceiling is a permission, not a quota.

The Actual Ladder: Five Levels, One Default

Here's where most of the secondhand coverage went sideways. The real effort ladder on Opus 4.8 has five rungs:

Low — fastest and cheapest, with some capability reduction. Right for simple classification, quick lookups, formatting, and high-volume jobs where a marginally better answer isn't worth the latency or spend. If you're running the same prompt across thousands of rows, this is your setting.

Medium — a balanced option with moderate token savings. Good for routine drafting, summaries, outlines, and everyday questions where you want a considered answer but not deep analysis.

High — the default. This is where Opus 4.8 sits unless you change it, on every surface including the API and Claude Code. It's tuned for serious writing, document analysis, code review, and anything you don't want to redo. Treat it as your 100% baseline.

xhigh (labeled "extra" in claude.ai) — a deeper reasoning level above the default. This is Anthropic's recommended setting for hard coding tasks and long-running, asynchronous agentic work. It's the rung the simplified "five levels" explainers tend to drop entirely, which is unfortunate, because it's the one that matters most for engineering.

Max — the most tokens spent for the best single answer. Reserve it for problems where a mistake is expensive and getting it right justifies the bill.

"The most common mistake isn't using too little effort. It's defaulting to Max for everything because the output feels more polished. On a simple task, the quality gap between High and Max is negligible — the cost and latency gap is not."

Key insight: A widely repeated claim is that Opus 4.8 defaults to its top tier. It doesn't. Opus 4.8 defaults to high. (Opus 4.7 is the model that defaulted to xhigh.) If you want more than balanced effort on 4.8, you're opting in deliberately.

Why "Ultra Code" Isn't on That Ladder

If you've read the launch writeups, you've seen "Ultra Code" — or ultracode — described as a sixth effort level, a kind of super-Max for programming. That framing is wrong, and the distinction is the single most useful thing to understand about this release.

Ultracode is not a model effort level. Anthropic's own documentation is blunt about it: ultracode shows up in Claude Code's effort menu, but it is not an additional API effort level. It's a Claude Code setting that does two things at once. First, it sends xhigh to the model — so you get the highest practical reasoning effort. Second, it switches on Dynamic Workflows, the feature where Claude takes a large task, plans it, spins up parallel subagents to execute the pieces, and verifies its own output before declaring the work done.

So the right mental model isn't "ultracode > max." It's "ultracode = xhigh + orchestration." Max gives you the deepest reasoning inside a single context window. Ultracode changes the execution shape — it moves the work out of one overloaded window and into many coordinated ones.

Note Ultrcode depends on Dynamic Workflows, which ships in Claude Code for Enterprise, Team, and Max plans. It also requires an xhigh-capable model, which today means Opus 4.8 or Opus 4.7. On models without xhigh, the option doesn't appear in the menu at all. If you want deeper reasoning without Claude spinning up subagents on its own, set xhigh directly and leave ultracode off.

Matching Effort to the Task

The right level isn't the highest one you can afford. It's the one that matches the task's complexity. A practical framework:

Reach for Low when the task has a single clear answer, speed is the priority, and a small error rate is acceptable — classification, bulk transformations, intermediate pipeline steps.

Reach for Medium when the work needs a few steps of reasoning but isn't ambiguous, and you want good output without the latency hit — emails, outlines, basic plans, moderate summaries.

Stay on High (the default) when the output goes to a person, the task has multiple requirements, or an error would cost you a manual correction. This covers the bulk of real knowledge work.

Step up to xhigh for hard coding, multi-file changes, and long-running agentic jobs where you want the model exploring thoroughly. This is Anthropic's recommendation for capability-sensitive engineering work — not Max.

Use Max only when a wrong answer is genuinely expensive: contract review, risk analysis, high-stakes synthesis across long inputs.

Turn on ultracode (in Claude Code) for codebase-scale work — audits, migrations across hundreds of thousands of lines, multi-file refactors, test generation — where you want the planning-and-verification layer, not just deeper thinking.

"The smart habit isn't living at the top of the dial. It's matching the level to the job — and trusting High to carry most of your work."

The Cost You Don't See: Latency and Rate Limits

Effort scales three things together, and only one of them shows up on an invoice.

Quality scales with effort, but only for problems that need it — past a task's real complexity, extra thinking buys nothing. Latency scales with effort too: a low-effort reply can land in seconds, while max-effort reasoning on a hard problem takes real time. And on claude.ai, effort consumes your rate limits faster at higher settings and slower at lower ones, which is its own kind of cost even on a flat plan.

A useful field observation from the launch: a higher model version and higher effort are different levers. Some users found Opus 4.8 on its default high effort used less of their plan limit than Opus 4.7 did. You can be on the newest model and still dial effort down — the two choices are independent.

This is why "just use Max" is a bad default even when budget isn't tight. You're trading away responsiveness and burning through limits for quality you often can't measure on the task in front of you.

Routing: The Pattern That Actually Saves Money

For anything running at scale, the cost-effective move isn't picking one level — it's routing. Segment tasks by complexity and send each to the level it needs. Simple inputs hit Low or Medium. Complex or high-stakes inputs escalate to High, xhigh, or Max. A coding pipeline might run xhigh on real implementation work and Medium on everything else.

The logic mirrors how a good team distributes work: most things don't need your most expensive thinker, but the few that do, badly need it. A document workflow might extract and summarize at High, then escalate to Max only for the final synthesis that lands in a client report. You pay top-tier rates for the step where it changes the outcome, and nothing extra for the steps where it doesn't.

"Routing turns the effort dial from a per-message guess into a system design choice — and that's where the savings live."

The mistake to avoid is the opposite of stinginess: paying Max-level cost on every input because the polish feels reassuring. On well-constrained tasks, that polish is indistinguishable from the High-effort output you'd have gotten for a fraction of the spend and a fraction of the wait.

Tags: #Claude #Anthropic #ArtificialIntelligence #LLM #DeveloperTools