Effektive Prompts für Extended Thinking

Prompting von Reasoning-Modellen unterscheidet sich

Keine Schritt-für-Schritt-Anweisungen geben

# Standard model: needs scaffolding
STANDARD_PROMPT = (
    'Let us think step by step.\n'
    'First, identify the variables.\n'
    'Then, set up the equation.\n'
    'Then, solve for x.\n'
    'Finally, verify your answer.\n\n'
    'Problem: If 3x + 7 = 22, what is x?'
)

# Reasoning model: just state the problem clearly
REASONING_PROMPT = (
    'Solve: If 3x + 7 = 22, what is x?'
    # The model handles the step-by-step internally
)

# Both produce correct answers; the reasoning model prompt is simpler
print('Reasoning model prefers the cleaner prompt')

Das Problem klar und vollständig formulieren

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Poor: vague problem statement
BAD_PROMPT = 'Write me a good sorting algorithm.'

# Good: clear, complete problem specification
GOOD_PROMPT = (
    'Write a Python sorting algorithm with these requirements:\n'
    '- Must sort a list of integers in ascending order\n'
    '- Must work correctly on empty lists, single-element lists, and lists with duplicates\n'
    '- Target time complexity: O(n log n) average case\n'
    '- Must not use Python built-in sort() or sorted()\n'
    '- Include a brief docstring and 3 test cases\n\n'
    'Return only the code, no explanation.'
)

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=8000,
    thinking={'type': 'enabled', 'budget_tokens': 5000},
    messages=[{'role': 'user', 'content': GOOD_PROMPT}]
)
print(next(b.text for b in response.content if b.type == 'text')[:300])

budget_tokens angemessen festlegen

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

def reasoning_call(prompt, budget_tokens=5000):
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=budget_tokens + 2048,  # max_tokens must exceed budget_tokens
        thinking={
            'type': 'enabled',
            'budget_tokens': budget_tokens
        },
        messages=[{'role': 'user', 'content': prompt}]
    )
    answer = next((b.text for b in response.content if b.type == 'text'), '')
    thinking_blocks = [b for b in response.content if b.type == 'thinking']
    print(f'Thinking blocks: {len(thinking_blocks)}')
    return answer

# Simple problem: small budget
reasoning_call('What is 17 * 23?', budget_tokens=1000)

# Complex problem: larger budget
reasoning_call(
    'Design a distributed rate limiter that handles 100k requests/second.',
    budget_tokens=10000
)

Minimale System-Prompts

# Over-engineered system prompt (hurts reasoning models)
BAD_SYSTEM = (
    'You are an expert Python developer. '
    'Always think step by step. '
    'First understand the problem. '
    'Then plan your approach. '
    'Then implement step by step. '
    'Check each step before proceeding. '
    'Finally review your solution. '
    'Format all code with comments. '
    'Add error handling to every function. '
    '...'
)

# Minimal system prompt (helps reasoning models)
GOOD_SYSTEM = (
    'You are an expert Python developer. '
    'Return only code unless explanation is explicitly requested. '
    'Use type hints and docstrings.'
)
# The model's internal reasoning handles the rest

Anweisungen zum Ausgabeformat sind weiterhin wichtig

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Clear output format instructions are still important
prompt = (
    'Analyze the time and space complexity of this Python function:\n\n'
    'def bubble_sort(arr):\n'
    '    n = len(arr)\n'
    '    for i in range(n):\n'
    '        for j in range(0, n-i-1):\n'
    '            if arr[j] > arr[j+1]:\n'
    '                arr[j], arr[j+1] = arr[j+1], arr[j]\n\n'
    'Return your answer as JSON with keys: '
    'time_complexity, space_complexity, explanation (2 sentences max).'
)

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=5000,
    thinking={'type': 'enabled', 'budget_tokens': 3000},
    messages=[{'role': 'user', 'content': prompt}]
)
print(next(b.text for b in response.content if b.type == 'text'))

Weniger Few-Shot-Beispiele

# Standard model: 3 few-shot examples improve performance significantly
STANDARD_FEW_SHOT = (
    'Q: 2 + 2 = ?\nA: 4\n\n'
    'Q: 5 * 6 = ?\nA: 30\n\n'
    'Q: 100 / 4 = ?\nA: 25\n\n'
    'Q: 17 + 38 = ?\nA:'
)

# Reasoning model: 0 examples is fine; 1 is enough if format is unclear
REASONING_DIRECT = 'What is 17 + 38?'

# The reasoning model already knows math — examples are overhead, not signal
# Only use 1 example when the output format needs clarification:
REASONING_FORMAT_EXAMPLE = (
    'Answer math questions returning only the number.\n'
    'Example: Q: 2 + 2  A: 4\n\n'
    'Q: 17 + 38'
)

Mit Unsicherheit in Ausgaben von Reasoning-Modellen umgehen

import anthropic
import re

client = anthropic.Anthropic(api_key='sk-ant-...')

def reasoning_with_confidence(question):
    prompt = (
        f'{question}\n\n'
        f'At the end of your answer, include a confidence statement: '
        f'Confidence: [HIGH/MEDIUM/LOW] — [one sentence why]'
    )
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=8000,
        thinking={'type': 'enabled', 'budget_tokens': 5000},
        messages=[{'role': 'user', 'content': prompt}]
    )
    text = next(b.text for b in response.content if b.type == 'text')

    # Parse confidence
    match = re.search(r'Confidence: (HIGH|MEDIUM|LOW)', text)
    confidence = match.group(1) if match else 'UNKNOWN'
    print(f'Confidence: {confidence}')
    return text, confidence

answer, conf = reasoning_with_confidence(
    'What will AI capabilities look like in 2030?'
)

Ausgaben von Reasoning-Modellen cachen

import hashlib
import json
import os

cache_dir = '/tmp/reasoning_cache'
os.makedirs(cache_dir, exist_ok=True)

def cached_reasoning_call(prompt, budget_tokens=5000):
    # Create cache key from prompt
    key = hashlib.sha256(f'{prompt}:{budget_tokens}'.encode()).hexdigest()
    cache_file = os.path.join(cache_dir, f'{key}.json')

    if os.path.exists(cache_file):
        with open(cache_file) as f:
            cached = json.load(f)
        print('Cache hit!')
        return cached['answer']

    # Cache miss: call the model
    answer = reasoning_call(prompt, budget_tokens)

    with open(cache_file, 'w') as f:
        json.dump({'prompt': prompt, 'answer': answer}, f)

    return answer

Ausgaben von Reasoning-Modellen überprüfen

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

def reasoning_with_verification(question):
    # Step 1: Get reasoning model answer
    r1 = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=10000,
        thinking={'type': 'enabled', 'budget_tokens': 8000},
        messages=[{'role': 'user', 'content': question}]
    )
    answer = next(b.text for b in r1.content if b.type == 'text')

    # Step 2: Independent verification call
    verify_prompt = (
        f'Question: {question}\n\n'
        f'Proposed answer: {answer}\n\n'
        f'Is this answer correct? Respond with CORRECT, INCORRECT, or UNCERTAIN, '
        f'followed by a brief explanation.'
    )
    r2 = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=256,
        messages=[{'role': 'user', 'content': verify_prompt}]
    )
    verification = r2.content[0].text
    print(f'Verification: {verification[:100]}')
    return answer, verification

Praktische Checkliste für Prompts von Reasoning-Modellen

Wissenscheck: Prompting von Reasoning-Modellen

Zusammenfassung: Effektive Prompts für erweitertes Denken