Zum Hauptinhalt springen

Senke deinen Token-Verbrauch (und die Kosten)

Fortgeschritten

Du zahlst für jeden Token rein und jeden Token raus. Die gute Nachricht: Die meisten realen Workloads schleppen totes Gewicht mit sich herum — aufgeblähte System-Prompts, erneut gesendeten Kontext, weitschweifige Antworten, das falsche Modell für eine einfache Aufgabe. Trimm das weg, und die Rechnung sinkt, ohne dass die Qualität leidet. Diese Seite ist das Power-User-Toolkit, grob nach Hebelwirkung geordnet.

What you'll learn
  • Wo Tokens tatsächlich verloren gehen — Input vs. Output vs. wiederverwendeter Kontext
  • Der knappe / 'Caveman'-Stil: was er wirklich spart und wo er nach hinten losgeht
  • Prompt-Caching und Batching für strukturelle Einsparungen Dollar für Dollar
  • Das Modell passend wählen (Haiku für günstige Aufgaben) und strukturierte Ausgabe statt Prosa
  • Vor dem Ausliefern messen mit dem Token-Counting-Endpunkt

Finde zuerst heraus, wohin die Tokens gehen​

Bevor du optimierst, teile deine Ausgaben in drei Eimer auf — jeder hat eine andere Lösung:

Die drei Token-Eimer
Drücke Enter oder die Leertaste, um die Karte umzudrehen. Nutze die Pfeiltasten links und rechts, um zwischen den Karten zu wechseln.Begriff angezeigt.
1 / 3

Die Lösungen passen sauber dazu: cache den wiederverwendeten Kontext, trimme den Input, kürze den Output, wähle das passende Modell und batche alles, was nicht zeitkritisch ist.

Der knappe / "Caveman"-Stil (Output-Einsparungen)​

Der virale Trick besteht darin, Claude anzuweisen, Füllwörter wegzulassen und in Fragmenten zu antworten — populär gemacht durch den quelloffenen caveman Claude Code Skill (MIT-lizenziert, von Julius Brussee), dessen Slogan lautet "why use many token when few token do trick". Er erzwingt kurze Sätze, Verben im Infinitiv und null Höflichkeitsfloskeln.

Die ehrliche Erkenntnis aus unabhängigen Tests: Der Stil kostet nichts am Inhalt (Code, Fachbegriffe, JSON bleiben exakt), aber die Einsparungen hängen vollständig von deiner Ausgangsbasis ab. Wenn deine Prompts bereits "fass dich kurz" sagen, ist der größte Teil des Gewinns schon eingefahren. Die großen Reduktionen (40–65 %) zeigen sich bei erklärungslastigen Antworten; strukturierte Extraktion bewegt sich kaum.

Schlanker Anweisungsblock — füge ihn in deinen System-Prompt ein

Answer terse. Cut filler, hedging, and pleasantries.
Drop articles (a/an/the) and softeners (just, really, basically, actually).
No preamble, no restating the question, no "happy to help."
Fragments are fine. Keep technical terms and code blocks exact.
Pattern per point: [thing] [action] [reason]. Next step if any.
Pro tip
  • Setze die Knapp-Regel einmal in den System-Prompt, nicht in jeden Nutzer-Turn — sie zu wiederholen zahlt die Input-Kosten bei jedem Aufruf erneut.
  • Komprimiere niemals Code, Bezeichner, JSON oder Zahlen. Komprimiere nur Prosa.
  • 'Be concise. Return JSON only.' ist für sich genommen schon ~60 % der erreichbaren Output-Einsparungen — schreib das, bevor du zu raffinierteren Tricks greifst.
Watch out
  • Der knappe Stil trimmt nur den OUTPUT. Er bringt nichts gegen einen 20k-Token-System-Prompt, den du bei jedem Aufruf erneut sendest — das ist ein Input-/Caching-Problem.
  • Bei Aufgaben mit Extended Thinking bleiben die Reasoning-Tokens unberührt; du verkleinerst nur die finale sichtbare Antwort.

Komprimiere Tool-Output, bevor er wieder in den Kontext gelangt (RTK)​

Caveman verkleinert das, was Claude schreibt. Das spiegelbildliche Leck in agentischen Sitzungen ist das, was Claude zurückliest: Jedes git status, npm test, ls -la oder Build-Log, das ein Coding-Agent ausführt, wird — Header, Fortschrittsbalken und alles — direkt als Input-Tokens beim nächsten Turn ins Kontextfenster geleitet. In einer langen Claude Code Sitzung übersteigt dieses Beobachtungsrauschen oft den System-Prompt.

rtk ("Rust Token Killer", Apache-2.0, in homebrew-core) ist ein CLI-Proxy, der genau darauf abzielt. rtk init -g installiert einen Claude Code PreToolUse-Hook am Bash-Tool (rtk hook claude), der jeden Befehl transparent zu rtk <command> umschreibt und dessen Ausgabe komprimiert — Header und visuelles Rauschen werden entfernt, ähnliche Zeilen gruppiert, Wiederholungen mit Zählern dedupliziert und Redundanz gekürzt —, bevor sie überhaupt das Modell erreicht.

