Token-Discipline-Skill für Claude Code: ehrlich getestet

Wir verbringen unsere Tage damit, fremde Claude-Skills zu vermessen, und ein Muster tauchte in der Telemetrie immer wieder auf: Teure Sessions wurden nicht teuer, weil Claude lange Antworten schrieb. Sie wurden teuer wegen dem, was Claude gelesen hat. Ganze Dateien geöffnet, um eine einzige Funktion zu finden. Dateien direkt nach einem erfolgreichen Edit noch mal gelesen, „nur zur Kontrolle". Ein JSON mit 16.000 Einträgen in den Kontext gezogen, als wäre es ein Blogpost.

Also haben wir einen Skill gebaut, der genau diese Seite der Rechnung angreift, ihn unter MIT-Lizenz veröffentlicht und das gemacht, was wir von jedem gelisteten Skill verlangen: mit kontrollierten Testläufen gegen eine Baseline gebenchmarkt und die Zahlen veröffentlicht — auch die, die nicht schmeicheln.

Der Skill heißt token-discipline. Er ist kostenlos: github.com/Skillproofdev/token-discipline.

Die Lücke in jedem Token-Skill, den wir untersucht haben

Bevor wir eine Zeile geschrieben haben, haben wir acht veröffentlichte Token-Spar-Skills und -Protokolle unter die Lupe genommen — vom Output-Verbosity-Regelwerk mit 5.800 Stars, das die Nische dominiert, über „Notfall"-Skills, die bei 40% Kontextauslastung greifen, bis zu Protokollen, die 76–93% Ersparnis versprechen, ohne erkennbaren Mechanismus und ohne Telemetrie, die wir finden konnten.

Fast alle teilen denselben blinden Fleck: Sie optimieren den Output. Präambel weg, Antworten kürzer, den Plan nicht mehr wiederholen. Das bringt etwas, ist aber die kleinere Hälfte der Rechnung. In Agenten-Sessions — Claude Code, das echte Arbeit in einem Repo erledigt — dominiert der Input: Jede gelesene Datei, jedes Suchergebnis, jede Tool-Ausgabe landet im Kontext und wird bei jeder weiteren Anfrage erneut mitgeschickt.

Drei Techniken auf der Input-Seite tauchten in keinem der acht als verbindliche Regel auf:

1. Erst suchen, dann lesen. Erst mit grep/glob lokalisieren, dann nur den passenden Abschnitt lesen. Nie eine ganze Datei öffnen, um etwas zu finden.
2. Unabhängige Tool-Calls bündeln. Wenn drei Reads nicht voneinander abhängen, gehören sie in eine Nachricht. Jeder zusätzliche Turn zahlt erneut Denk- und Erzähl-Tokens zwischen den Calls.
3. Dem eigenen Zustand vertrauen. Nach einem erfolgreichen eigenen Edit die Datei nicht zur Kontrolle erneut lesen — das Edit-Tool meldet laut einen Fehler, wenn es scheitert. Re-Reads sind für externe Änderungen da, nicht für die eigenen.

Diese drei bilden den Kern des Skills. Drumherum stehen sechs weitere Regeln: Ausschnitte statt ganzer Dateien lesen, große JSON-Dateien/Logs mit python oder jq abfragen statt sie zu öffnen, lange Outputs zusammenfassen und dann verwerfen, breite Recherche an Subagenten delegieren, den Kontext cache-freundlich halten (stabiler Prefix bleibt unangetastet — Anthropics eigener Engineering-Blog nennt Prompt-Caching den mit Abstand wirksamsten Kostenfaktor), und ja, auch knapper Output. Neun Regeln, jede als harte Regel mit genannter Alternative formuliert, sodass das Befolgen nie Korrektheit kostet.

Wie wir gebenchmarkt haben

Gleiches Protokoll wie in unserer Skill-Bench-Serie: gleiches Modell, gleicher Prompt, eine Variable. Jeder Task lief zweimal — ein Claude-Sonnet-Agent ohne Skill, einer, der zuerst SKILL.md gelesen hat und angewiesen wurde, sich strikt daran zu halten. Die Summen des Skill-Agenten enthalten die Kosten fürs Lesen des Skills selbst. Testumgebung war unsere eigene Codebase: eine Astro-Site mit rund 9.000 Zeilen Templates plus ein JSON-Datensatz mit 16.682 Einträgen — groß genug, dass undiszipliniertes Lesen tatsächlich schmerzt.

