Speed Modes and Effort Tuning

You just asked Claude Code to rename a variable. It spent 30 seconds thinking deeply about it, burning through your token budget. A rename took the same cognitive effort as an architecture redesign. That's broken.

Claude Code gives you two knobs to fix this: fast mode and effort tuning. One controls output speed, the other controls how hard the model thinks. Together they let you match reasoning intensity to the actual complexity of what you're doing.

Fast Mode

Toggle it. That's it.

/fast on

/fast off

No config files, no environment variables. Just a runtime switch.

When fast mode is on, Claude Code still uses whatever model you have selected. It doesn't downgrade to a smaller model. It just produces output faster by spending less time on internal reasoning. Quick gut response vs. a written analysis.

Fast mode is great for rapid iteration. Exploring ideas, asking quick questions, making small edits. You don't need a 2,000-word explanation for every change. Flip it on, move fast, flip it off when you need depth.

Effort Levels

This goes deeper than fast mode. Effort levels control adaptive reasoning, which dynamically allocates thinking based on task complexity. Three levels: low, medium, high.

Three ways to set it.

Through the /model command. Open the model selector and use left/right arrow keys to adjust the effort slider. Quickest way mid-session.

Through an environment variable:

export CLAUDE_CODE_EFFORT_LEVEL=low

Valid values are low, medium, or high.

Through your settings file. Add an effortLevel key for a persistent default.

Effort tuning works on Opus 4.6 and Sonnet 4.6. The current effort level shows up next to the logo and spinner, so you always know where you stand. You might see "with low effort" displayed during processing.

See It in Action

Open Claude Code and run:

/model

Select your model, slide effort to "low" with the arrow keys. Ask it to rename a variable. Notice how fast it responds. Now slide to "high" and ask it to review a module's architecture. The difference in response depth is dramatic.

Extended Thinking

The third piece of the puzzle. Toggle with Alt+T on Windows/Linux or Option+T on macOS. If the keyboard shortcut doesn't work, run /terminal-setup first.

Extended thinking lets Claude Code spend more time reasoning through complex problems. It's on by default with a budget of 31,999 tokens. Those thinking tokens are billed as output tokens, so they cost real money.

You can cap the budget:

export MAX_THINKING_TOKENS=8000

Lower budgets mean less thinking, lower costs. For simpler tasks, reduce expenses by lowering effort, disabling extended thinking entirely, or capping the thinking budget.

To disable adaptive reasoning completely and go back to fixed thinking budgets:

export CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1

This kills the dynamic allocation and gives you predictable, fixed-cost reasoning on every request. Useful if you want tight control over spending.

Matching Effort to the Task

Not every task deserves deep thought. This is the heuristic that actually matters.

Low effort is for mechanical work. Renaming, fixing formatting, updating imports. Obvious correct answers where deep thinking just adds latency and cost.

Medium effort covers most of your day. Writing functions, implementing features from specs, refactoring components. Opus 4.6 defaults here for Max and Team subscribers.

High effort is for the genuinely hard problems. Architecture decisions, debugging multi-file issues, large refactors where Claude Code needs to hold a lot of moving parts in its head and reason about how they interact.

One thing worth experimenting with: a smaller model at high effort sometimes outperforms a larger model at low effort. The combinations aren't obvious.

My usual pattern: start at medium effort. Drop to low for a batch of mechanical edits. Bump to high when I hit a tricky bug. Switching is instant, so there's no reason not to.

Quick Reference

/fast on gives quicker output by reducing reasoning depth. Effort levels (low/medium/high) control how hard the model thinks, set via /model slider, env var, or settings. Extended thinking (Alt+T) costs output tokens, cap the budget with MAX_THINKING_TOKENS. Low for renames, medium for everyday coding, high for architecture and hard debugging. Thinking tokens are billed as output, so lowering effort directly reduces costs on simple tasks.