Claude Code Ultrathink: What It Does and When to Use It

Claude Code ultrathink still works, but not the way most blog posts describe. Typing ultrathink in a prompt adds an in-context instruction asking Claude to reason more deeply on that turn. It does not raise a token budget, and think hard or think harder do nothing at all.

Effort levels and thinking behaviour verified 31 July 2026 against Anthropic's adaptive thinking documentation.

That distinction matters, because almost every popular guide to ultrathink describes a mechanism that no longer exists. If you picked up the trick from a viral thread, you are probably using it for the wrong reasons and expecting the wrong result. This post gives you the honest, current answer to "does ultrathink do anything?" — what the keyword really does today, what genuinely governs reasoning depth, and when deeper thinking earns its cost.

Where the ultrathink lore came from

Older models used a fixed reasoning allowance set through a budget_tokens parameter, and the CLI genuinely mapped certain phrases onto a larger allowance. Adaptive thinking replaced that plumbing, so the tiered ladder no longer has anything left to move.

The original story went like this: Claude Code scanned your prompt for magic phrases and mapped them onto a tiered thinking budget. think bought you a little reasoning, think hard more, think harder more still, and ultrathink unlocked the maximum. Community posts circulated exact token numbers for each tier, and the ladder got repeated so widely it became folklore.

The lore was real once. Older Claude models used a fixed reasoning allowance set through a budget_tokens parameter, and Claude Code did translate certain keywords into a larger allowance. Writing ultrathink genuinely moved a number.

Then the models changed underneath the trick. Anthropic's newer models use adaptive thinking, where the model decides per step whether to think and how much, rather than spending against a fixed ceiling. Per Anthropic's extended thinking documentation, budget_tokens is deprecated on Claude Opus 4.6 and Claude Sonnet 4.6, and on newer models it is not supported at all — passing it returns a 400 error. The plumbing the lore depended on was removed.

So the tiered ladder is dead. But the keyword itself is not, which is where most write-ups on the keyword go wrong in the opposite direction.

What Claude Code ultrathink actually does now

The keyword is still special-cased, but it works by asking rather than allocating: it injects an in-context instruction to reason harder on that turn, and the effort level sent to the API is unchanged. Sibling phrases are ordinary text.

Anthropic's Claude Code model configuration docs are explicit about this, and the wording is worth reading closely. Including ultrathink anywhere in your prompt requests deeper reasoning on that turn without changing your session effort setting. Claude Code recognizes the keyword and adds an in-context instruction. The effort level sent to the API is unchanged.

Three things follow from that sentence, and they resolve most of the confusion around the keyword:

1. The keyword is still recognized. It is not a placebo and it is not silently ignored. Claude Code special-cases it.
2. It works by asking, not by allocating. The keyword injects an instruction into your context telling Claude to reason harder. It is closer to a very reliable prompt than to a settings change.
3. The other tiers are gone. Phrases such as think, think hard, and think more are passed through as ordinary prompt text and are not recognized as keywords. They influence Claude only as much as any other English words in your prompt.

That last point quietly kills the ladder. There is no think < think hard < think harder < ultrathink scale anymore. There is ultrathink, and there is everything else.

What really controls thinking depth today

The effort level, set with /effort, is the real dial — five levels from low to max, defaulting to high on most current models. The extended-thinking toggle is the second lever, though it does nothing on models that always reason adaptively.

If claude code ultrathink is only a per-turn nudge, what actually moves the dial? The primary control on current models is the effort level, set with the /effort command. Effort governs adaptive reasoning — how readily the model spends thinking on each step.

Current models expose five effort levels: low, medium, high, xhigh, and max. Claude Sonnet 5, Claude Opus 5, and Claude Opus 4.8 currently support the full range, while the slightly older Claude Opus 4.6 and Claude Sonnet 4.6 offer four levels and skip xhigh. Default effort is high on most current models. Anthropic's own guidance notes that max is prone to overthinking and can show diminishing returns — a useful hint that more reasoning is not automatically better.

The extended-thinking toggle is the other lever. As documented in the Claude Code interactive mode reference, Option+T on macOS or Alt+T on Windows and Linux enables or disables extended thinking mode, and since v2.1.132 the shortcut works on macOS without configuring Option as Meta. On models that always reason adaptively, the toggle has no effect. If you want the mechanics of the underlying feature, our guide to extended thinking covers how the reasoning blocks work and what you pay for them.

