4 Token-Sparer für Claude Code getestet, einer kostet mehr

Im Juli 2026 gab JetBrains rund 320 $ an API-Guthaben aus — 425 abgerechnete Durchläufe — um rtk zu testen, einen Shell-Proxy, den zehntausende Entwickler installieren, um in Claude Code Tokens zu sparen. Das Urteil: Die Sessions wurden pro Aufgabe 7,6 % teurer. Zwei Wochen zuvor hatte dasselbe Team caveman vermessen, die Skill, die mit 65 % Token-Einsparung wirbt, und kam auf 8,5 %. Auf meinem eigenen Rechner meldet rtk gain 11,6 Millionen gesparte Tokens über 25 599 Kommandos.

Beide Zahlenreihen sind echt. Sie messen nur nicht dasselbe: die eine sind Kosten pro abgeschlossener Aufgabe, die andere Bash-Ausgabebytes.

Zahl	Was sie misst	Quelle
+7,6 % pro Aufgabe (p=0,004)	Gesamtkosten einer Aufgabe mit installiertem rtk	JetBrains, 425 Durchläufe, ~320 $
8,5 % der Output-Tokens	Gemessene Einsparung von caveman bei Agentenarbeit	JetBrains, 82 gepaarte Aufgaben
65 %	Von caveman beworbene Einsparung	caveman-README
11,6 Mio. gespart (41,6 %)	Von rtk komprimierte Bash-Ausgabebytes	rtk gain, 25 599 Kommandos

Das ist der Stack, vier Tools: graphify, rtk, Superpowers und caveman, zusammen 575 612 GitHub-Sterne am 2026-09-02. Jedes greift an einem anderen Stück der Rechnung an.

Tool	Sterne (2026-09-02)	Sprache	Lizenz
Superpowers	280 792	Markdown-Skills	MIT
graphify	113 946	Python	Apache-2.0
caveman	102 548	Go	MIT (Skill)
rtk	78 326	Rust	Apache-2.0

Eine Claude-Code-Rechnung hat zwei Seiten. Input-Tokens sind alles, was das Modell liest: die Ausgabe jedes Shell-Kommandos, dein Prompt, der System-Prompt und der komplette Gesprächsverlauf, der bei jedem Aufruf erneut mitgeschickt wird. Output-Tokens sind alles, was das Modell schreibt.

rtks eigene Dokumentation zeichnet genau diesen Baum und ergänzt einen Satz, den der Launch-Post nie hatte: „Ein Kommando mit 90 % weniger Ausgabebytes macht deine Session nicht 90 % billiger."

JetBrains hat die Leseseite beziffert und dafür 83 Baseline-Sessions nachgespielt, 1,9 Millionen Zeichen Tool-Ausgabe.

Anteil dessen, was das Modell liest	Zeichen	Anteil
Shell-Ausgabe, die rtk komprimieren kann	373 339	19,7 %
Shell-Ausgabe, für die rtk keine Regel hat	879 326	46,3 %
Lese- und Suchtools, die rtk komplett umgehen	646 613	34,0 %

Nur ein Fünftel dessen, was das Modell liest, ist überhaupt von einem Shell-Proxy komprimierbar — die eingebauten Tools Read, Grep und Glob von Claude Code laufen nie über den Bash-Hook.

Daraus ergibt sich die Landkarte der vier Tools: graphify verkleinert, was der Agent liest, rtk verkleinert, was die Shell zurückgibt, Superpowers verkleinert den Verlauf, den jede Aufgabe mitschleppt, und wählt das Modell, das ihn trägt, und caveman verkleinert, was der Agent sagt. Die Leseseite ist die größere Hälfte der Rechnung, also beginnt das Ranking dort.

graphify ist eine Skill, die eine Codebasis — samt Docs, SQL-Schemas, Configs und PDFs — in einen abfragbaren Wissensgraphen verwandelt. Du tippst /graphify . in Claude Code, Cursor, Codex oder Gemini CLI, und das Projekt wird einmal kartiert, damit der Agent den Graphen abfragt, statt sich durch Dateien zu greppen.

