So nutzen Sie Claude Fable 5, ohne pleitezugehen

Fable 5 ist das beste KI-Modell, das ich je benutzt habe.

Es ist aber auch wahnsinnig teuer.

In den ersten Stunden des Testens habe ich fast mein gesamtes Nutzungslimit aufgebraucht.

Und ich habe nicht einmal etwas Verrücktes gemacht.

Fable kostet doppelt so viel wie Opus 4.8.

Und weil es so intelligent ist, denkt es tatsächlich zu viel nach – es führt Schleifen aus und verbrennt Tokens auf eine Weise, wie es kein früheres Claude-Modell getan hat.

Die meisten Leute nutzen es völlig falsch.

Hier ist das genaue System, das ich entwickelt habe, um meine Fable-Token-Kosten um über 50 % zu senken.

Keine neuen Tools. Nicht weniger Output. Nur intelligentere Weiterleitung.

Der Fehler, den am ersten Tag jeder macht

Du öffnest Claude Code.

Fable ist jetzt das Standardmodell.

Du beginnst zu chatten.

Du bittest es, einen Tippfehler zu korrigieren. Du bittest es, etwas JSON zu formatieren. Du bittest es, eine Variable umzubenennen.

Fable denkt 12 Sekunden lang nach, verbrennt 8.000 Tokens für das Nachdenken und gibt die Antwort zurück.

Kosten: 0,60 $ für eine Aufgabe, die Haiku für 0,02 $ erledigt hätte.

Du zahlst Chirurgen-Tarife für Smalltalk.

Fable ist ein Architekt.

Kein Mitbewohner.

In dem Moment, in dem du das verinnerlichst, ändert sich alles.

Das 10-80-10-System (Das genaue Framework, das Anthropic-Ingenieure selbst verwenden)

Jedes Fable-Projekt hat drei Phasen.

Die meisten Leute lassen alle drei Phasen mit Fable laufen.

Der kluge Schachzug ist, nur zwei davon mit Fable laufen zu lassen.

Die ersten 10 % – Planung

Hier verdient Fable seinen Preis.

Bevor ein Projekt startet, verwende Fable, um Folgendes zu definieren:

→ Die Struktur und der Ansatz → Erfolgskriterien → Einschränkungen und Grenzfälle → Was schiefgehen könnte

Stell dir vor, du baust ein Haus.

Der teuerste Fehler ist es, den Bauarbeitern einen schlechten Bauplan zu geben.

Hol zuerst die Architektur richtig hin.

Fable ist darin außergewöhnlich gut.

Die mittleren 80 % – Ausführung

Hier werden die meisten Tokens verbrannt.

Das Hin und Her. Die Iteration. Die Implementierungsschleifen. Die Knochenarbeit des tatsächlichen Erledigens von Aufgaben.

Fable muss hier nicht sein.

Wechsle für Standardarbeit zu Opus 4.8. Verwende Haiku für leichte Aufgaben. Verwende Codex oder GPT-5.5 für mechanische Ausführung.

Du bekommst Fable-Qualitätsarchitektur, ohne Fable-Preise für jeden Ausführungs-Token zu bezahlen.

Die letzten 10 % – Überprüfung

Hol Fable wieder herein.

Lass es den Output mit dem ursprünglichen Plan abgleichen:

→ Entspricht das Ergebnis der Architektur?

→ Gibt es Lücken oder übersehene Grenzfälle?

→ Muss etwas repariert werden, bevor es ausgeliefert wird?

Da Fable ein fertiges Ergebnis überprüft, anstatt es von Grund auf neu zu generieren, verbraucht es einen Bruchteil der Tokens, die es für die gesamte Aufgabe verbrannt hätte.

[BILD 2 EINFÜGEN – PROMPT UNTEN]

Die CLAUDE.md-Routing-Tabelle (Eine Datei, die alles steuert)

Das ist der größte Durchbruch.

Behalte eine einzige Routing-Tabelle in deiner CLAUDE.md.

Lass Fable als Orchestrator fungieren, der sie liest und die Arbeit automatisch an das richtige Modell delegiert.

Hier ist die genaue Routing-Tabelle, die ich verwende:

