Claude Code Thinking Modes and Effort

Default mode is fast. Sometimes you need deep.

By default, the model decides for itself how much to think on each step, and the effort level sets how far it goes. On Opus 5.5 that default is medium, which is fine for most coding. But for complex problems: architecture decisions, tricky bugs, multi-step plans: you want it to think harder first, not just react.

Claude Code has three ways to control how deeply it thinks before doing anything.

That run was in plan mode, turned on with Shift+Tab: the same prompt gets a read of the code and a plan first, and Claude changes files only after you approve it.

Extended thinking

Thinking means Claude reasons internally before giving you an answer. It works through the problem step by step, considers edge cases, and arrives at a more careful response. On current models this is adaptive: thinking is optional on each step, so routine prompts get fast answers and hard steps get deeper reasoning.

When it's worth it:

• Complex debugging where your first approach already failed
• Architecture decisions with real trade-offs
• Security reviews where you can't afford to miss something
• Refactoring that touches 10+ files

How to get more of it: Raise the effort level (next section), or put ultrathink anywhere in your prompt for one turn of deeper reasoning without changing your session setting. Plain phrases like "think hard" are not keywords; Claude reads them as ordinary guidance, still within your effort level.

What it costs: Thinking is billed as output tokens, even when Claude Code collapses or redacts it on screen. You pay for the thinking. For complex tasks, the quality improvement is usually worth it. For a simple bug fix, it's overkill.

On Opus 5.5 and the Fable models thinking is always on: Option+T (Alt+T on Windows and Linux) and MAX_THINKING_TOKENS=0 have no effect there, so effort is your only dial. Sonnet 5 always uses adaptive thinking too. Haiku 5.5 uses adaptive thinking with effort levels, the first Haiku to have them. Haiku 4.5 used the older extended thinking mode and had none.

Plan mode

Plan mode is the most practical thinking feature for daily use. Instead of diving into code changes immediately, Claude proposes a plan first. You review it, adjust if needed, then it executes.

Toggle it: Shift+Tab in the terminal, or /plan as a slash command.

What happens:

1. You give Claude a task
2. Claude proposes a step-by-step plan
3. You review and approve (or adjust)
4. Claude executes the approved plan

Use plan mode when:

• Any task touching more than 2-3 files
• You're not sure about the approach
• Destructive operations (deleting files, resetting databases)
• Onboarding a new team member who needs to see the steps

Skip plan mode when:

• Quick fixes ("change this color from blue to green")
• Single-file edits
• Tasks you've done the same way dozens of times

# Enable plan mode for the session
/plan

# Or toggle with keyboard shortcut
# Shift+Tab (toggles on/off)

Effort levels

Some tasks need deep thinking. Others just need a quick answer. Effort levels let you control the balance without switching models. Effort shapes every output token, not just thinking: lower effort also means fewer, terser tool calls.

Opus 4.7 and later, Sonnet 5, and the Fable models support all five levels. Opus 4.6 and Sonnet 4.6 stop at max without xhigh. Haiku 5.5 defaults to medium, and Anthropic's launch charts plot it from low to max. Haiku 4.5 has none. Pick a level a model lacks and Claude Code drops to the highest one it supports below it.

How to set it:

/effort              # Open the slider
/effort high         # Set it directly (saved as your default for this model)
/effort auto         # Clear your saved level and go back to the model default
claude --effort low  # Launch one session at a level

You can also move the effort slider with the arrow keys inside /model, set CLAUDE_CODE_EFFORT_LEVEL, or put effort: in a skill's or subagent's frontmatter. max only lasts for the current session unless you set it through the environment variable. The session header shows the active level, for example "with low effort".

Moving from Opus 5? Opus 5.5 defaults one level lower than Opus 5 did, and Anthropic's testing puts Opus 5.5 at medium level with or ahead of Opus 5 at high on coding. At the same level name it also thinks more per turn. So start at medium instead of carrying your old setting over, and save xhigh and max for work where you've seen them help.

Change it at the start, not mid-session. Changing effort mid-conversation can invalidate the prompt cache, and Claude Code may show a cache warning first. Pick a level when you start a session and leave it.

The /effort menu also lists ultracode. That is a Claude Code setting rather than a model level: it sends xhigh and has Claude plan a multi-agent workflow for each substantive task. Expect it to spend far more tokens.

Combining thinking modes

The real power is mixing these together.

Plan mode + Opus: For architecture decisions. Claude thinks deeply AND shows you the plan before executing. Maximum safety, maximum quality. Use this when you're redesigning something load-bearing.

Quick mode + Haiku: For rapid iteration. Fast answers, low cost. Great for "does this look right?" checks throughout the day.

Extended thinking + Sonnet: The daily sweet spot. Sonnet thinks through the problem carefully but doesn't take as long (or cost as much) as Opus. This is what I use for most non-trivial tasks.

Practical patterns

The "think then do" pattern

"Before you make any changes, analyze this codebase and tell me:
1. What's the current architecture?
2. What are the risks of changing X?
3. What's your recommended approach?

Then wait for my approval before making changes."

This forces Claude to think first even without plan mode. Useful when you want the reasoning visible but don't want to toggle a mode.

The "rubber duck" pattern

"I'm stuck on this bug. Don't fix it yet. Just think through 
what could be causing it. List your hypotheses from most to 
least likely."

Use Claude as a thinking partner, not just a code generator. Sometimes the most valuable thing it does is help you articulate the problem clearly.

The "pre-mortem" pattern

"I'm about to deploy this change. Before I do, think about 
what could go wrong. What edge cases am I missing?"

Extended thinking plus a pre-mortem catches issues that quick mode would miss entirely. I run this before any deploy that touches auth, payments, or data migrations.