Code wird mit tree-sitter-AST über rund 40 Sprachen geparst: deterministisch, kein LLM-Aufruf, nichts verlässt die Maschine. Der Aufbau kostet null LLM-Credits. Er erzeugt drei Dateien: graph.html zum Durchklicken, GRAPH_REPORT.md und graph.json — den Graphen selbst, abfragbar ohne erneutes Lesen deiner Dateien. Jeder Knoten ist ein Konzept (eine Datei, eine Funktion, eine Klasse), und jede Kante trägt das Tag EXTRACTED, wenn sie im Quelltext explizit stand, oder INFERRED, wenn graphify sie aufgelöst hat. Die Knoten werden mit dem Leiden-Algorithmus zu Subsystemen geclustert.

Der eingebaute Benchmark, auf einem unserer eigenen Projekte ausgeführt:

Kennzahl	Wert
Knoten	34 031
Kanten	56 865
Erkannte Communities	967
Herkunft der Kanten	76 % EXTRACTED · 24 % INFERRED
Naives Lesen des gesamten Korpus	1 701 550 Wörter ≈ 2 268 733 Tokens
Durchschnittliche Graph-Abfrage	~24 702 Tokens
Reduktion	91,8× weniger Tokens pro Abfrage

Pro Frage ist die Spanne groß: 679,1× bei „what is the main entry point", 34,0× bei „what connects the data layer to the api".

Zwei Grenzen. Der Vergleich läuft gegen „alles lesen", und eine grep-getriebene Session war nie so teuer, der echte Gewinn ist also kleiner. Und der Graph veraltet — halte ihn mit graphify update <path>, --watch oder den Git-Hooks aktuell — während der semantische Durchgang über Docs, PDFs und Bilder sehr wohl ein Modell aufruft und sehr wohl Tokens kostet.

Installation: uv tool install graphifyy (der Paketname hat ein doppeltes y), dann graphify install.

rtk ist ein CLI-Proxy zwischen Claude Code und deiner Shell. Alltägliche Kommandos wie ls, cat oder git status liefern Rauschen zurück, das der Agent als Input-Tokens lesen muss: Dateirechte, Fortschrittsbalken, hundert Zeilen grüner Tests. rtk führt dasselbe Kommando aus und gibt eine kompakte Fassung zurück: ein einziges Rust-Binary, über 100 unterstützte Kommandos, unter 10 ms Overhead. Ein PreToolUse-Hook schreibt jeden passenden Bash-Aufruf (git status → rtk git status) vor der Ausführung um, der Agent muss also nie daran denken.

Der Launch-Post des Autors behauptete 10,2 Mio. gesparte Tokens in zwei Wochen, 89,2 %, mit Beispielen wie cargo test, das von 155 Zeilen auf 3 schrumpft. Unser eigenes Dashboard nach 25 599 Kommandos:

Kommando	Aufrufe	Gesparte Tokens	Quote
rtk find	354	2,2 Mio.	46,6 %
rtk read	3 504	2,2 Mio.	10,4 %
rtk grep	2 760	1,9 Mio.	47,7 %
rtk ps aux	24	1,1 Mio.	98,0 %
rtk diff	39	541,1 K	92,2 %
Gesamt	25 599	11,6 Mio.	41,6 %

Dann der Prozess. JetBrains installierte rtk genau so, wie es ausgeliefert wird, und ließ 86 Aufgaben zweimal auf claude-sonnet-5 laufen.

JetBrains-Befund	Wert
Shell-Kommandos, die rtk umschreiben kann	349 von 1 056 (1 von 3)
Obergrenze der Gesamteinsparung	~3 % der Rechnung
Kosten pro Aufgabe, niedriger Reasoning-Aufwand	+7,6 % (p=0,004)
Turns pro Aufgabe	+13,8 % (p=0,03)
Kosten pro Aufgabe, hoher Aufwand	±0 %
Aufgabenqualität	Unverändert

Das rtk-README sagt es inzwischen klar: bis zu 90 % der Bash-Ausgabe, „nicht dasselbe wie 90 % weniger Rechnung", und die eigenen Zählungen werden als bytes / 4 geschätzt.

Urteil: kostenlos, die Kompression ist echt und, in JetBrains' Worten, „oft geschmackvoll". Behalte es für bash-lastige Sessions; erwarte nicht, dass es die Rechnung bewegt.

Superpowers ist Jesse Vincents Plugin für Claude Code — 280 792 Sterne, vierzehn Skills, ein Installationsbefehl (/plugin install superpowers@claude-plugins-official). Es spart Tokens, ohne irgendetwas zu komprimieren.