1## Model Routing Table
2
3### Fable 5 (nur Orchestrator)
4Verwendung für: Planung, Architektur, Überprüfung des endgültigen Outputs
5Nie verwenden für: mechanische Aufgaben, Massengenerierung, Boilerplate
6Aufwandsstufe: hoch (niemals xhoch – es ist ein Token-Ofen mit schlechterem Output)
7
8### Opus 4.8 (tiefgründiger Reasoning-Ausführer)
9Verwendung für: komplexes Debugging, mehrstufiges Reasoning, alles,
10         was echtes Denken erfordert, aber keine Architektur ist
11Kostenstufe: Standard
12
13### Sonnet 5 (mechanischer Arbeitsausführer)
14Verwendung für: Code-Generierung, Refactoring, Standard-Feature-Arbeit
15Kostenstufe: Günstig
16
17### Codex / GPT-5.5 (Peer-Ausführer)
18Verwendung für: Implementierungsaufgaben, UI/UX-Verifizierung,
19         gut spezifizierte Ausführungsarbeit
20Hinweis: Fable kann lernen, Codex zu steuern – bringe es einmal bei, wie
21Kostenstufe: oft kostenlos im Codex-Plan
22
23### Haiku (Massenausführer)
24Verwendung für: Formatierung, Lint, einfache Bearbeitungen, Boilerplate,
25         Umbenennungs-Refactorings, Test-Gerüste
26Erzeuge niemals weitere Unter-Agenten von Haiku aus
27Kostenstufe: Günstigste
28
29### Kimi / GLM-5.2 (Langkontext-Ausführer)
30Verwendung für: Lesen riesiger Dateien, langfristige Repo-Analyse,
31         damit Fable niemals Tokens dafür ausgibt
32Kostenstufe: Sehr günstig
33
34### DeepSeek / Qwen (spottbillige Routinearbeit)
35Verwendung für: Boilerplate, Tests schreiben, Datenbereinigung,
36         Übersetzungen, erste Dokumentenentwürfe, Massengenerierung
37Kostenstufe: Nahezu kostenlos

Fable berührt die billige Arbeit nie direkt.

Es plant, delegiert an die richtige Stufe und überprüft dann die Ergebnisse mit dem Plan.

Das teure Gehirn gibt nur Tokens für die Entscheidungsfindung aus.

Diese eine Datei ist der Grund, warum meine Rechnung GESUNKEN ist, während mein Output GESTIEGEN ist.

Das genaue CLAUDE.md-Setup, das 70 % meiner Tokens gespart hat

Hier ist der vollständige Orchestrierungsabschnitt, den ich in meine CLAUDE.md eingefügt habe:

1## Orchestration Workflow
2
3Du (Fable) bist der Orchestrator. Plane, zerlege, synthetisiere.
4Führe mechanische Aufgaben NICHT selbst aus.
5
6### Delegationsregeln:
7- Reasoning-intensive Phasen → deep-reasoner (Opus 4.8)
8- Mechanische Arbeit → fast-worker (Sonnet/Haiku)
9- Codebase-Analyse / riesige Dateien → Kimi (langer Kontext)
10- Boilerplate / Massenarbeit → DeepSeek oder Qwen
11- Peer-Review aus einer anderen Perspektive → Codex
12
13### Codex ist ein Peer, kein Reviewer:
14Behandle Codex wie einen abgefahrenen Sr. Engineer aus einer anderen
15Perspektive. Bei wichtigen Entscheidungen: Beauftrage Opus + Codex
16parallel mit demselben Problem, synthetisiere das Beste aus
17beiden, ohne einem die Antwort des anderen zu zeigen.
18
19### Kontext-Disziplin:
20Halte deinen eigenen Kontext schlank.
21Lies niemals Dateien erneut, die du bereits verarbeitet hast.
22Fasse Tool-Outputs zusammen, bevor du sie wieder in den Kontext einspeist.
23Bitte Modelle, präzise Schlussfolgerungen zurückzugeben, mit denen du arbeiten kannst.
24
25### Aufwandsstufen:
26- Planung und Architektur: hoher Aufwand
27- Überprüfungsdurchläufe: mittlerer Aufwand
28- Verwende niemals standardmäßig xhoch/max – kostet mehr, oft schlechter

Jetzt prompte Fable wie ein Tech-Lead:

