How to pick a Claude model and effort level

If you've used Claude for more than a week, you've switched models. Sonnet for the quick stuff, Opus when it matters. That part everybody figures out on their own.

The effort setting is the one people leave alone, and it's the one that changes more day to day.

Here's the difference in one line. The model decides how smart Claude is. Effort decides how thorough it is. They're not interchangeable, and no amount of one buys you the other.

If you shoot film this is already familiar. Your film stock and your lens set what the image can be — that's fixed before you press anything. Exposure decides how much light actually lands. Same scene, same glass, wildly different negative depending on how long you left the shutter open. Model is the stock. Effort is the exposure.

Effort isn't "thinking time"

This is the part that surprised me. I assumed effort just meant a longer pause before the answer arrived. It's broader than that. Effort controls how much work Claude does on your request overall — how many files it opens, how much it double-checks, how far into a multi-step job it pushes before coming back to ask you something.

At low effort Claude would rather ask you for context than go find it. At high effort it goes and finds it, runs the tests, and reads the thing next door just in case. That's why effort matters far more in Claude Code than in chat: in an agentic session, most of the tokens aren't prose, they're tool calls.

There are five levels.

• low — Just answer. Skims, barely uses tools, hands questions back to you. Good for renames, classification, quick lookups.
• medium — A competent pass with real savings. The honest default for cost-sensitive work.
• high — The default on nearly every model. Reads what it needs, verifies the obvious things. Best balance there is.
• xhigh — Investigates. Built for long agentic runs, the kind that go past half an hour and burn through millions of tokens.
• max — No ceiling. Genuinely helps on brutal problems, but it's prone to overthinking and the returns shrink fast.

Two things worth knowing before you read the grid. First, the same level name means different things on different models — the scale is calibrated per model, so Sonnet at max is nowhere near Opus at max in spend or depth. Second, high is the default almost everywhere, and the defaults are tuned. Treat effort as a standing preference for the kind of work you do, not a knob you fiddle with per task.

The grid

Read it like an exposure chart. Cool cells on the left are thin negatives — fast, cheap, a bit underdone. The amber column in the middle is correct exposure. The red end is blown out: more light than the scene needed.

About that last column

Ultracode isn't a sixth effort level, and it doesn't sit above max. It's a Claude Code session setting: it sends xhigh to the model and additionally has Claude plan a dynamic workflow for every substantial task, fanning work out across subagents without you asking for it.

It only lives in Claude Code, only lasts the current session, and can't be saved in your settings file or set through the environment variable. One request can turn into several workflows in a row: one to understand the code, one to change it, one to verify. Powerful, and open-ended in cost. Gauge it on one directory before you point it at a repo.

Some matchups worth understanding

The grid tells you where to start. These pairings are where people actually get stuck.

Opus high vs. Sonnet max

Opus knows more; Sonnet tries harder. Reach for Opus high when the problem is subtle — an unfamiliar domain, a bug whose cause isn't in the file you're staring at, an architecture tradeoff with no clean answer. Reach for Sonnet max when the problem is large but well-defined: you know exactly what needs doing, there's just a mountain of it. Sonnet max usually costs less and takes longer on the clock.

Fable high vs. Opus max

The cleanest illustration of the whole idea. Opus max is the expert with unlimited time. Fable high is the specialist working at a normal pace. If the task is something Opus can reach at all, Opus max gets there for less money. If it's something Opus fundamentally can't reach, long-horizon or genuinely novel, Fable high wins and Opus max just burns tokens converging on a confident wrong answer.

Opus high vs. Sonnet ultracode

Different shapes entirely. Opus high is one careful expert inside one context window. Sonnet ultracode is a generalist automatically fanning work across verifying subagents. Hard single question? Opus high. Sprawling job, migrate forty files or audit a whole module? Sonnet ultracode does more real work per hour, at a lower rate per token but an open-ended total.

Opus xhigh vs. Fable low

The underrated one. Fable low buys you the specialist's recognition cheaply, but it's a glance rather than a study. Opus xhigh buys exhaustive investigation from a slightly smaller brain. When something is weird rather than big, try Fable low first. One glance is sometimes the whole answer.

When it gets something wrong

Before you touch either dial, check the boring stuff: was the prompt vague, was Claude pointed at the right files, did it have the tools it needed. If you find yourself raising effort on a task that shouldn't need it, the fix is usually upstream in your context, not in the settings.

Once you've ruled that out, there's one question that sorts almost everything.

Did it not try hard enough, or did it not know enough?

Skipped a file, didn't run the tests, gave up on a refactor halfway? It didn't try hard enough. Raise the effort.

Confidently wrong no matter how much context you feed it? It didn't know enough. Go up a model.

And the reverse is just as useful. If you've been on the big model and the work has been routine for a while, drop down. You'll get faster answers for less money and the quality won't move.

The short version

Leave both settings on default most of the time. That's not a cop-out — the defaults are tuned to what most people would want to spend on a given task, and Anthropic's own guidance is to start there.

Then set effort once, deliberately, based on the kind of work you do rather than the task in front of you. If you write a lot of scoped, well-specified code, medium will save you real money. If you spend your days on ambiguous debugging, xhigh will pay for itself. Adjust the model when you hit a wall of capability, not a wall of patience.

Three small things that will save you a headache.

• persistence — low, medium, high and xhigh stick across sessions. max is session-only unless you set it via the environment variable, and ultracode always resets.
• ultrathink — type it anywhere in a Claude Code prompt for deeper reasoning on that one turn. It doesn't change your session's effort setting.
• older models — Opus 4.6 and Sonnet 4.6 don't have xhigh. Ask for it and you'll quietly get high instead.

Model is how capable. Effort is how thorough. Most real work needs some of both, and knowing which one you're short on is most of the skill.

Sources

Anthropic's effort documentation, the Claude Code model configuration docs, and Lydia Hallie's post on choosing a model and effort level. Model lineups and effort availability change often — verified August 2026.