Alles beginnt mit der Brainstorming-Skill, die mit einem harten Gate öffnet: kein Code, kein Scaffolding, keine Implementierungs-Skill, bevor eine explizite Absicht freigegeben ist. Wenn die Skill lädt, wird der Agent zum Brainstorming-Partner, und in der Praxis werden Teile des Projekts neu gedacht, bevor überhaupt etwas gebaut wird. Das ist die wichtigste Stufe, denn die teuersten Tokens sind die, die man ins Falsche steckt.

Die Skill klassifiziert die Arbeit als Spike, begrenzte Änderung oder architektonische Änderung, und die Regel steht in der Datei: „Im Zweifel zwischen zwei Wegen nimm den schwereren." Sie benennt sogar den Fehlermodus, mit einem Anti-Pattern-Abschnitt namens „Too Simple To Need Approval". Der architektonische Weg liefert eine Spec, die du freigibst, und danach einen Implementierungsplan.

Aus dem Plan kommt die Verlässlichkeit. Die Skill writing-plans zerlegt die Arbeit in Schritte von je einer Aktion, 2 bis 5 Minuten: den fehlschlagenden Test schreiben, ihn ausführen, um das Fehlschlagen zu bestätigen, den minimalen Code schreiben, der ihn grün macht, die Tests erneut laufen lassen, committen. Pläne werden unter der Annahme geschrieben, dass der Umsetzende null Kontext hat. Eine so kleine Aufgabe passt mit Luft in ein frisches Kontextfenster, der Agent erreicht das Ende einer Aufgabe also nie mit gesättigtem Fenster — und aus einem gesättigten Fenster kommt halluzinierter Code.

Die Grenze ist die Zeremonie. Die Datei sagt, sie skaliere mit der Aufgabe, aber das Gate feuert trotzdem bei einem Einzeiler, und auch das kostet Tokens.

Dann läuft der Plan, und die Token-Rechnung ändert sich. Eine Aufgabe, ein Subagent. Jeder Subagent startet mit einem frischen Kontext, der nur seine Aufgabe enthält, nie den Sessionverlauf, sodass das Fenster des Orchestrators klein und das des Subagenten sauber bleibt. Nach jeder Aufgabe prüft der Orchestrator das Ergebnis: OK, nächste Aufgabe; nicht OK, die Korrektur geht zurück an einen Subagenten. Maximal fünf Runden pro Aufgabe — Runde 1 bis 3 setzen beim ursprünglichen Umsetzer fort, Runde 4 gibt die Arbeit an einen frischen Umsetzer auf einem stärkeren Modell, in Runde 5 entscheidet der Orchestrator selbst.

Die Regel, die alles bezahlt, ist die Modellwahl: „Nutze das schwächste Modell, das die jeweilige Rolle bewältigen kann, um Kosten zu sparen." Der Orchestrator bewertet die Schwierigkeit jeder Aufgabe und wählt das passende Modell.

Aufgabentyp	Modellstufe
Mechanisch, klar spezifiziert; der Plan enthält den Code bereits	Günstigstes / kleines Modell
Koordination über mehrere Dateien, Debugging	Standardmodell
Architektur, finaler Branch-Review	Stärkstes Modell
Modell nicht angegeben	Erbt das Modell der Session

Eine Nuance aus derselben Datei: „Die Zahl der Turns schlägt den Token-Preis." Ein billiges Modell, das drei Turns braucht, ist nicht billig. In der Praxis macht genau das Opus und Fable auf einem 20-$-Pro-Plan nutzbar — das teure Modell fasst eine Handvoll Aufgaben an statt die ganze Session.

Der letzte Gewinn ist Dokumentation. Jede Spec und jeder Plan ist eine Markdown-Datei in docs/superpowers/specs/ und docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md, am Ende der Arbeit committet. In der Pipeline dieses Kanals ist die Migration auf unsere aktuelle Video-Engine eine Spec plus ein Plan aus vierzehn Aufgaben, den man noch immer öffnen, in einer neuen Session erwähnen und weiterbauen kann. Nichts, was die Agenten getan haben, bleibt unerfasst.

