Updated February 2026 for Opus 4.6. The original post was written for Opus 4.5, which used manual thinking budgets. Opus 4.6 introduced adaptive thinking and the effort parameter, which changes how this works under the hood. The trigger words still work in Claude Code, but the system behind them is different now. Details below.
I toggle thinking mode with Tab constantly. On for planning, off for quick edits. It works great until it doesn’t.
Sometimes Claude gives me a plan that’s… fine. Surface level. Missing the edge cases I know are going to bite me later. That’s when I discovered the magic words.
Table of contents
Open Table of contents
The thinking trigger words
Claude Code has specific phrases that unlock progressively deeper reasoning:
- think -> Small boost
- think hard -> Medium reasoning
- think harder -> Extended thinking
- ultrathink -> Maximum depth (yes, it sounds like an energy drink for robots, and honestly it kind of is)
Just drop them naturally into your prompt: “Ultrathink about why this auth flow keeps failing.”
Important caveat: these are a Claude Code feature, not a general Claude API or claude.ai thing. They work because Claude Code’s system prompt maps these words to specific thinking configurations. If you’re using the API directly, you need to set thinking parameters yourself (more on that below).
What changed with Opus 4.6
When I originally wrote this post, Claude used manual thinking budgets. You (or Claude Code on your behalf) would set a budget_tokens value that capped how much internal reasoning Claude could do. The trigger words mapped to progressively larger budgets.
Opus 4.6 replaced that with two new concepts:
Adaptive thinking (thinking: {type: "adaptive"}) lets Claude decide on its own whether a problem needs deep reasoning. Ask it “what’s 2+2?” and it skips thinking entirely. Ask it to debug a race condition across three async services and it thinks extensively. No manual budget needed.
The effort parameter (effort: "low" | "medium" | "high" | "max") is the new knob for controlling how hard Claude works. It affects everything: thinking depth, number of tool calls, response length. At high (the default), Claude almost always thinks. At low, it skips thinking for simple stuff and keeps responses tight.
Here’s how the old and new map (roughly):
| Trigger word | Old system (Opus 4.5) | New system (Opus 4.6) |
|---|---|---|
| (no trigger) | Default thinking budget | effort: "high" (adaptive) |
| think | Small budget boost | Nudge toward thinking |
| think hard | Medium budget | effort: "high" with emphasis |
| think harder | Large budget | Leaning toward effort: "max" |
| ultrathink | Maximum budget | effort: "max" territory |
The trigger words still work in Claude Code. But behind the scenes, the model is smarter about allocating its own thinking now. You’re less likely to need them because adaptive thinking handles most cases automatically.
When to still reach for ultrathink
Even with adaptive thinking, I still use the triggers. Here’s when:
Debugging. There are so many variables that get overlooked in a quick pass. Race conditions, state mutations, that one edge case you forgot about three files ago. Making Claude actually think through the problem instead of pattern-matching to a solution changes everything. It’s like the difference between asking your kid “did you clean your room?” and “show me under the bed.”
Architecture decisions. When I’m asking Claude to evaluate tradeoffs between approaches, I want it to actually weigh the options, not just pick the first reasonable one.
When it’s not clicking. I’ve given context and examples and it’s still off. That’s when I stop treating Claude like a tool and start treating it like a coworker. “Think with me here, what are we missing?” Sounds silly. Works surprisingly well.
When I would have said “be thorough” in the old days. If you catch yourself adding “make sure to consider all edge cases” or “be comprehensive,” just say “ultrathink” instead. It’s more direct and the model responds to it better.
If you’re using the API directly
The trigger words are a Claude Code convenience. If you’re building with the API, here’s what to actually set:
# Opus 4.6 - adaptive thinking (recommended)
response = client.messages.create(
model="claude-opus-4-6",
max_tokens=16000,
thinking={"type": "adaptive"},
output_config={"effort": "high"}, # or "max", "medium", "low"
messages=[{"role": "user", "content": "..."}],
)
# Older models - manual thinking budget
response = client.messages.create(
model="claude-sonnet-4-5-20250929",
max_tokens=16000,
thinking={"type": "enabled", "budget_tokens": 10000},
messages=[{"role": "user", "content": "..."}],
)The budget_tokens approach still works on Opus 4.6 but it’s deprecated. Anthropic says they’ll remove it in a future release.1
One more thing: interleaved thinking
This didn’t exist when I wrote the original post. With adaptive thinking on Opus 4.6, Claude can think between tool calls automatically. It reads a file, thinks about what it found, decides what to do next, calls another tool, thinks again.
On older models you needed a beta header for this. On 4.6 with adaptive thinking, it just happens. This is a big deal for Claude Code specifically, since most of what it does is chain tool calls together (read files, edit files, run commands). The model is reasoning between each step instead of planning everything upfront and hoping for the best.
The bottom line
The trigger words still work. Use them. But Opus 4.6 is genuinely smarter about when to think deeply on its own. The biggest shift is that you don’t have to micromanage the model’s reasoning anymore. You can focus on writing good prompts (context, specifics, examples) and let adaptive thinking handle the rest. Save “ultrathink” for when you really mean it.2
Want more Claude Code productivity tips? Check out my full breakdown of background tasks, MCPs, and my updated workflow.