RTK installieren und den globalen Hook einrichten (macOS)

brew install rtk          # see the repo for cargo / other installers
rtk init -g --hook-only   # PreToolUse(Bash) hook only, no RTK.md file
# undo anytime: rtk init -g --uninstall

Das Flag --hook-only ist für das Token-Budget entscheidend: Das Standard-rtk init schreibt außerdem eine RTK.md-Anweisungsdatei, die in jeder Sitzung geladen wird — ein fester Input-Kostenfaktor, der die Einsparungen teilweise zunichtemacht. Hook-only behält die Output-Komprimierung und fügt dem Präfix nichts hinzu. Starte Claude Code nach rtk init -g neu, damit der Hook geladen wird.

Pro tip
  • RTK und Caveman ergänzen sich, sie sind nicht redundant: Caveman komprimiert den Modell-OUTPUT, RTK komprimiert den Tool-Ergebnis-INPUT (die Beobachtungen, die jeden Turn zurückgespeist werden). Beide zusammen decken beide Richtungen ab.
  • Der Hook feuert pro Bash-Aufruf und schreibt transparent um — du änderst nicht, wie du promptest.
  • Miss an der echten Rechnung, nicht am README. Wenn deine Sitzungen wenige Shell-Befehle enthalten, hat RTK wenig zu komprimieren — sein Gewinn skaliert damit, wie verrauscht dein Tool-Output ist.

Cache das wiederverwendete Präfix (Input-Einsparungen)​

Wenn viele Aufrufe einen großen, unveränderlichen Block teilen — einen langen System-Prompt, einen Tool-Katalog, ein Referenzdokument —, verarbeitet Prompt-Caching ihn einmal und verwendet ihn bei jedem späteren Aufruf zu einem Bruchteil des Input-Preises wieder. Das ist die strukturelle Änderung mit der höchsten Hebelwirkung für Chat- und Agent-Workloads, weil sie sich bei jedem Turn auszahlt.

Die eine Regel: Das gecachte Präfix muss bei allen Aufrufen Byte für Byte identisch sein. Ein verirrter Zeitstempel oder eine umsortierte Tool-Liste nahe dem Anfang lässt deine Trefferquote stillschweigend auf null fallen. Die vollständige Mechanik, das zum Kopieren bereite cache_control-Snippet und wie du Treffer verifizierst, findest du in Prompt Caching & Cost Optimization.

Guided walkthrough1 of 3
  1. Verschiebe System-Prompt, Tools und Dokumente nach vorne; halte den sich ändernden Nutzer-Turn ans Ende.

Trimme den Kontext, den du sendest​

Caching verwendet Kontext günstig wieder, aber der günstigste Token ist der, den du nie sendest. Prüfe, was tatsächlich im Fenster steht:

  • Beschneide den System-Prompt. Lange Anweisungsblöcke sammeln Ballast an. Streiche Beispiele, die ihre Tokens nicht mehr verdienen; behalte ein starkes Beispiel statt fünf mittelmäßiger.
  • Abrufen, nicht abladen. Statt ein ganzes Dokument einzufügen, hol nur die relevanten Passagen (RAG). Ein 50-seitiges PDF zu senden, um eine einzige Frage zu beantworten, ist die häufigste Verschwendung.
  • Verdichte lange Sitzungen. Wenn ein Gespräch wächst, ersetze alte Turns durch eine kurze laufende Zusammenfassung, statt jede Nachricht ewig mitzuschleppen. Der Verlauf sind Input-Tokens, die du bei jedem Aufruf erneut zahlst.
  • Wähle den Tool-Katalog passend. Jede Tool-Definition sind Input-Tokens bei jeder Anfrage. Stelle nur die Tools bereit, die die aktuelle Aufgabe braucht.
  • Komprimiere statische Memory-Dateien. CLAUDE.md und Memory-Notizen sind wiederverwendeter Input, den du jede Sitzung erneut zahlst. Sie in knapper "Caveman"-Prosa umzuschreiben (z. B. mit dem caveman-compress-Befehl aus dem caveman Plugin) trimmt ein Stück weg — aber erwarte einstellige Werte bei Dateien, die schon schlank sind: Ein praktischer Durchlauf über eine straffe ~350-Wörter-CLAUDE.md kürzte nur ~10 %. Der Hebel ist real, aber klein; opfere die Klarheit der Anweisungen in deiner globalen Konfiguration nicht, um ihm hinterherzujagen.

Wähle das passende Modell​

Zahle keine Opus-Tarife für eine Aufgabe der Haiku-Klasse. Klassifizierung, Extraktion, einfache Formatierung und Routing laufen meist hervorragend auf dem kleinsten Modell zu einem Bruchteil des Preises pro Token. Reserviere die größeren Modelle für echt schwieriges Reasoning und erwäge Routing: Ein günstiges Modell erledigt die einfache Mehrheit und eskaliert nur die harten Fälle. Siehe Choosing a Model und Tokens, Context & Pricing für die Abwägungen.