1Ziel: [was du willst]
2Kontext: [Dateien, Einschränkungen, wovor du Angst hast]
3
4Du bist der Lead.
5Delegiere Reasoning an deep-reasoner (Opus).
6Delegiere Routinearbeit an fast-worker (Sonnet/Haiku).
7Verwende Codex für Probleme mit frischer Perspektive.
8
9Zeig mir zuerst deinen Plan, dann führe aus.

Das ist es.

Fable plant. Alles andere führt aus. Die Rechnung bleibt stabil.

Das Codex-Plugin installieren – der Multiplikator-Zug

Das ist das Setup, das die meisten Leute überspringen.

Codex + Fable zusammen ist 10x besser als Fable allein.

Fable macht die Architektur. Codex führt mit GPT-5.5-Qualität aus. Du berührst deine Claude-Limits kaum.

Einrichtung in unter 5 Minuten:

Schritt 1: Installiere die Codex-CLI auf deinem Rechner

1npm install -g @openai/codex

Schritt 2: Füge das Plugin in Claude Code hinzu

1/plugin marketplace add openai/codex-plugin-cc
2/plugin install codex@openai-codex
3/codex:setup

Schritt 3: Erstelle zwei Unter-Agenten in Claude Code

1/agents
2
3→ deep-reasoner
4  Modell: Opus 4.8
5  Anweisungen: "Verwende für reasoning-intensive Phasen, Architektur,
6  komplexes Debugging. Denke gründlich nach, gib eine präzise
7  Schlussfolgerung zurück, mit der der Orchestrator arbeiten kann."
8
9→ fast-worker
10  Modell: Sonnet 5
11  Anweisungen: "Verwende für mechanische Aufgaben, Boilerplate, Tests,
12  Formatierung, einfache Bearbeitungen. Führe effizient aus."

Schritt 4: Bitte Fable, eine SKILL.md für Codex zu schreiben

1Schreibe eine SKILL.md, die Codex genau beibringt, wie man:
2- Implementierungspläne liest und ausführt
3- Tests ausführt und Ergebnisse an dich zurückmeldet
4- Die spezifische Dateistruktur in diesem Projekt handhabt

Sorge dafür, dass Codex bei mechanischer Arbeit keine Anleitung mehr braucht.

Fable schreibt die Fähigkeit einmal.

Codex liest sie bei jedem zukünftigen Durchlauf.

Dein Codex-Output wird sofort 10x besser.

Der /loop-Befehl (Der derzeit leistungsstärkste Weg, Fable zu nutzen)

Die meisten Leute prompten immer noch auf die alte Art.

Du promptest → Fable antwortet → du überprüfst → du promptest erneut → wiederhole.

In diesem Modell bist du die Schleife.

Du überprüfst manuell jeden Schritt, jede Korrektur, jedes Follow-up.

Loops entfernen dich als Engpass.

Wie es funktioniert:

Du gibst Fable ein Ziel vor.

Es startet Unter-Agenten, die auf dieses Ziel hinarbeiten.

Die Agenten prompten sich selbst und melden sich zurück, wenn sie fertig sind.

Die zwei Befehle:

1/goal — definiere die Aufgabe und den Endzustand
2
3Struktur:
4/goal [Aufgabe] bis [messbarer Endzustand] ohne [Einschränkungen]
5
6Beispiel:
7/goal refaktoriere das Auth-Modul, bis alle 47 Tests bestanden sind
8ohne den Payment-Service oder das Datenbankschema zu berühren

1/loop — führe einen Prompt automatisch nach einem Zeitplan aus
2
3Struktur:
4/loop [dein Prompt] --intervall 30m --läuft ab 8h
5
6Beispiel:
7/loop führe Sicherheitscheck auf allen API-Endpunkten aus
8--intervall 24h --läuft ab 7d

Die Kombination:

1/goal baue die Dashboard-Komponente neu, bis der Lighthouse
2-Score auf Mobilgeräten 90 übersteigt, ohne bestehende Tests zu brechen
3
4/loop führe /goal oben aus --intervall 6h --läuft ab 48h

Fable entwirft die Schleife. Günstigere Modelle führen die 80 % Ausführung innerhalb der Schleife aus. Fable kommt nur wieder herein, wenn die Schleife geschlossen wird oder auf einen Blocker stößt.

