Claude Extended Thinking: Deep Reasoning in Practice

What is Extended Thinking?

Extended Thinking is a feature that allows Claude to think deeply before responding. Instead of immediately generating a response, Claude:

1. →Explores different approaches to the problem
2. →Verifies its reasoning step by step
3. →Corrects its errors along the way
4. →Formulates a more reliable final response

It's the equivalent of asking an expert to take time to think rather than answering instantly.

Without vs With Extended Thinking

Enabling Extended Thinking via the API

Basic Implementation

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # Maximum budget for thinking
    },
    messages=[{
        "role": "user",
        "content": "Solve this dynamic programming problem: given an array of integers, find the longest increasing subsequence."
    }]
)

# Iterate through response blocks
for block in response.content:
    if block.type == "thinking":
        print("🧠 Thinking:")
        print(block.thinking)
        print("---")
    elif block.type == "text":
        print("💬 Response:")
        print(block.text)

Adaptive Thinking (Claude 4.6)

Claude 4.6's adaptive thinking automatically adjusts reasoning effort based on complexity:

response = client.messages.create(
    model="claude-opus-4-20250918",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # MAXIMUM budget, not fixed
    },
    messages=[{
        "role": "user",
        "content": "What is the capital of France?"
    }]
)
# → Minimal thinking (~50 tokens) because the question is simple

response2 = client.messages.create(
    model="claude-opus-4-20250918",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    messages=[{
        "role": "user",
        "content": "Prove that the square root of 2 is irrational."
    }]
)
# → Extended thinking (~5000 tokens) because the problem is complex

Budget Tokens: Optimizing Cost

The budget_tokens defines the maximum number of tokens Claude can use for thinking.

Allocation Strategy

def get_thinking_budget(task_type):
    """Returns a thinking budget suited to the task type."""
    budgets = {
        "simple_qa": 1000,
        "code_review": 5000,
        "bug_fix": 8000,
        "algorithm_design": 12000,
        "math_proof": 20000,
        "architecture": 15000,
    }
    return budgets.get(task_type, 5000)

# Usage
budget = get_thinking_budget("bug_fix")
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": budget},
    messages=[{"role": "user", "content": "..."}]
)

Important Constraints

• →Minimum: budget_tokens must be ≥ 1024
• →Maximum: budget_tokens + max_tokens must not exceed the model's limit
• →Billing: Thinking tokens are billed at the output token rate
• →No cache: Thinking tokens are not eligible for prompt caching

When to Use Extended Thinking?

✅ Use It

❌ Avoid It

• →Simple factual questions: "What is the capital of France?" → Not needed
• →Free creative tasks: "Write a poem" → Thinking doesn't improve creativity
• →Low-latency chatbots: Thinking adds latency
• →Tight budget: Thinking tokens are billed and add up quickly

Streaming with Extended Thinking

with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": 8000},
    messages=[{"role": "user", "content": "Design a database for a social network."}]
) as stream:
    current_type = None
    for event in stream:
        if hasattr(event, 'type'):
            if event.type == "content_block_start":
                block_type = event.content_block.type
                if block_type == "thinking":
                    print("\n🧠 Thinking in progress...")
                    current_type = "thinking"
                elif block_type == "text":
                    print("\n💬 Response:")
                    current_type = "text"
            elif event.type == "content_block_delta":
                if current_type == "thinking" and hasattr(event.delta, 'thinking'):
                    print(event.delta.thinking, end="")
                elif current_type == "text" and hasattr(event.delta, 'text'):
                    print(event.delta.text, end="")

Block Order in Streaming

1. message_start
2. content_block_start (type: "thinking")
3. content_block_delta (thinking content...)  ← thinking blocks
4. content_block_stop
5. content_block_start (type: "text")
6. content_block_delta (text content...)     ← final response
7. content_block_stop
8. message_stop

Performance Benchmarks

Extended Thinking significantly improves performance on reasoning benchmarks:

Advanced Patterns

Multi-Turn Conversation with Thinking

messages = []

def chat_with_thinking(user_msg, budget=5000):
    messages.append({"role": "user", "content": user_msg})
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=16000,
        thinking={"type": "enabled", "budget_tokens": budget},
        messages=messages
    )
    
    # Add the complete response (without thinking blocks)
    assistant_content = [
        block for block in response.content
        if block.type == "text"
    ]
    messages.append({"role": "assistant", "content": assistant_content})
    
    return response

# Usage
chat_with_thinking("Design a recommendation algorithm.", budget=10000)
chat_with_thinking("Optimize it for scalability.", budget=8000)

Dynamic Budget Based on Complexity

def estimate_complexity(message):
    """Estimates question complexity to adjust the budget."""
    complexity_indicators = {
        "prove": 3, "demonstrate": 3, "optimize": 2,
        "algorithm": 2, "architecture": 2, "compare": 1,
        "design": 2, "debug": 2, "why": 1,
        "analyze": 1, "explain": 0.5
    }
    
    score = sum(
        weight for keyword, weight in complexity_indicators.items()
        if keyword in message.lower()
    )
    
    if score <= 1:
        return 2000
    elif score <= 3:
        return 6000
    elif score <= 5:
        return 12000
    else:
        return 20000

budget = estimate_complexity("Prove and demonstrate that this algorithm is optimal.")
# → 20000 tokens (high complexity)

Common Errors