Bevorzuge strukturierte Ausgabe gegenüber Prosa​

Nach JSON (oder einem anderen knappen Schema) statt nach einem erklärenden Absatz zu fragen, senkt Output-Tokens und beseitigt das Rätselraten beim Parsen weiter unten. Claude anzuweisen, nur ein kompaktes Objekt wie {"label": ..., "score": ...} zurückzugeben, generiert einen Bruchteil der Tokens einer geschwätzigen Antwort — und du überspringst das "Hier ist das Ergebnis:"-Vorgeplänkel komplett. Details in Structured Output.

Batche, was nicht zeitkritisch ist​

Für Offline-Arbeit, bei der du keine Antwort in Sekunden brauchst — Evals, Massenklassifizierung, Datensatz-Labeling, das Zusammenfassen eines Archivs —, führt Anthropics Message Batches API Anfragen asynchron aus, mit 50 % Rabatt auf Input- und Output-Tokens, wobei Ergebnisse typischerweise innerhalb von 24 Stunden zurückkommen.

Kombiniere das mit Caching und einem passend gewählten Modell, und der kombinierte Rabatt bei einem großen Offline-Job ist dramatisch.

Messen — nicht raten​

Optimiere gegen Zahlen, nicht gegen Bauchgefühl. Anthropics Token-Counting-Endpunkt liefert die exakte Input-Token-Anzahl für eine Anfrage bevor du sie sendest — gleiche Form wie ein Messages-Aufruf, und er ist kostenlos (mit Rate-Limit). Nutze ihn, um einen aufgeblähten Prompt mit einem getrimmten zu vergleichen, um Entscheidungen zum Modell-Routing zu treffen und um Prompts innerhalb des Kontextfensters zu halten.

Tokens vor dem Senden zählen (Python SDK)

import anthropic

client = anthropic.Anthropic()

resp = client.messages.count_tokens(
  model="claude-opus-4-8",
  system="You are a scientist",
  messages=[{"role": "user", "content": "Hello, Claude"}],
)
print(resp.input_tokens)  # exact input count, no charge for counting
Pro tip
  • Verwende nicht den Tokenizer eines anderen Modells (z. B. tiktoken) — die Zählungen unterscheiden sich je Modellfamilie. Nutze Anthropics Endpunkt.
  • Neuere Tokenizer können für denselben Text ~30 % mehr Tokens erzeugen als ältere Modelle — zähl neu, wenn du migrierst, recycle keine alten Schätzungen.
  • Lies input_tokens, cache_read_input_tokens und output_tokens aus der Usage der Antwort, um zu bestätigen, dass die Einsparungen in der Produktion ankamen.

Siehe Tokens, Context & Pricing für die Zählregeln und die Formel zur Kostenschätzung.

Ein Vorher/Nachher, durchgängig​

Ein Support-Triage-Assistent fährt bei jedem Ticket denselben 4.000-Token-System-Prompt + Tool-Katalog und schreibt eine geschwätzige 600-Token-Antwort.

Guided walkthrough1 of 4
  1. ~4.000 Input-Tokens, bei jedem Aufruf zum vollen Preis erneut gesendet + ~600 weitschweifige Output-Tokens, auf einem großen Modell. Nichts gecacht, synchron, Prosa-Antworten.

Jeder Hebel ist multiplikativ: gecachter Input × kleineres Modell × knapperer Output × Batch-Rabatt verbinden sich zu einer großen Gesamtreduktion — während die Antwortqualität bei dieser einfachen Aufgabe unverändert bleibt. Miss jeden Schritt mit count_tokens, damit du den Gewinn beweisen kannst, statt ihn anzunehmen.

Prüf dich selbst

0/4
  1. Der 'Caveman'-/knappe Stil reduziert primär welche Tokens?
  2. Du sendest denselben 10k-Token-System-Prompt bei jedem Aufruf erneut. Beste Lösung?
  3. Welche Workload passt am besten zum 50-%-Rabatt der Message Batches API?
  4. Wie solltest du verifizieren, dass eine Prompt-Änderung tatsächlich Tokens gespart hat?
Key takeaways
  • Teile die Ausgaben in Input, Output und wiederverwendeten Kontext — jeder Eimer hat eine andere Lösung.
  • Der knappe/'Caveman'-Stil kürzt nur den Output; die Gewinne sind groß bei Prosa, klein bei ohnehin knappen, strukturierten Aufgaben.
  • Cache das stabile Präfix (Byte für Byte identisch) für Input-Einsparungen Dollar für Dollar bei jedem Aufruf.
  • Trimme den Kontext, wähle das passende Modell und bevorzuge JSON gegenüber Prosa — günstige, sich aufaddierende Gewinne.
  • Batche nicht-dringende Arbeit für 50 % Rabatt und miss immer mit count_tokens, statt zu raten.

Quellen & weiterführende Literatur​

Weiter​