Du wachst mit einer erledigten Aufgabe auf.

[BILD 5 EINFÜGEN – PROMPT UNTEN]

7 Prompts, die du jetzt sofort in Fable ausführen solltest

Das sind die Dinge mit der höchsten Hebelwirkung, die du mit Fable tun solltest, bevor du es für irgendetwas anderes verwendest.

Kein Vibe-Coding.

Keine Features ausliefern.

Jedes System schärfen, das du bereits hast.

1. Finde heraus, was es wirklich wert ist, mit Fable ausgeführt zu werden

1Du bist Fable 5, das leistungsfähigste verfügbare Modell.
2
3Sieh dir meine Projekte, Dokumente und meinen Speicher an.
4
5Liste die 5 wichtigsten Aufgaben auf, die es wirklich wert sind, mit dir ausgeführt zu werden.
6
7Reihe sie mit einem einzeiligen Grund für jede ein.
8
9Mach die Arbeit noch nicht.

2. Gestalte neu, wie du baust, bevor du etwas baust

1Ich möchte, dass du meinen Codierungs-Workflow vollständig überprüfst und neu gestaltest.
2
3So arbeite ich derzeit: [beschreibe deinen Prozess]
4
5Mein Ziel ist: [was du ausliefern möchtest]
6
7Überprüfe, auditiere, schärfe und verbessere mein System.
8
9Schreibe keinen Code. Gestalte die Fabrik neu, bevor wir sie laufen lassen.

3. Plane das große Projekt – baue es noch nicht

1Ich möchte planen: [beschreibe das Projekt]
2
3Baue noch nicht.
4
5Lege den vollständigen Plan dar: Phasen, wichtige Entscheidungen, Risiken
6und offene Fragen.
7
8Markiere alles, was es zum Scheitern bringen könnte.
9
10Mache den Plan klar genug, dass Sonnet oder Codex ihn
11Schritt für Schritt ausführen könnten, ohne mich Fragen zu stellen.

4. Finde alles Falsche, bevor du auslieferst

1Ich bin kurz davor, dieses Projekt auszuliefern.
2
3Finde zuerst alles Falsche daran.
4
5Lies die gesamte Codebase.
6
7Suche nach echten Bugs, kaputten Grenzfällen und allem, was
8vor einem Benutzer kaputtgehen wird.
9
10Liste jedes Problem auf mit: wie man es reproduziert und dem Fix.
11
12Halte eine hohe Messlatte. Sei gnadenlos.

5. Baue deine CLAUDE.md von Grund auf neu

1Lies meine aktuelle CLAUDE.md.
2
3Sie wurde für ältere Modelle geschrieben und ist aufgebläht.
4
5Kürzere, sauberere Anweisungen liefern bessere Ergebnisse und kosten weniger
6in Fable.
7
8Schreibe sie neu:
9- Entferne Anweisungen, die Fable nicht mehr braucht
10- Straffe jeden Workflow
11- Füge die Modell-Routing-Tabelle aus unserem Gespräch hinzu
12- Halte jeden Abschnitt wo möglich unter 5 Zeilen
13
14Fable wird den Rest von selbst herausfinden.

6. Hol dir Geschäftsberatung aus allem, was es über dich weiß

1Du bist mein Geschäftsberater.
2
3Lies mein Planungsdokument, die verbundenen Tools und den Speicher.
4
5Schreibe eine einseitige Bewertung meines Geschäfts und:
6- Die 3 wichtigsten Dinge, auf die ich mich in den nächsten 3 Monaten konzentrieren sollte
7- Was ich fallen lassen sollte und warum
8- Eine Sache, die ich wahrscheinlich übersehe

7. Sicherheitsüberprüfung im Autopilot-Modus

1/loop führe einen Sicherheitscheck auf allen meinen API-Endpunkten aus.
2
3Suche nach: offengelegten Schlüsseln, fehlender Authentifizierung, Rate-Limit-Lücken,
4Injektionsvektoren und allem, was ein böswilliger Benutzer ausnutzen könnte.
5
6Melde nur echte Probleme mit Schweregradbewertungen.
7
8--intervall 24h --läuft ab 7d

Aufwandsstufen – die am meisten missverstandene Einstellung