When deeper thinking genuinely helps

Four situations share one trait: the bottleneck is reasoning rather than typing. Hard debugging where symptom and cause sit far apart, architecture trade-offs, multi-constraint refactors, and requirements vague enough that noticing the ambiguity is the first useful move.

Reasoning is not free — you are charged for thinking tokens even when they are collapsed and hidden. So spend them where they change the answer. Deeper thinking earns its cost on:

• Hard debugging, where the symptom and the cause sit far apart and the model has to hold several hypotheses at once before testing them.
• Architecture and design decisions, where the work is weighing trade-offs rather than typing code.
• Multi-constraint refactors — for example, a change that must preserve a public API, keep tests green, and stay backwards compatible with two callers at the same time.
• Ambiguous requirements, where the useful first move is noticing that the request is underspecified.

The common thread: the bottleneck is reasoning, not typing. Reaching for claude code ultrathink on a genuinely hard problem is reasonable. It nudges a single turn without permanently raising your effort setting, which is exactly the shape of "this one prompt is harder than the rest."

We build and maintain this site inside Claude Code every day, and in practice we type the keyword far less often than we expected to. Most of our work — drafting, editing, small refactors — runs fine on our default model without it. Where it earns its place is the occasional tangled build failure on our Windows setup, where the cause is two steps removed from the error message; that is a reasoning problem, and the per-turn nudge fits it well.

When Claude Code ultrathink just costs you tokens

Renames, log lines, a test for code already in context, a routine migration — none of these improve with more reasoning, and an overthinking model can second-guess a correct first instinct. Vague prompts need context, not depth.

Most prompts do not need it. Renaming a variable, adding a log line, writing a test for a function Claude already read, running a migration — none of these get better with more reasoning. They get slower and more expensive, and occasionally worse, because an overthinking model second-guesses a correct first instinct.

There is a subtler failure too. Reaching for claude code ultrathink is often a reflex for a prompt that is simply vague. Extra reasoning applied to a bad question produces a confidently reasoned bad answer. The model was never short on thinking; it was short on context. If Claude cannot see the file, no amount of deeper reasoning will make it guess correctly.

The honest heuristic: if you cannot say what Claude is supposed to think harder about, the keyword is not your problem.

Alternatives that work better than the keyword

Five controls move more weight: set a session effort level, force a plan before edits, hand over better context, delegate broad exploration to subagents, and pick a model whose reasoning depth already suits the work.

Before typing claude code ultrathink out of habit, try the controls that move more weight:

Set the effort level instead. If a whole session is hard, /effort xhigh is a real, persistent setting that changes what is sent to the API. The keyword is a per-turn nudge; effort is the dial. You can also express the same intent in plain English — Anthropic notes that if you want Claude to think more or less often, you can say so directly in your prompt or in CLAUDE.md, and the model responds within its effort setting.

Use plan mode. Forcing a plan before edits catches wrong approaches at the cheapest possible moment. Plan mode usually beats extra reasoning on a bad plan.

Give better context. Point at the files, paste the stack trace, name the constraint. Filling the context window with the right material outperforms the keyword on an empty context almost every time.

Delegate the search. When a task needs broad exploration, subagents investigate in a separate context and report back conclusions, which keeps your main session focused.

Pick the right model. Reasoning depth is a model property first. Our breakdown of the best Claude model for coding is a better starting point than any keyword. If you are new to the tool entirely, start with what Claude Code is. And don't confuse this with ultraplan — despite the similar name, that one is a real, documented feature rather than a magic word.

The short version

The mechanism the lore described is genuinely gone, but the keyword survives as a recognized per-turn nudge. Effort level, model choice, and the quality of the context you hand over are the controls that actually decide a hard prompt.

The lore is wrong and the backlash is also wrong. Claude code ultrathink was never deleted, but the mechanism it once triggered was — the tiered keyword-to-token-budget mapping is gone, and the sibling phrases are now just words. What survives is a recognized keyword that asks the model to reason harder for one turn, which is a genuinely useful thing to have when a single prompt is unusually hard.

Treat claude code ultrathink as what it is: a per-turn nudge, not a power-up. The real controls are your effort level, your model choice, and the quality of the context you hand over. Get those right and you will rarely need the keyword — and when you do reach for claude code ultrathink, it will be for a problem that actually deserves it.