Fünf Task-Paare, gewählt, um das Spektrum von trivial bis wirklich mehrstufig abzudecken:

Task	Baseline	Mit Skill	Δ
Codebase-Q&A — 8 Fragen über mehrere Subsysteme	88.419	71.636	−19.0%
Multi-File-Edit — 4 koordinierte Änderungen	68.219	54.637	−19.9%
Code-Trace — One-Shot	53.986	52.850	−2.1%
Audit-Sweep — One-Shot	44.691	44.705	+0.0%
Big-JSON-Digest — One-Shot	42.726	45.164	+5.7%

Was die Zahlen wirklich sagen

Bei echter Multi-Step-Arbeit spart der Skill rund 20%. Die Codebase-Q&A mit acht Fragen kommt einer normalen Arbeitssession am nächsten — den Auth-Flow nachvollziehen, den Webhook erklären, die Sortierlogik finden. Der Baseline-Agent hat richtig geantwortet, dabei aber großzügig gelesen und redundant verifiziert. Der disziplinierte Agent hat dieselben Fragen mit derselben Genauigkeit beantwortet (wir haben jede file:line-Referenz aus beiden Läufen geprüft) — für 16.783 Tokens weniger.

Der Multi-File-Edit ist das interessantere Ergebnis. Vier koordinierte Änderungen über vier Dateien. Der Baseline-Agent war fertig und hat danach — Zitat aus seinem eigenen Report — „durch erneutes Lesen der geänderten Bereiche verifiziert". Diese Gewohnheit allein macht ein Fünftel der Rechnung aus. Der Skill-Agent hat dieselben vier Änderungen angewendet, die Zeremonien-Re-Reads übersprungen und fertig gemeldet. Wir haben beide Arbeitsbäume verglichen: Die Änderungen waren in beiden Fällen gleichwertig und korrekt. Nichts ging verloren, weil man darauf vertraut hat, dass das Tool bei einem Fehler laut meckert — genau dafür sind Tools da.

Bei trivialen One-Shots gleicht es sich aus — und das veröffentlichen wir trotzdem. Der JSON-Digest-Task hat mit Skill tatsächlich 5.7% mehr gekostet. Zwei Gründe, beide lehrreich. Erstens kostet das Lesen des Skills selbst rund 1.400 Tokens, und ein Task, der nach zwei Tool-Calls fertig ist, bietet für diesen Overhead keine Amortisationsfläche. Zweitens verhält sich ein aktuelles Modell bei einfachen Aufgaben schon von sich aus gut: Der Baseline-Agent hat einen Blick auf ein JSON mit 16.682 Einträgen geworfen und direkt zu python gegriffen, statt es zu öffnen. Kein Skill nötig. Disziplin zahlt sich dort aus, wo Undiszipliniertheit möglich ist — lange Sessions, viele Dateien, sich aufschaukelnder Kontext — nicht dort, wo es nichts zu verschwenden gibt.

Wenn deine Sessions meist aus One-Linern bestehen, liefert der Skill seine eigene Antwort: einen 60-Token-Destillat-Block, den du statt der vollen Skill-Installation in CLAUDE.md einfügst. Immer aktiv, kostet ungefähr so viel wie dieser Satz, und ein einziger vermiedener Ganze-Datei-Read zahlt ihn vielfach zurück. (Wir haben einen Rechner genau für diese Always-on-Steuer gebaut — die Mathematik zu Trigger-Descriptions gilt genauso für Regel-Blöcke.)

Die neun Regeln, kurz erklärt

Die vollständige SKILL.md hat ~1.400 Tokens und ist auf einen Blick lesbar; hier die Kurzform:

1. Erst suchen, dann lesen. Erst grep, dann den Treffer ±30 Zeilen lesen. Mehr als ~200 Zeilen zu lesen braucht einen Grund, den du in einem Satz nennen kannst.
2. Den Ausschnitt lesen, nicht die Datei. Offset+Limit für alles Lange; python/jq für alles Strukturierte. Ein großes JSON ist eine Datenbank, kein Dokument.
3. Unabhängige Tool-Calls bündeln. Eine Nachricht, mehrere Calls, immer wenn Outputs nicht als Inputs gebraucht werden.
4. Dem eigenen Zustand vertrauen. Keine Kontroll-Re-Reads nach eigenen Edits; keine erneuten Suchen, deren Ergebnisse schon im Kontext stehen.
5. Code nicht zurückzitieren. Mit file:line referenzieren. Nur das einfügen, was der Mensch zum Entscheiden sehen muss.
6. Zusammenfassen, dann verwerfen. Nach einem langen Tool-Output nur die 2–5 relevanten Fakten behalten, das Log nie erneut anfordern.
7. Schwere Recherche delegieren. Breite Sweeps gehen an einen Subagenten; die schweren Reads sterben in dessen Kontext, nicht in deinem.
8. Den Kontext cache-freundlich halten. Stabiler Prefix bleibt unangetastet; anhängen statt umschreiben; die Cache-TTL im Blick behalten.
9. Output-Disziplin. Antwort zuerst, keine Präambel, keine Diff-Essays.

Dazu ein Selbst-Check (drei Fragen vor jedem größeren Re-Read) und eine explizite Do-not-Liste, denn ein Token-Skill, der einen Agenten nötige Verifikation überspringen lässt, spart nichts — er verschiebt nur die Nacharbeit. Wenn eine echte Bugsuche die ganze Datei braucht, sagt die Regel: lesen, mit genanntem Grund.

Wo das im größeren Kostenbild steht

Regeln wie diese sind die variable Hälfte deiner Rechnung. Die fixe Hälfte — die 30.000-Token-Präambel aus MCP-Servern, aufgeblähten CLAUDE.md-Dateien und Always-on-Skill-Descriptions, die buchstäblich bei jeder Anfrage erneut mitgeschickt wird — ist ein anderes Problem mit anderen Fixes und für Vielnutzer meist der größere Hebel. Dieses Audit haben wir in Claude-Code-Token-Kosten senken aufgeschrieben; beide Stücke ergänzen sich: die Fixkosten einmal reparieren, dann hält token-discipline die variablen Kosten die ganze Session über flach.

Und falls du dich fragst, ob Skills generell Tokens sparen: unsere Skill-Bench-Serie hat vier populäre Skills gemessen und festgestellt, dass sie es meistens nicht tun — sie kosten zusätzliche Tokens und kaufen dafür Qualität und Disziplin. token-discipline wurde gezielt als Ausnahme gebaut, und selbst so verdient er sich seinen Platz nur bei Multi-Step-Arbeit. Das ist die ehrliche Grenze, und die ziehen wir lieber selbst, als dass du sie auf deiner Rechnung findest.

Installation

git clone https://github.com/Skillproofdev/token-discipline ~/.claude/skills/token-discipline

Claude Code neu starten. Der Skill triggert bei „reduce token usage", „work token-efficiently", Beschwerden über Kontextlimits und Kostenfragen — oder du wendest ihn session-weit über den enthaltenen CLAUDE.md-Block an.

FAQ

Ersetzt das die Output-Verbosity-Skills? Nein — der Kern davon (Regel 9) ist enthalten, dazu kommt die Input-Seite, die sie auslassen. Wenn du schon ein knappes Output-Regelwerk fährst, überschneidet sich token-discipline nur bei einer von neun Regeln damit.

Wird Claude dadurch schlampiger? Der Benchmark sagt nein: Der Multi-File-Edit kam auf beiden Seiten gleichwertig und korrekt heraus, und die Do-not-Liste des Skills schützt explizit die Verifikation, die wirklich nötig ist. Die Regeln ersetzen Zeremonien-Reads, nicht notwendige.

Warum ist der Skill selbst so kurz? Weil ein Token-Spar-Skill, der pro Session Tausende Tokens zum Laden kostet, seine eigene Parodie wäre. Die SKILL.md hat ~1.400 Tokens und wird bei Bedarf geladen; der Always-on-CLAUDE.md-Block hat ~60.

Ich habe ein Pro/Max-Abo, keinen API-Zugang. Spielt das eine Rolle? Ja, in der Währung der Limits: Dieselben Tokens, die API-Nutzern berechnet werden, fressen dein Nutzungskontingent auf. Zwanzig Prozent weniger Tokens bei Arbeitssessions bedeuten proportional mehr Arbeit, bevor du an die Decke stößt.

War der Benchmark Cherry-Picking? Die fünf Tasks wurden festgelegt, bevor auch nur eine Variante lief, und wir haben die beiden Ergebnisse veröffentlicht, bei denen der Skill verloren hat. Die Rohdaten — Token- und Tool-Call-Zahlen pro Lauf — stehen im Repo-README.