Die meisten Leute verwenden standardmäßig max oder xhoch.

Das ist falsch.

Hier ist, was tatsächlich auf jeder Stufe passiert:

→ Niedrig: Schnell, günstig, überraschend leistungsfähig für einfache Aufgaben. Viele Leute berichten von erstaunlichen Ergebnissen hier.

→ Mittel: Der Sweet Spot. Fable auf mittel schlägt Opus auf extra hoch. Standardmäßig hier verwenden.

→ Hoch: Verwende für: schwieriges Debugging, dateiübergreifende Refactorings, Architekturentscheidungen. Echte Reasoning-Leistung.

→ Xhoch / Max: Token-Ofen. Produziert oft SCHLECHTERE Ergebnisse als Hoch. Nur für die wirklich schwierigsten Probleme reservieren, die du je hattest.

Die Regel: Beginne mit Mittel. Gehe nur zu Hoch, wenn die Qualität tatsächlich nicht ausreicht. Verwende niemals standardmäßig max.

Noch eine Einstellung, die Budgets killt:

Extended Thinking – standardmäßig ausschalten.

Schalte es nur für Probleme ein, die es wirklich erfordern. Es dauerhaft eingeschaltet zu lassen, ist wie den Motor im Leerlauf in der Einfahrt laufen zu lassen.

Der /handoff-Trick – Kontextfenster-Aufblähung beheben

Lange Sitzungen sind ein stiller Killer.

Jeder Durchgang sendet den gesamten Gesprächsverlauf erneut.

Eine Sitzung mit 200.000 Tokens wird zum teuersten Posten auf deiner Rechnung.

Die Lösung: Häufig neue Chats öffnen.

Aber du willst den Kontext nicht verlieren, wenn du das tust.

Verwende die /handoff-Fähigkeit:

1Gib mir einen Prompt, den ich verwenden kann, um diese Sitzung in
2einem neuen Chat neu zu starten, ohne unseren Kontext zu verlieren.
3
4Füge hinzu:
5- Was wir entschieden haben
6- Was wir gebaut haben
7- Was die nächsten Schritte sind
8- Alle wichtigen Einschränkungen, an die ich mich erinnern muss
9
10Halte ihn unter 500 Tokens, damit die neue Sitzung schlank startet.

Kopiere diesen Output.

Öffne einen neuen Chat.

Füge ihn ein.

Mache genau dort weiter, wo du aufgehört hast, zu einem Bruchteil der Kontextkosten.

Frische Sitzung alle 30–60 Minuten = massive Token-Ersparnis.

Die 4 teuren Fehler, die du vermeiden solltest

Fehler 1: Fable ist jetzt der Standard.

Wenn du Claude Code öffnest, verwendet es automatisch Fable.

Überprüfe den Modell-Auswähler vor jeder Sitzung.

Diese eine Gewohnheit hat mich schon öfter erwischt, als ich zugeben möchte, wie ich versehentlich Fable in normalen Chats verwendet habe.

Fehler 2: Kein Ausgabenlimit.

Am 7. Juli wechselt Fable von Standard-Abonnements.

Füge eine Kreditkarte hinzu und setze sofort ein hartes monatliches Limit.

Einstellungen → Nutzung → Limit anpassen.

Fable verbrennt Tokens schnell bei autonomen Läufen und langen Sitzungen.

Ohne ein hartes Limit kann ein einziger nächtlicher Agentenlauf eine Rechnung anhäufen, bevor du aufwachst.

Jemandem wurden bereits 960 $ für einen einzigen Prompt berechnet.

Setze das Limit heute Abend.

Fehler 3: Es bitten, seine Argumentation zu erklären.

Diese eine Anfrage kann Klassifikatoren auslösen, und deine Arbeit wird stillschweigend von einem schwächeren Modell erledigt, während du denkst, du seist noch bei Fable.

Lass die "Warum"-Anfragen weg. Beurteile die Output-Qualität, nicht den Prozess.

Fehler 4: Es mit winzigen Prompts häppchenweise füttern.

Fable hat stundenlang Kontext im Kopf.

Gib ihm das ganze chaotische Ding auf einmal.

Vollständiger Kontext. Die Einschränkungen. Wovor du wirklich Angst hast.

