`.
4. **Einstellungsdatei**: das Feld `model` in `~/.claude/settings.json`.
Grundlegende Befehle:
```bash
# Mit dem führenden Modell starten (derzeit Opus 5.5)
claude --model opus
# Innerhalb einer Sitzung zu Sonnet wechseln
/model sonnet
# Auswahlmenü öffnen (für interaktive Auswahl)
/model
# Zu Opus mit 1M-Kontext wechseln
/model opus[1m]
# Zu einer bestimmten Version wechseln (fest einstellen)
/model claude-opus-5-5
```
Aliase und ihre Entsprechungen in der Anthropic-API (Stand: 23. September 2026):
- `opus` → Opus 5.5 (erfordert Claude Code v2.1.280 oder neuer)
- `sonnet` → Sonnet 5
- `haiku` → Haiku 4.5
- `best` → das leistungsfähigste verfügbare Modell
- `default` → Opus 5.5 bei Pro, Max, Team, Enterprise und der Anthropic-API
- `opusplan` → eine Kombination aus Opus + Sonnet (wird weiter unten separat besprochen)
⚠️ Bei Cloud-Anbietern gelten andere Standards: Bei Amazon Bedrock und Google Cloud verweist der Alias `sonnet` auf Sonnet 4.5; bei Microsoft Foundry wird `opus` weiterhin als Opus 4.6 aufgelöst. Wenn Sie über einen Cloud-Anbieter arbeiten, stellen Sie entweder eine bestimmte Version fest ein (`claude-opus-5-5`) oder setzen Sie die Variable `ANTHROPIC_DEFAULT_OPUS_MODEL`.
Ab Version 2.1.144 gilt die wichtigste Änderung: `/model` schreibt die Auswahl nicht mehr in die Einstellungen. Die Auswahl gilt für die aktuelle Sitzung und geht verloren, wenn die Sitzung geschlossen wird. Um einen Standard dauerhaft zu speichern, drücken Sie im Auswahlmenü bei der markierten Zeile `d`. Dadurch wird das Feld `model` in `~/.claude/settings.json` eingetragen.
Zusammengefasste Sitzungen (`claude --resume`, `--continue`, `/resume`) behalten das in der jeweiligen Sitzung verwendete Modell bei, unabhängig von der aktuellen Einstellung. So wird verhindert, dass eine andere Sitzung das Modell beim Fortsetzen ändert.
Um zu prüfen, welches Modell gerade aktiv ist, verwenden Sie `/status` – dort werden sowohl das Konto als auch das aktuelle Modell angezeigt.
## `/model opusplan`: Planungs- und Ausführungskosten getrennt vergleichen
Das Wichtigste
`opusplan` ist ein hybrider Alias: Im Plan Mode denkt Claude mit Opus über Architektur und Aufgabenanalyse. Sobald Plan Mode endet und die Ausführung beginnt, wechselt es automatisch zu Sonnet. Ersparnisse hängen von Preisen und tatsächlichem Tokenverbrauch beider Phasen ab. Im folgenden historischen Beispiel entsprechen Sonnets 3 $/15 $ für Ein-/Ausgabe 60 % von Opus mit 5 $/25 $. Das reduziert den ersetzten Ausführungsteil um 40 %, nicht die ganze Aufgabe um 75–80 %.
In der hier beschriebenen Praxis wird dieser Modus für Aufgaben verwendet, die mehr als 10 Schritte umfassen.
Die Logik:
- Im Plan Mode (`/plan`) besprechen Sie die Architektur und Optionen und einigen sich auf ein Vorgehen. Opus ist hier teuer, rechtfertigt seinen Preis aber durch sein grundlegend anderes Reasoning.
- Sobald der Plan Mode endet und Claude mit dem Bearbeiten von Dateien, Schreiben von Tests und Ausführen von Befehlen beginnt, ist das die Ausführung. Bei der Ausführung erreicht Sonnet 4.6 dieselbe Qualität wie Opus.
So aktivieren Sie den Modus:
```bash
# Beim Start
claude --model opusplan
# Oder innerhalb einer Sitzung
/model opusplan
```
Eine konkrete Berechnung. Nehmen wir an, ein Refactoring mit 50 Schritten hat eine typische Verteilung:
- Planung (5 Schritte, ~30,000 Input- + 8,000 Output-Tokens): Opus 4.7
- Ausführung (45 Schritte, ~200,000 Input- + 50,000 Output-Tokens): Sonnet 4.6
| Option | Planungskosten | Ausführungskosten | Gesamt |
|----|----|----|----|
| Nur Opus | \$0.15 + \$0.20 = \$0.35 | \$1.00 + \$1.25 = \$2.25 | **\$2.60** |
| Opusplan (Opus + Sonnet) | \$0.15 + \$0.20 = \$0.35 | \$0.60 + \$0.75 = \$1.35 | **\$1.70** |
Die Basis verwendet 230.000 Eingabe- und 58.000 Ausgabetokens für 2,60 $ zu den historischen Opus-Preisen der Tabelle. Opusplan belässt 30.000 Eingabe- und 8.000 Ausgabetokens bei Opus für 0,35 $ und verwendet 200.000 Eingabe- und 50.000 Ausgabetokens bei Sonnet für 1,35 $, insgesamt 1,70 $. Ersparnis: (2,60 $ − 1,70 $) / 2,60 $ = 34,6 %. Bei identischen Tokenmengen und diesen Preisen spart der ersetzte Ausführungsteil 40 %. Selbst bei 90 % Ausführungsanteil an den Basiskosten wären es insgesamt 36 %. Ein anderer Tokenizer braucht ausdrückliche Ein-/Ausgabetokenzahlen je Modell und begründet allein keine 75–80-%-Behauptung.
⚠️ Ein Detail: Opus im Plan Mode von `opusplan` verwendet den Standardkontext von 200K. Das automatische Upgrade auf 1M, das beim Alias `opus` verfügbar ist, gilt NICHT für `opusplan`. Wenn Sie eine große Aufgabe mit Millionen Tokens Kontext planen (zum Beispiel die Analyse eines großen Monorepos), verwenden Sie entweder ausdrücklich `/model opus[1m]` oder wechseln Sie NACH der Planung zu opusplan.
## Der Befehl `/effort`: 5 Stufen adaptiven Reasonings
Das Wichtigste
`/effort` steuert, wie tief das Modell bei jedem Schritt nachdenkt. Die Stufen sind low, medium, high, xhigh (nur Opus 4.7) und max. Ab Version 2.1.117 gelten standardmäßig xhigh für Opus 4.7 und high für die anderen Modelle. low/medium/high/xhigh werden sitzungsübergreifend gespeichert; max gilt nur für die aktuelle Sitzung. Bei low wird Opus fast so schnell und günstig wie Sonnet.
Dies ist der zweitwichtigste Befehl nach `/model`. Effort bedeutet adaptives Reasoning: Bei jedem Schritt entscheidet das Modell anhand der Aufgabenkomplexität, wie tief es nachdenken soll. Je höher die Stufe, desto tiefer das Reasoning und desto mehr Tokens werden verwendet.
Stufen (je nach Aufgabe):
| Stufe | Wann verwenden | Was ändert sich |
|----|----|----|
| **low** | Kurze Aufgaben ohne intellektuelle Anforderungen: Dateien umbenennen, einfache Grep-Suchen, „Was macht diese Funktion?“, Build-Befehl | Das Modell denkt kaum nach und antwortet schnell und günstig |
| **medium** | Arbeit, bei der Tokens sparen wichtiger ist als ein geringer Präzisionsverlust | Senkt den Tokenverbrauch; bei Feinheiten geht manchmal Präzision verloren |
| **high** | Das Minimum für Aufgaben, die echtes Reasoning erfordern: Programmierung, Refactoring, Code-Review | Gleicht Tokenverbrauch und Qualität aus. Standard für Sonnet 4.6 und Opus 4.6 |
| **xhigh** | Beste Ergebnisse bei den meisten Programmier- und Agentenaufgaben | Standard für Opus 4.7. Nur bei Opus 4.7 verfügbar |
| **max** | Sehr anspruchsvolle Aufgaben. Kann die Ergebnisse verbessern, führt aber zu übermäßigem Nachdenken | Kein Token-Limit. Wird am Ende der Sitzung zurückgesetzt |
Drei Modelle werden unterstützt: Opus 4.7, Opus 4.6 und Sonnet 4.6. Bei den anderen ist Effort nicht verfügbar.
Was sich bis September 2026 geändert hat. Die Stufen `low`, `medium`, `high`, `xhigh` und `max` sind bei Opus 5.5, Opus 5, Sonnet 5, Opus 4.8 und Opus 4.7 verfügbar; Opus 4.6 und Sonnet 4.6 haben kein `xhigh`, und eine angeforderte Stufe `xhigh` wird bei diesen Modellen als `high` ausgeführt. Die Standardstufe ist bei allen Modellen mit Effort-Unterstützung `high`, außer bei Opus 5.5 (`medium`) und Opus 4.7 (`xhigh`). Das bedeutet, dass eine tiefgehende Analyse beim aktuellen führenden Modell ausdrücklich angefordert werden muss. Außerdem ist ein separater `ultracode`-Modus hinzugekommen: Es handelt sich um eine Claude-Code-Einstellung, nicht um eine Modellstufe – sie sendet `xhigh` und fordert Claude außerdem auf, für große Aufgaben dynamische Workflows zu erstellen.
So legen Sie die Stufe fest:
```bash
# Interaktiven Regler öffnen
/effort
# Stufe direkt festlegen
/effort high
/effort xhigh
# Auf den Modellstandard zurücksetzen
auto
# Über ein Start-Flag
claude --effort high
# Über eine Umgebungsvariable (gilt ab dem Start)
export CLAUDE_CODE_EFFORT_LEVEL=high
# In den Einstellungen (max funktioniert nicht – max gilt nur für die Sitzung)
{
"effortLevel": "high"
}
# In Frontmatter von Skill / Subagent
---
name: my-skill
effort: low
---
```
Die Stufe wird in Claude Code neben dem Logo und dem Spinner angezeigt, zum Beispiel „mit low effort“. Sie müssen `/model` also nicht öffnen, um sie zu prüfen.
Der Effort-Regler erscheint auch im Auswahlmenü von `/model` – verwenden Sie die Pfeiltasten links/rechts, um die Stufe festzulegen.
Ein wichtiges Detail. Wenn Sie von einem anderen Modell zu Opus 4.7 wechseln, wird Effort zwingend auf xhigh gesetzt – auch wenn bei Opus 4.6 oder Sonnet 4.6 zuvor high eingestellt war. Um die gewünschte Stufe wiederherzustellen, führen Sie `/effort` erneut aus.
Noch eine Technik: **ultrathink** im Prompt. Wenn Sie das Wort `ultrathink` in den Prompt-Text aufnehmen, verwendet Claude in diesem einen Durchgang ein tieferes Reasoning, ohne den Effort der Sitzung zu ändern. Ähnliche Formulierungen („think“, „think hard“, „think more“) lösen dieses Verhalten nicht aus – sie werden einfach als gewöhnlicher Text übergeben.
## Der Befehl `/fast`: Opus ist 2.5-mal schneller zum 6-fachen Preis – wann lohnt es sich?
Das Wichtigste
`/fast` ist eine alternative API-Konfiguration für die führenden Opus-Modelle. Es ist kein anderes Modell – es ist dasselbe Opus, aber bei der Ausgabe bis zu 2.5-mal schneller. Stand: 23. September 2026, wird es bei Opus 5.5, Opus 5 und Opus 4.8 unterstützt; es kostet bei Opus 5.5 \$8 / \$40 pro Million Tokens und bei Opus 5 und Opus 4.8 \$10 / \$50. Bei Sonnet und Haiku ist es nicht verfügbar und wurde am 24. Juli 2026 bei Opus 4.7 entfernt. Es eignet sich für Live-Debugging und interaktive Arbeit, bei denen die Latenz wichtiger als die Kosten ist.
Der Fast-Modus ist eine Funktion in der Research Preview. Er erfordert Claude Code v2.1.36+; die Version lässt sich mit `claude --version` prüfen.
So aktivieren Sie ihn:
```bash
# Fast-Modus umschalten (verfügbar in der Claude-Code-CLI und der VS-Code-Extension)
/fast
# Oder in den Einstellungen
{
"fastMode": true
}
```
Nach der Aktivierung:
- Wenn Sie ein anderes Modell verwenden, wechselt Claude Code automatisch zu Opus.
- Es erscheint die Bestätigung „Fast mode ON“.
- Neben dem Prompt erscheint das Symbol `↯`.
Optionen und Details:
- Das Standardmodell im Fast-Modus ist das leistungsfähigste verfügbare Opus. Stand: 23. September 2026, ist das Opus 5.5; bei Opus 4.7 funktioniert der Fast-Modus überhaupt nicht, und ein Wechsel dorthin schaltet ihn aus.
- Der Fast-Modus bleibt standardmäßig sitzungsübergreifend aktiviert. Team-/Enterprise-Administratoren können mit `fastModePerSessionOptIn: true` festlegen, dass er für jede Sitzung ausdrücklich aktiviert werden muss.
- Wenn Sie den Fast-Modus durch erneutes Ausführen von `/fast` ausschalten, bleiben Sie bei Opus – das Modell wechselt nicht zum vorherigen zurück. Verwenden Sie `/model`, um zu wechseln.
- Wird der Modus mitten im Gespräch aktiviert, gilt der Fast-Modus-Preis für den gesamten Gesprächskontext. Daher ist es günstiger, ihn gleich zu Sitzungsbeginn statt erst nach der Hälfte zu aktivieren.
Wann Sie den Fast-Modus verwenden sollten:
- **Live-Debugging**: Sie beobachten einen Trace, und die Antwortzeit ist entscheidend.
- **Enge Deadline bei interaktiver Arbeit**: Sie erstellen bis 18:00 eine Demo und benötigen schnelle Iterationen.
- **Schnelle Code-Iterationen**: Sie testen Hypothesen nacheinander.
Wann Sie ihn nicht verwenden sollten:
- **Lange autonome Aufgaben**, bei denen Geschwindigkeit nicht entscheidend ist. Sie zahlen das 6-Fache für die 2.5-fache Geschwindigkeit – es lohnt sich nicht, wenn Sie während der Arbeit von Claude zum Mittagessen gehen.
- **Batch-Verarbeitung, CI/CD-Pipelines** – überhaupt nicht für den interaktiven Modus gedacht.
- **Kostensensitive Workloads** – die Wahl ist offensichtlich.
Verfügbarkeit:
- Funktioniert NICHT mit Bedrock, Vertex oder Foundry.
- Erfordert **Nutzungsguthaben** im Konto (Abrechnung über das im Plan enthaltene Limit hinaus). Bei Einzelkonten wird die Funktion in den Console-Abrechnungseinstellungen aktiviert. Bei Team/Enterprise muss sie ein Administrator aktivieren.
- Tokens im Fast-Modus werden NICHT vom im Plan enthaltenen Limit abgezogen. Sie werden ab dem ersten Token direkt über Nutzungsguthaben zu den Preisen des Fast-Modus abgerechnet.
Wenn Sie das Anfragelimit des Fast-Modus erreichen oder Ihnen die Nutzungsguthaben ausgehen, wechselt der Fast-Modus automatisch zu Standardgeschwindigkeit und Standardpreisen, das Symbol `↯` wird grau und die Arbeit wird fortgesetzt. Sobald das Limit zurückgesetzt wird, schaltet sich der Fast-Modus wieder ein.
Fast-Modus und Effort sind keine konkurrierenden Einstellungen. Sie können sie kombinieren: Fast-Modus + low effort = maximale Geschwindigkeit bei einfachen Aufgaben.
## Was jedes Modell tatsächlich kostet: Aufschlüsselung der Monatsrechnung
Das Wichtigste
Grundpreise pro Million Tokens: Haiku 4.5 – \$1 / \$5, Sonnet 4.6 – \$3 / \$15, Opus 4.7 – \$5 / \$25. Fast-Modus – \$30 / \$150. Prompt-Caching senkt die Kosten wiederholter Eingaben auf 0.1x. Die Batch-API gewährt 50 % Rabatt. Die wichtigste Einsparung ergibt sich nicht durch das Modell selbst, sondern dadurch, Opus zu vermeiden, wenn Sonnet die Aufgabe erledigt.
Preise pro Million Tokens (Anthropic-API, USD):
| Modell | Input | 5-Minuten-Cache-Schreiben | 1-Stunden-Cache-Schreiben | Cache-Treffer | Output |
|------------------|-------|-------------------|-----------------|-----------|--------|
| Haiku 4.5 | \$1 | \$1.25 | \$2 | \$0.10 | \$5 |
| Sonnet 4.6 | \$3 | \$3.75 | \$6 | \$0.30 | \$15 |
| Opus 4.6 | \$5 | \$6.25 | \$10 | \$0.50 | \$25 |
| Opus 4.7 | \$5 | \$6.25 | \$10 | \$0.50 | \$25 |
| Fast-Modus (Opus) | \$30 | n/a | n/a | n/a | \$150 |
Was die Rechnung tatsächlich senkt:
1. **Prompt-Caching.** Anthropic cached wiederholte Prompt-Abschnitte: den System-Prompt, CLAUDE.md und Tool-Beschreibungen. Ein Cache-Treffer kostet 10 % des Input-Preises. Bei Sonnet werden so aus \$3 pro Million Tokens \$0.30 – zehnmal günstiger. Die Funktion wird über `cache_control: { type: "ephemeral" }` in der API-Anfrage automatisch aktiviert. In Claude Code funktioniert sie standardmäßig.
2. **Batch-API**: 50 % Rabatt auf Input und Output bei Aufgaben, auf deren Erledigung Sie warten können (Berichte, umfangreiche Textgenerierung in Batches). Sonnet über die Batch-API = \$1.50 / \$7.50. Die Funktion ist in Claude Code nicht direkt verfügbar, aber wenn Sie Automatisierungen mit dem Anthropic-SDK erstellen, sollten Sie sie verwenden.
3. **opusplan statt reinem Opus**: rund 34,6 % im durchgerechneten historischen Beispiel. Tatsächliche Gesamtkosten hängen von Ausführungsanteil, Tokenzahlen, Preisen, Caching und Wiederholungen ab.
4. **Sonnet als Standard + Opus bei Bedarf**: die wichtigste Einsparung. Wenn Opus „nur für den Fall“ aktiviert ist, wechselt die hier beschriebene Praxis zu Sonnet. Wenn die Aufgabe Opus erfordert, wird das spätestens beim dritten oder vierten Schritt deutlich, und ich wechsle ausdrücklich mit `/model opus`.
5. **Den neuen Tokenizer von Opus 4.7 berücksichtigen.** Bei derselben Datei verwendet Opus 4.7 bis zu 35 % mehr Tokens als Sonnet 4.6. Die tatsächlichen Kosten für dieselbe Aufgabe steigen stärker, als die Tabelle vermuten lässt.
Ein konkretes Beispiel: eine typische Aufgabe für eine Immobilienagentur, die einen Website-Prototyp für einen neuen Kunden erstellt: „Erstelle eine Seite mit drei Abschnitten, einem Formular und einer Integration mit einem Zahlungsgateway.“ Die Ergebnisse:
- Nur Opus 4.7 (high effort): ~\$4.80 pro Sitzung (1.5 Stunden Arbeit).
- opusplan: ~\$1.90 (Opus plant, Sonnet führt aus).
- Nur Sonnet 4.6 (high effort): ~\$1.30, aber die Architekturentscheidung war schlechter (Sonnet wählte einen vorlagenbasierten Ansatz, während Opus in opusplan einen eigenen Ansatz für die nicht-standardmäßigen Anforderungen entwickelte).
Für diese Aufgabe ist opusplan der Sieger. Die Einsparung beträgt 60 %, bei Opus-Qualität für den entscheidenden Teil.
Claude Code zeigt die Tokenanzahl für Limits nicht direkt an – sie ist dynamisch und hängt vom Plan ab. Unter `/status` sehen Sie jedoch Ihren Plan und die aktuelle Nutzung. Eine ausführlichere Anleitung finden Sie hier: [So vermeiden Sie, dass die Claude-Code-Limits an einem Tag aufgebraucht sind](https://ailoot.ai/blog/de/claude-code-token-limits-saving/).
## Welchen täglichen Workflow sollten Sie einrichten? 4 fertige Voreinstellungen
Das Wichtigste
Vier fertige Voreinstellungen für unterschiedliche Aufgabentypen. Tägliche Programmierung – Sonnet + high effort. Umfangreiches Refactoring – opusplan. Schnelle Korrektur – Haiku + low effort. Architektur-Session – Opus 4.7 + xhigh effort + Plan Mode. Sie können jede Voreinstellung als Alias speichern, an einen Skill anhängen oder als ersten Befehl beim Start einer Sitzung griffbereit halten.
Diese vier Voreinstellungen lassen sich je nach Arbeitstag und Aufgabe wechseln.
**Voreinstellung 1. Tägliche Programmierung – 80 % der Arbeitszeit in der hier beschriebenen Praxis.**
```bash
claude --model sonnet --effort high
# Bei Bedarf innerhalb der Sitzung zu Opus wechseln
/model opus
```
Wofür: neue Funktionen, kleine Refactorings, einfache Fehler beheben, Dokumentation. Sonnet mit high effort ist der optimale Mittelweg.
**Voreinstellung 2. Umfangreiches Refactoring – eine größere Architekturänderung.**
```bash
claude --model opusplan
# Zuerst mit /plan die Struktur besprechen
# Nach dem Verlassen des Plan Mode führt Sonnet die Arbeit aus
```
Wofür: ein Modul über mehr als 15 Dateien hinweg neu schreiben, eine Integration von einem Gateway auf ein anderes umstellen. Opus kümmert sich um die Architektur (Abhängigkeiten durchdenken), Sonnet um die Ausführung (Dateien schnell bearbeiten). Bei diesen Aufgaben lassen sich 70 % und mehr sparen.
**Voreinstellung 3. Schnelle Korrektur – einzeilige Änderungen und Skripte.**
```bash
claude --model haiku --effort low
```
Wofür: „Ändere den Namen einer Variablen in allen Dateien“, „Schreibe ein Bash-Skript, das nginx neu startet“, „Was macht diese Funktion?“ Haiku erledigt diese Aufgaben und kostet dreimal weniger als Sonnet.
**Voreinstellung 4. Architektur-Session – eine strategische Entscheidung.**
```bash
claude --model opus --effort xhigh
# Bei Wechsel in den Plan Mode die höchste Effort-Stufe verwenden:
/plan
# Bei kritischen Fragen das Wort ultrathink zum Prompt hinzufügen
```
Wofür: „Soll X ein separater Dienst sein?“, „Welche Tools sollten wir für den Prototyp verwenden?“, „Wie sollten wir ein Datenbankschema für die mandantenfähige Nutzung organisieren?“ Hier ist Opus 4.7 teuer – und es lohnt sich, denn ein Fehler an dieser Stelle kostet Wochen Arbeit.
Diese Voreinstellungen können als Skills (ein Modell pro Skill) oder als Aliase in `~/.zshrc` gespeichert werden:
```bash
alias claude-daily='claude --model sonnet --effort high'
alias claude-refactor='claude --model opusplan'
alias claude-quick='claude --model haiku --effort low'
alias claude-architect='claude --model opus --effort xhigh'
```
Wenn Sie im Team arbeiten, können Sie die Auswahl über verwaltete Einstellungen standardisieren. Ein Administrator legt in der Organisationsrichtlinie `availableModels: ["sonnet", "haiku", "opusplan"]` fest, und Nutzer können Opus nicht direkt auswählen, sondern nur nach ausdrücklicher Freigabe. Das ist ein guter Schutz davor, versehentlich das Limit aufzubrauchen.
Wer [Subagenten](https://ailoot.ai/blog/de/claude-code-subagents/) erstellt, kann über `CLAUDE_CODE_SUBAGENT_MODEL` oder das Feld `model` im Frontmatter der Agentendefinition auch für verschiedene Subagenten unterschiedliche Modelle festlegen. Das bietet eine weitere Möglichkeit zur Optimierung.
## Was tun, wenn die Kapazität aufgebraucht ist: 5 praktische Techniken
Das Wichtigste
Wenn Sie das Opus-Limit erreichen, geraten Sie nicht in Panik. Fünf Möglichkeiten weiterzuarbeiten: zu Sonnet wechseln, opusplan verwenden, Prompt-Caching aktivieren, einen Teil der Arbeit auf die Batch-API verlagern oder Haiku für Nebenaufgaben verwenden. Die Limits wurden im Mai 2026 verdoppelt und die Drosselung während der Spitzenzeiten wurde aufgehoben. Dadurch lässt sich die Opus-Kapazität schwerer aufbrauchen.
Wenn `/status` anzeigt, dass Sie das Opus-Limit erreicht haben:
1. **Zu Sonnet 4.6 wechseln**: `/model sonnet`. Es hat einen eigenen Pool, und bei 80 % der Aufgaben werden Sie keinen Unterschied bemerken. Bei der Anthropic-API kann Claude Code sogar automatisch zu Sonnet wechseln, wenn Sie sich dem Opus-Limit nähern.
2. **Für die anstehende Arbeit opusplan verwenden**: `/model opusplan`. Wenn Sie für den Tag noch Aufgaben im Plan Mode haben, verwenden diese Opus nur minimal (nur für die Planung); die Ausführung erfolgt vollständig mit Sonnet.
3. **Prompt-Caching prüfen**: Vergewissern Sie sich, dass es nicht mit `DISABLE_PROMPT_CACHING=1` deaktiviert wurde. Wenn Ihre CLAUDE.md oder Ihr System-Prompt ein Megabyte an Einstellungen enthält, sollte dieser Inhalt gecacht werden. Bei 90 % Lesezugriffen senkt das den Verbrauch um das Zehnfache.
4. **Batch-Aufgaben verlagern**: Wenn Sie umfangreiche Generierungen durchführen (Berichte, Texte, Übersetzungen), verlagern Sie diese in ein Skript mit der Batch-API – 50 % Rabatt auf Input und Output. Die Funktion ist in Claude Code nicht direkt verfügbar, lässt sich aber in 30 Minuten mit einem `tsx`-Skript + Anthropic-SDK einrichten.
5. **Haiku für Nebenaufgaben verwenden**: Bei Routineaufgaben wie „Schreibe eine Commit-Nachricht“ oder „Erkläre, was diese Datei macht“ wechseln Sie Claude Code zu Haiku. Es verbraucht dreimal weniger als Sonnet und fünfmal weniger als Opus.
Und die wichtigste Erinnerung: **Seit dem 6. Mai 2026 wurden die Limits für Pro, Max, Team und Enterprise verdoppelt**, und die Drosselung während der Spitzenzeiten wurde aufgehoben. Wenn Opus Ihre Kapazität in einem halben Tag aufbraucht, liegt das Problem nicht an den Limits – Opus wird dort eingesetzt, wo Sonnet die Aufgabe erledigen würde. Die Entscheidungshilfe im zweiten Abschnitt dieses Leitfadens gibt Ihnen die Kontrolle zurück.
Ausführliche Informationen zu Limits und acht praktischen Regeln zum Tokensparen finden Sie in diesem Grundlagenartikel: [So vermeiden Sie, dass die Claude-Code-Limits an einem Tag aufgebraucht sind: 8 Regeln zum Tokensparen in 2026](https://ailoot.ai/blog/de/claude-code-token-limits-saving/). Eine weitere hilfreiche Ergänzung ist [Plan Mode in Claude Code: eine Schritt-für-Schritt-Anleitung](https://ailoot.ai/blog/de/claude-code-plan-mode/), denn opusplan funktioniert nicht ohne Plan Mode. Und die Grundlage für jedes Modell ist [So konfigurieren Sie CLAUDE.md in 2026](https://ailoot.ai/blog/de/claude-md-template/).
### Quellen
- [Anthropic – Ankündigung von Claude Opus 5.5 (22. September 2026)](https://www.anthropic.com/news/claude-opus-5-5)
- [Anthropic API: Modellübersicht, Preise und Effort-Stufen](https://platform.claude.com/docs/en/about-claude/models/overview)
- [Anthropic Claude Code: Modellkonfiguration](https://code.claude.com/docs/en/model-config)
- [Anthropic Claude Code: Antworten mit dem Fast-Modus beschleunigen](https://code.claude.com/docs/en/fast-mode)
- [Anthropic Claude Code: Neuigkeiten](https://code.claude.com/docs/en/whats-new)
- [Anthropic API: Preise](https://platform.claude.com/docs/en/about-claude/pricing)
- [Anthropic API: Effort-Stufen](https://platform.claude.com/docs/en/build-with-claude/effort)
- [Anthropic API: Kontextfenster mit 1M Tokens](https://platform.claude.com/docs/en/build-with-claude/context-windows)
- [Anthropic Support: Modelle, Nutzung und Limits in Claude Code](https://support.claude.com/en/articles/14552983-models-usage-and-limits-in-claude-code)
- [Anthropic Blog: Neuigkeiten zu Claude Managed Agents (Code with Claude 2026)](https://claude.com/blog/new-in-claude-managed-agents)
Praktische Materialien: [Ailoot-Dokumentation](https://ailoot.ai/docs/).
Weitere Materialien und Tools: [Ailoot](https://ailoot.ai/).
## Fragen und Antworten
### Wie viel spart das durchgerechnete opusplan-Beispiel?
Zu historischen Preisen und Tokenmengen der Tabelle kostet reines Opus 2,60 $ und opusplan 1,70 $. Die Ersparnis beträgt 0,90 $ / 2,60 $, rund 34,6 %. Das belegt keine allgemeine Ersparnis von 75–80 %.
### Garantiert ein günstigeres Ausführungsmodell günstigere erfolgreich abgeschlossene Aufgaben?
Nein. Nutze tatsächliche Eingabe-, Ausgabe-, Cache- und Wiederholungszahlen zu den geltenden Preisen und dieselben Erfolgskriterien. Ein niedrigerer Tokenpreis ist nur ein Teil der Endkosten.
## Ailoot · Das Unternehmen und sein Projektportfolio
Ailoot baut auf bewährte Betriebserfahrung, einen großen Kundenstamm, stabilen Service und kontinuierliche KPI-Kontrolle.
Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.
Ailoot nutzt diese Betriebserfahrung für den API-Zugang zu KI-Funktionen in Kundenprodukten, Agenten, Anwendungen und Automatisierungen.