Du rufst die Claude API auf — Anthropics Schnittstelle, um Prompts zu senden und programmatisch Antworten zu bekommen — und bei einfachen Aufgaben läuft alles wie geschmiert. Extraktion, Zusammenfassung, Klassifikation: Claude nagelt das. Dann wirfst du was Hartes rein. Einen Pull Request mit 2.000 Zeilen reviewen. Eine Datenbank-Migration planen. Eine Race Condition debuggen. Die Antwort kommt schnell, selbstbewusst — und subtil falsch. Wie ein Student, der das Lehrbuch überflogen hat und jetzt die Klausur improvisiert.

Das Problem ist nicht das Modell. Das Problem: Du gibst ihm kein Schmierblatt.

Warum "Lies einfach die Doku" nicht reicht

Claude hat ein Feature namens Extended Thinking — die Fähigkeit, intern Schritt für Schritt zu denken, bevor es antwortet. Wie den Rechenweg in der Mathearbeit aufschreiben, nur dass der Rechenweg unsichtbar bleibt. Anthropic hat es am 24. Februar 2025 mit Claude 3.7 Sonnet eingeführt, und seitdem hat sich einiges getan.

Die Doku ist gründlich. Aber auch 4.000 Wörter aus Parametertabellen, Deprecation-Hinweisen und Migrations-Guides, verteilt auf drei separate Seiten. Die meisten Entwickler machen eins von drei Dingen: Thinking komplett ignorieren, eine Config aus einem Blog-Post kopieren, der für ein älteres Modell geschrieben wurde, oder Thinking ohne Kostenkontrolle aktivieren und sich über eine 50-Dollar-Rechnung wundern.

Am 16. April 2026 hat Anthropic Claude Opus 4.7 veröffentlicht und alle drei Ansätze zerschossen. Der manuelle budget_tokens-Parameter, mit dem man früher die Thinking-Kosten kontrolliert hat? Liefert jetzt einen 400-Error. Ein neuer Tokenizer bläht Token-Counts um bis zu 35 % auf. Und Thinking ist standardmäßig unsichtbar — während es dir trotzdem die vollen 25 Dollar pro Million Tokens berechnet.

So richtest du es korrekt ein, Stand 27. April 2026.

Schritt 1: Adaptive Thinking aktivieren

Auf Opus 4.7 nutzt du Adaptive Thinking — das Modell entscheidet selbst, wie viel es nachdenkt, basierend auf der Problemkomplexität. Keine manuellen Token-Budgets mehr. Du steuerst die Intensität über einen effort-Parameter (ein einfaches Label wie "low", "high" oder "max") statt eine Zahl zu raten.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},
    messages=[{
        "role": "user",
        "content": "Review this SQL migration for correctness and edge cases: ..."
    }],
)

Drei Zeilen dazu: thinking, output_config und ein größeres max_tokens — die Obergrenze, wie viele Tokens (Wort-Stücke, die die KI verarbeitet, grob ¾ eines englischen Wortes) die Antwort enthalten darf. Thinking-Tokens zählen gegen dieses Limit, also setz es auf mindestens 16.000. Anthropic empfiehlt 32.000+ für komplexe Aufgaben. Wenn allein das Thinking dein Maximum sprengen würde, schlägt der Request fehl — keine Teilantwort, nur ein Error.

/faion ist Neros Prompt-Tool zum Generieren von funktionierendem Code aus einer Spec — füg den Block unten ein und bekomm einen produktionsreifen Startpunkt.

/faion
Generate a Python function `call_with_thinking(prompt: str, effort: str = "high") -> str` that calls Claude Opus 4.7 with adaptive thinking using the anthropic Python SDK. Accept an effort parameter ("low", "medium", "high", "xhigh", "max"). Set max_tokens to 16000. Return the text response. Include error handling for API errors and a docstring explaining the effort levels.

Schritt 2: Das richtige Effort-Level wählen

Nicht jeder Prompt verdient einen Doktortitel. Hier der Spickzettel, basierend auf Anthropics Empfehlungen und Produktionsdaten aus Resolve AIs Tests:

Effort Was passiert Wann verwenden
low Überspringt Thinking bei trivialen Aufgaben Klassifikation, Extraktion, Massen-Pipelines
medium Moderates Reasoning, kann Thinking überspringen Ausgewogenes Kosten-/Qualitätsverhältnis, die meisten agentischen Workflows
high Denkt fast immer gründlich nach Code Review, Analyse, Planung
xhigh Erweiterte Exploration (nur Opus 4.7) Multi-File-Coding, lange agentische Ketten
max Keine Limits beim Denken Grenzprobleme, Forschung, unbegrenztes Budget

Die Kernerkenntnis von Resolve AI: Sonnet 4.6 mit medium Effort erreicht ungefähr Opus-4.6-Qualität — zu einem Bruchteil der Kosten. Greif nicht zum größten Modell — greif zum richtigen Effort-Level auf einem günstigeren. Die cleverste Optimierung ist oft, gar nicht erst für Opus zu bezahlen.

Schritt 3: Thinking streamen für Echtzeit-UX

Ohne Streaming bedeutet ein denkintensiver Request, dass dein User 30+ Sekunden auf einen toten Bildschirm starrt. Mit Streaming sieht er live, wie das Modell denkt — sichtbarer Fortschritt statt existenzieller Zweifel, ob die App abgestürzt ist.

with client.messages.stream(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive", "display": "summarized"},
    messages=[{"role": "user", "content": "Analyze this codebase architecture..."}],
) as stream:
    for event in stream:
        if event.type == "content_block_delta":
            if event.delta.type == "thinking_delta":
                print(f"[thinking] {event.delta.thinking}", end="", flush=True)
            elif event.delta.type == "text_delta":
                print(event.delta.text, end="", flush=True)