Ich habe Fable einen Refactoring gegeben, vor dem ich mich wochenlang gedrückt hatte, in einer einzigen kurzen Beschreibung. Es kam fertig zurück.

Es häppchenweise zu füttern, verschwendet das Eine, worin es am besten ist.

Der Modellkostenvergleich – wisse, was du tatsächlich bezahlst

Bevor du etwas weiterleitest, kenne den Preis jedes Modells:

Modell Input ($/M) Output ($/M) Am besten für

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Fable 5 ~$15 ~$75 Planung, Überprüfung

Opus 4.8 ~$5 ~$25 Tiefgründiges Reasoning

Sonnet 5 ~$3 ~$15 Standard-Ausführung

Kimi K2.7 ~$0.95 ~$4.00 Massen-Coding, langer Kontext

GLM-5.2 ~$1.40 ~$4.40 Repo-weite Arbeit

DeepSeek v4 ~$0.28 ~$1.10 Spottbillige Routinearbeit

Haiku 4.5 ~$1 ~$5 Bereinigung, Formatierung

Lokal (Qwen/Llama) $0 $0 Autovervollständigung, Boilerplate

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Die Lücke zwischen Fable und DeepSeek: 53x beim Input. 68x beim Output.

Derselbe 30-Schritte-Refactoring-Agent: → Nur Fable: ~25 $ pro Durchlauf → Fable-Plan + Kimi-Ausführung: ~1,40 $ pro Durchlauf → Gleicher ausgelieferter Code. Gleiche bestandene Tests.

Routing geht nicht darum, billig zu sein.

Es geht darum, präzise zu sein.

Das vollständige System – wie es im Betrieb aussieht

Vor diesem System:

→ Alles wird an Fable weitergeleitet

→ Die Rechnung schnellt jedes Mal in die Höhe, wenn du auslieferst

→ Nutzungslimits werden mitten in der Sitzung erreicht

→ Du rationierst Prompts wie ein Budget-Reisender

Nach diesem System:

→ Fable kümmert sich um die 10 %, die es wirklich brauchen

→ Billige Modelle kümmern sich um die 80 % der Ausführung

→ /loop läuft über Nacht, ohne dein Limit zu berühren

→ Du lieferst mehr aus, gibst weniger aus, erreichst nie ein Rate-Limit

Die Drei-Zeilen-Zusammenfassung:

Fable plant. Andere führen aus. Fable überprüft.

Diese eine Regel senkt deine Rechnung um über 50 %, bevor du irgendetwas anderes änderst.

Der Rest ist Optimierung.

Führe das heute Abend aus

Füge das jetzt sofort in Fable ein:

Lies meine aktuelle CLAUDE.md und alle meine aktiven Projekte.

Deine Aufgabe: Richte das 10-80-10-Routing-System für meinen Workflow ein.

Erstelle:

1. Aktualisierte CLAUDE.md mit der vollständigen Modell-Routing-Tabelle
2. Eine Liste meiner aktuellen aktiven Aufgaben, geordnet danach, welches Modell welche bearbeiten sollte
3. Drei /goal-Prompts, die ich heute Abend auf günstigeren Modellen ausführen kann, basierend auf dem, was du in meinen Projekten siehst

Führe nichts aus. Plane und routiere nur.

Fable macht die Planung.

Du wachst mit einem vollständigen Routing-System auf.

Und einer Rechnung, die dir keinen Herzinfarkt beschert.

Wenn dir das Geld gespart hat:

→ Teile es erneut, damit andere Bauherren aufhören, ihre Budgets zu verbrennen

→ Folge @sairahul1 für weitere Systeme wie dieses

→ Lesezeichen setzen – die CLAUDE.md-Konfigurationen funktionieren, füge sie heute Abend ein

Abonniere theaibuilders.co für weitere interessante Artikel dieser Art

Ich schreibe über KI, das Bauen von Produkten und Systeme, die funktionieren, während du schläfst.

Ressourcen:

→ Entelligence Token Router: entelligence.ai/blogs/entelligence-token-router

→ Drei-Modell-Workflow, der Rechnungen um 80 % senkte: entelligence.ai/blogs/our-three-model-coding-workflow-that-cut-our-ai-bill-80

→ Claude Code: claude.ai/code

→ Codex CLI: npmjs.com/package/@openai/codex