Effort, Fast Mode, and Thinking - AI's 'Thinking Depth' Control Knob

Do you ever feel like Claude Code is sometimes too verbose, sometimes not thinking deeply enough?

This isn’t the AI having “bad days” - it’s a matter of “thinking depth” calibration. Today let’s talk about Claude Code’s three power tools: Effort, Fast Mode, and Thinking - how they control AI’s “mental energy consumption.”

Why Control Reasoning Depth?

Deeper thinking does not equal better results.

For “rename variable from foo to bar”, having AI think for 10 seconds is wasteful; for “refactor error handling in entire authentication module”, quick shallow responses produce low-quality code.

Claude Code controls reasoning depth through three mechanisms:

Effort: reasoning effort level (low/medium/high/max)
Fast Mode: Opus 4.6 acceleration mode
Thinking: chain-of-thought configuration (adaptive/enabled/disabled)

Effort: Four-Level Reasoning Effort

Effort is Claude API’s native parameter, controlling how much “thinking time” the model invests.

Four Levels

Level	Description	Use Case
low	Fast, direct implementation	Simple renaming, adding comments
medium	Balanced approach	Standard implementation and testing
high	Comprehensive implementation	Complex architecture decisions
max	Deepest reasoning	Opus 4.6 only

Max level restriction: Only opus-4-6 and internal models support it. Other models using max get downgraded to high.

Priority Chain

Actual Effort value is determined by three layers of priority:

Environment variable CLAUDE_CODE_EFFORT_LEVEL (highest priority)
    ↓ Not set
AppState.effortValue (/effort command or UI setting)
    ↓ Not set
Model defaults
    - Opus 4.6 Pro users → medium
    - Ultrathink enabled → medium
    - Others → undefined (API default high)

Why does Opus 4.6 default to medium?

This is an A/B tested decision. Most programming interactions don’t need deepest reasoning - lowering default effort:

Significantly improves throughput
Reduces latency
Decreases costs

When users need deep reasoning, they can use the ultrathink keyword for temporary boost (see below).

Numeric Effort (Internal Only)

Internal users can use numeric effort (0-100), mapping rules:

≤50 → low
≤85 → medium
≤100 → high
100 → max

Numeric does not persist to settings file, only exists during session runtime.

Fast Mode: Opus 4.6 Acceleration

Fast Mode (internal codename “Penguin Mode”) lets non-Opus models use Opus 4.6 capabilities.

How It Works

When user’s primary model is not Opus, specific requests can be routed to Opus 4.6 for higher quality responses.

Hardcoded to Opus 4.6:

if (Fast Mode enabled && conditions met) {
    Route to Opus 4.6
} else {
    Use original model
}

If user is already using Opus 4.6, Fast Mode is essentially itself (no change).

Availability Checks

Fast Mode has a series of checks:

Statsig remote kill (highest priority)
Non-native binary (optional check)
SDK mode (disabled by default)
Non-first-party provider (Bedrock/Vertex unsupported)
Organization-level disable

Cooldown State Machine

Fast Mode has an elegant cooldown mechanism:

active (normal)
    ↓ Trigger cooldown (rate limit/service overload)
cooldown (cooling, record resetAt time)
    ↓ Time expires
active (resume)
    ↓ Organization disables
disabled (permanent)

Lazy expiration detection: no timers used - check status on each query. This avoids timer resource consumption.

Three-State Output

What users see for Fast Mode status:

on: normal operation, show acceleration icon
cooldown: temporary degradation, show notice
off: not enabled

Thinking: Chain-of-Thought Configuration

Thinking controls whether the model outputs reasoning process.

Three Modes

Mode	API Behavior	Applicable Conditions
adaptive	Model decides how much to think	Opus 4.6, Sonnet 4.6, other new models
enabled	Fixed token budget chain-of-thought	Older Claude 4 models that don’t support adaptive
disabled	No chain-of-thought output	API validation, low-overhead calls

Model Compatibility Tiers

modelSupportsThinking(): detects whether model supports chain-of-thought

First-party and Foundry: all models except Claude 3
Third-party (Bedrock/Vertex): only Sonnet 4+ and Opus 4+

modelSupportsAdaptiveThinking(): detects whether model supports adaptive mode

Only 4.6 versions explicitly support it
First-party and Foundry default true (new models trained with adaptive thinking)
Third-party default false

shouldEnableThinkingByDefault(): decides whether to enable thinking by default

Environment variable MAX_THINKING_TOKENS > 0 → enabled
Setting alwaysThinkingEnabled === false → disabled
Default → enabled

Interaction with Effort

When Effort is medium and Thinking is adaptive:

Model chooses less reasoning
Ultrathink raises Effort to high
Adaptive thinking increases reasoning depth accordingly

This is the “medium default + zero-friction upgrade” design philosophy.