Beachte "display": "summarized". Auf Opus 4.7 ist der Default "omitted" — das Modell denkt, du zahlst für die Tokens, aber der Thinking-Text kommt leer zurück. Du musst display explizit setzen, wenn du sehen willst, worüber das Modell nachgedacht hat. Unsichtbares Reasoning debuggen macht genau so viel Spaß, wie es klingt.

/faion
Generate a Python function `stream_thinking_response(prompt: str, effort: str = "high")` that calls Claude Opus 4.7 with adaptive thinking and streaming enabled via the anthropic Python SDK. Set display to "summarized". Print thinking deltas prefixed with "[thinking]" and text deltas without prefix. Set max_tokens to 32000. Handle stream cleanup properly with a context manager.

Schritt 4: Tool Use ohne Kontextverlust

Wenn deine Integration Tools verwendet — Funktionen, die das Modell aufrufen kann, wie eine Datenbank abfragen oder eine externe API ansprechen — musst du Thinking-Blocks beim Fortsetzen der Konversation beibehalten. Lass sie weg, und Claude verliert seinen Reasoning-Kontext mitten im Ablauf.

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    tools=[your_tool],
    messages=[
        {"role": "user", "content": "What's the production error rate?"},
        {"role": "assistant", "content": [
            thinking_block,   # BEHALTE DAS — ohne geht der Kontext flöten
            tool_use_block
        ]},
        {"role": "user", "content": [tool_result]},
    ],
)

Eine Einschränkung, die agentische Architekturen beißen wird: Mit aktiviertem Thinking unterstützt tool_choice — der Parameter, der steuert, ob Claude ein bestimmtes Tool verwenden muss — nur "auto" oder "none". Ein bestimmtes Tool erzwingen liefert einen Error.

Schritt 5: Überwache, was du wirklich zahlst

Jede Response enthält ein usage-Objekt. Nach dem Aktivieren von Thinking wird das die wichtigste Zeile in deiner Codebase:

cost_per_mtok = 25  # Opus 4.7 Output-Preis
output_cost = (response.usage.output_tokens / 1_000_000) * cost_per_mtok
print(f"Output tokens: {response.usage.output_tokens} (${output_cost:.4f})")

Der Output-Token-Count enthält ALLE Thinking-Tokens — auch die unsichtbaren bei display: "omitted". Wenn deine sichtbare Antwort 500 Tokens hat, aber output_tokens 8.000 sagt, hast du gerade für 7.500 Tokens Reasoning bezahlt, das niemand gesehen hat. Laut Anthropics Pricing-Seite werden Thinking-Tokens zum vollen Output-Tarif berechnet: 25 $/MTok für Opus, 15 $/MTok für Sonnet.

/faion
Generate a Python helper function `log_thinking_cost(response, model: str = "claude-opus-4-7")` that takes an Anthropic Messages API response object and prints a cost breakdown: input tokens, output tokens (including thinking), cache read tokens, and total estimated cost in USD. Use a dict of per-model pricing (Opus 4.7: $15 input / $25 output, Sonnet 4.6: $3 input / $15 output). Warn if output_tokens exceeds 5000 with a note about possible high thinking usage.

Fallstricke, die dich erwischen werden

Die Tokenizer-Steuer. Der neue Tokenizer von Opus 4.7 generiert bis zu 35 % mehr Tokens für denselben Text im Vergleich zu Opus 4.6. Deine Kosten steigen ohne eine einzige Code-Änderung, sobald du das Modell upgradest. Ein Thinking-Prozess, der auf Opus 4.6 noch 0,25 $ gekostet hat, kann auf 4.7 bei 0,34 $ landen — selbes Reasoning, größere Rechnung. Überwache usage vor und nach dem Modellwechsel.

Thinking-Tokens können nicht per Prompt-Caching gecacht werden. Prompt Caching — Anthropics Feature, das wiederholte Input-Tokens rabattiert — gilt nicht für Thinking-Inhalte. In agentischen Loops mit vielen Tool Calls liest Claude die Thinking-Blocks aus vorherigen Turns als Input erneut ein. Das erzeugt kumulierende Kosten, die du nur siehst, wenn du cache_read_input_tokens separat trackst.

Die Legacy-Falle. Noch auf Claude Sonnet 4.6 oder Opus 4.6? budget_tokens funktioniert noch. Upgrade auf Opus 4.7, und es gibt einen 400-Error ohne Runtime-Deprecation-Warnung — einfach ein harter Fehler. Testen vor dem Deployen.

Das max_tokens-Limit. Thinking-Tokens und Response-Tokens teilen sich denselben max_tokens-Deckel. Setzt du max_tokens: 4000 und das Modell denkt 3.800 Tokens lang, bleiben 200 Tokens für die Antwort. Setz den Wert immer höher, als du glaubst, dass du brauchst.

Was du jetzt tun kannst

Du hast zwei Gänge. Für die Routine-80 % — Extraktion, Formatierung, simples Q&A — nutz effort: "low" oder überspring Thinking komplett. Für die harten 20 % — Code Review, Architekturplanung, komplexe Analyse — nutz "high" oder "xhigh" mit Streaming und Kosten-Monitoring. Mach 100 Calls, schau dir die usage-Zahlen an, dann justiere.

Vor einem Jahr lief jeder Claude-API-Call auf derselben Tiefe — schnell, oberflächlich, ein Gang. Jetzt hast du den Regler in der Hand. Das Modell, das 30 Sekunden lang über einen harten Bug nachdenkt, ist dasselbe Modell, das bei einer Klassifikationsaufgabe komplett aufs Denken verzichtet. Selber Endpunkt, selber Code, drei Zeilen Config Unterschied. Dreh dran.