Das letzte Stück ist, was der Agent sagt. Agenten erzählen — „klar", „gerne helfe ich", „das Problem, das du erlebst, kommt wahrscheinlich von" — und das sind Output-Tokens für nichts.

caveman ist eine Skill von Julius Brussee, 102 548 Sterne, die den Agenten wie einen Höhlenmenschen sprechen lässt: Artikel, Füllwörter, Höflichkeitsfloskeln und Absicherungen streichen und dem Muster [Ding] [Aktion] [Grund]. [nächster Schritt]. folgen. Code, Kommandos, Dateipfade und exakte Fehlermeldungen werden nie „gecavemannt"; nur die Prosa drumherum. Es gibt drei Stufen (/caveman lite|full|ultra) und einen SessionStart-Hook, der die Skill beim Start aktiviert.

Die eigene Tabelle, zehn Prompts über die Claude-API, kommt im Schnitt auf 1 214 Output-Tokens ohne die Skill und 294 mit — 65 %, mit 87 % im besten und 22 % im schlechtesten Fall.

Das README liefert die Ernüchterung selbst: die Skill kürzt nur den Output, Input- und Reasoning-Tokens ändern sich nicht, und ihre eigenen Regeln kosten pro Turn etwa 1 bis 1,5 k Input-Tokens. JetBrains hat sie an 82 gepaarten Agentenaufgaben für rund 106 $ Guthaben vermessen.

caveman	Beworben	Gemessen (JetBrains)
Einsparung Output-Tokens	65 %	8,5 % (592 k → 542 k)
Auswirkung auf Qualität	—	Keine messbare Verschlechterung (Vorzeichentest p=0,82)

Die Lücke ist strukturell: der Output eines Agenten besteht überwiegend aus Code und Tool-Aufrufen, die caveman zu Recht unangetastet lässt. JetBrains' Empfehlung: „Nutze es, wenn es dir gefällt. Es macht Spaß und kostet dich nichts messbares an Qualität."

Seit Claude Code v2.1.237 gibt es ein eingebautes Pendant, den Output-Stil Concise: Claude „beginnt mit dem Ergebnis, überspringt Vorrede und Erzählung und hält Antworten standardmäßig kurz". Auswählbar unter /config → Output style; er landet in .claude/settings.local.json und greift nach /clear oder in einer neuen Session. Eine gemeinsame Grenze: Output-Stile gelten nur für die Hauptunterhaltung — ein Subagent läuft mit seinem eigenen System-Prompt.

Rangfolge danach, was jedes Tool wirklich bewegt, samt seinem Preis.

Rang	Tool	Was es bewegt	Gemessener Effekt	Der Preis
1	Superpowers	Den Verlauf pro Aufgabe + welches Modell ihn liest	Teures Modell auf einer Handvoll Aufgaben statt der ganzen Session	Ein Gate bei jeder Aufgabe, auch bei Einzeilern
2	graphify	Was der Agent liest	91,8× weniger Tokens pro Abfrage als naives Lesen des Korpus (unser Projekt)	Der Graph veraltet; der semantische Durchgang kostet Tokens
3	rtk	Bash-Ausgabebytes	Obergrenze ~3 % der Rechnung; +7,6 % pro Aufgabe bei niedrigem Aufwand im JetBrains-Test	Nur 1 von 3 Shell-Kommandos hat eine Regel
4	caveman / Concise	Die Prosa, die der Agent schreibt	8,5 % der Output-Tokens, kein Qualitätsverlust	~1 bis 1,5 k Input-Tokens pro Turn

Superpowers gewinnt, und zwar nicht wegen irgendeiner Kompression: ein frischer Kontext pro Aufgabe und das günstigste Modell, das die Arbeit schafft, verändern, was gelesen wird und wer es liest. graphify ist Zweiter, weil weniger lesen die größere Hälfte der Rechnung ist. rtk ist echt, kostenlos und harmlos, aber zwei Drittel der Shell-Kommandos und sämtliche Dateizugriffe laufen daran vorbei. caveman, oder der inzwischen mitgelieferte Concise-Stil, stutzt das kleinste Stück.

Alle vier sind kostenlos — graphify und rtk unter Apache-2.0, Superpowers unter MIT, die caveman-Skill unter MIT. Mehr als 570 000 Sterne sagen, dass die Leute ein Wunder wollen. Die ehrliche Version ist eine Rangfolge.