Ultrathink: Keyword-Triggered Deep Reasoning

Ultrathink is an clever interaction design: including the ultrathink keyword in a message automatically raises Effort from medium to high.

Double Gating

if (ULTRATHINK feature switch enabled && GrowthBook runtime flag enabled) {
    Detect keyword
}

Keyword Detection

Uses word boundary matching (\b), case-insensitive:

/\bultrathink\b/i.test(text)

Attachment Injection

Ultrathink doesn’t directly modify API parameters - it uses the attachment system:

[{ type: 'ultrathink_effort', level: 'high' }]

Converts to system reminder message:

User requested reasoning effort level: high. Apply this to the current turn.

Lets model self-adjust in adaptive thinking mode.

Rainbow UI

When Ultrathink activates, UI displays keyword in rainbow colors, giving users visual feedback.

The Synergy of Three Mechanisms

User input
    ↓
Contains "ultrathink"? → Inject ultrathink_effort attachment
    ↓
resolveAppliedEffort(model, appState.effortValue)
    ↓
Effort value → sent to API effort parameter
    ↓
Fast Mode check → may route to Opus 4.6
    ↓
Thinking configuration → adaptive/enabled/disabled
    ↓
API call: messages.create({ model, effort, thinking })

Key interaction points:

Effort + Thinking: in adaptive mode, higher effort means deeper thinking
Fast Mode + Effort: Fast Mode changes model, Effort changes reasoning depth of same model
Fast Mode + Thinking: when routing to Opus 4.6, automatically supports adaptive thinking

Practical: How to Tune Reasoning Depth

Scenario 1: Simple code modification

/effort low

Simple tasks like renaming variables, adding comments - use low to reduce latency.

Scenario 2: Complex architecture decisions

/effort high

Or directly input:

Please help me design this module's interface ultrathink

Scenario 3: Environment Variable for Team Policy

Team-wide policy:

export CLAUDE_CODE_EFFORT_LEVEL=high

Set to unset or auto to not send effort parameter, using server-side default.

Scenario 4: Fast Mode Cooldown

When Fast Mode enters cooldown due to rate limits, system automatically falls back to original model. Cooldown is temporary - auto-recovers when time expires, no manual intervention needed.

Scenario 5: Disable Adaptive Thinking

When you need forced fixed budget mode:

export CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=true

Design Insights

“Medium” as Default Philosophy

Opus 4.6 defaults to medium instead of high for Pro users, reflecting a tradeoff:

Most programming interactions don’t need deepest reasoning
Lower default effort improves throughput and reduces latency
Ultrathink provides zero-friction upgrade path

Lazy State Check Pattern

Fast Mode cooldown expiration detection doesn’t use timers - calculates lazily on each status query. This avoids timer resource overhead and race conditions.

Cautious Persistence Boundaries

max effort not persisted for external users
Numeric effort not persisted
Fast Mode per-session opt-in option

These designs follow the same principle: high-overhead configuration should not leak across sessions.

Summary

Effort, Fast Mode, and Thinking form Claude Code’s reasoning control panel:

Effort four levels: low/medium/high/max, controlling thinking depth
Fast Mode: lets non-Opus models use Opus 4.6
Thinking three modes: adaptive/enabled/disabled, controlling chain-of-thought
Ultrathink: semantic control interface, zero-friction upgrade

This is like:

Effort is “mental gear”
Fast Mode is “turbocharger”
Thinking is “self-talk switch”
Ultrathink is “emergency deep thinking button”

Understanding these three mechanisms lets you:

Choose appropriate reasoning depth based on task complexity
Balance response speed and quality
Implement similar controls in your own AI Agents

Next up: 89 Feature Flags - Claude Code’s “Secret Switches.”

Why Control Reasoning Depth?#

Effort: Four-Level Reasoning Effort#

Four Levels#

Priority Chain#

Numeric Effort (Internal Only)#

Fast Mode: Opus 4.6 Acceleration#

How It Works#

Availability Checks#

Cooldown State Machine#

Three-State Output#

Thinking: Chain-of-Thought Configuration#

Three Modes#

Model Compatibility Tiers#

Interaction with Effort#

Ultrathink: Keyword-Triggered Deep Reasoning#

Double Gating#

Keyword Detection#

Attachment Injection#

Rainbow UI#

The Synergy of Three Mechanisms#

Practical: How to Tune Reasoning Depth#

Scenario 1: Simple code modification#

Scenario 2: Complex architecture decisions#

Scenario 3: Environment Variable for Team Policy#

Scenario 4: Fast Mode Cooldown#

Scenario 5: Disable Adaptive Thinking#

Design Insights#

“Medium” as Default Philosophy#

Lazy State Check Pattern#

Cautious Persistence Boundaries#

Summary#