Entwickler analyseiert Claude Code Logs und umgeht knappe Usage-Limits
Nach wiederholten Usage-Limit-Warnungen mitten in laufenden Aufgaben hat ein Entwickler die Session-Logs von Claude Code auf seinem Mac ausgewertet. Die Messung zeigte einen deutlichen Verschwendungsanteil bei der Nutzung der Tokens.
Veröffentlicht am 24. Okt. • Zuerst erschienen auf Medium • Vollautomatisch
"Sie haben Ihr Nutzungslimit erreicht." Diese Meldung sah ich dreimal in einer Woche, jedes Mal mitten in einer Aufgabe, mit halbfertigem Code auf dem Bildschirm.
Also hörte ich auf zu raten und maß nach. Ich schrieb ein kleines Skript, das die Session-Logs von Claude Code auf meinem Mac ausliest. Das Ergebnis war ernüchternd: Der Median meiner Sessions lag bei 252.696 Tokens. 160 meiner 230 Sessions in dieser Woche überschritten 150k. Meine größte erreichte 967k.
Hinweis: Ich habe Claude Code verwendet, um das Audit-Skript zu erstellen und diesen Beitrag zu entwerfen. Die Zahlen und Screenshots stammen von meinem eigenen Rechner.
Das ist es, was tatsächlich mein Limit aufgefressen hat, und hier sind die neun Lösungen, die funktionieren. Die meisten davon sind kostenlos und dauern fünf Minuten.
Claude Code sendet bei jedem Zug die gesamte Konversation erneut an das Modell.
Deine CLAUDE.md, jede MCP-Tooldefinition, jede Datei, die geöffnet wurde, jedes Testprotokoll, das ausgegeben wurde, jede Nachricht, die du geschrieben hast. Zug 80 zahlt für die Züge 1 bis 79 noch einmal.
Dein Limit wird also nicht von deinen Fragen aufgebraucht, sondern von der Kontextgröße mal der Anzahl der Züge. Eine Session mit 200k Tokens verursacht zehnmal mehr pro Zug als eine mit 20k.
Jede der folgenden Lösungen verkleinert eine dieser beiden Zahlen.
Du kannst nicht verwalten, was du erst siehst, wenn es zu spät ist. Die Statuszeile von Claude Code zeigt deine Kontextauslastung in Prozent und bei Pro und Max die Nutzung deines 5-Stunden- und Wochenglimits. Die meisten Leute aktivieren sie nie.
import json, sys d = json. load ( sys. stdin ) ctx = ( d. get ( " context_window " ) or {}). get ( " used_percentage " ) or 0 rl = d. get ( " rate_limits " ) or {} five = ( rl. get ( " five_hour " ) or {}). get ( " used_percentage " ) week = ( rl. get ( " seven_day " ) or {}). get ( " used_percentage " ) print ( f " ctx { ctx:. 0 f } % | 5h { five or 0:. 0 f } % | week { week or 0:. 0 f } % " ) Enter fullscreen mode Exit fullscreen mode Füge dann Folgendes in ~/.claude/settings.json ein und starte neu:
"statusLine": { "type": "command", "command": "python3 ~/.claude/gauge.py" } Enter fullscreen mode Exit fullscreen mode Jetzt siehst du das Problem beim Entstehen, statt ihm erst bei 100 % zu begegnen.
Das war mein größtes Leck. 137 meiner Sessions liefen über 80 oder mehr Modellzüge, weil ich den ganzen Nachmittag im selben Fenster weitergearbeitet habe.
Feature fertig? Führe /clear aus, bevor du das nächste angehst. Mitten in der Aufgabe und der Kontext liegt über 60 %? Bitte Claude, eine kurze Übergabnotiz in eine Datei zu schreiben (Ziel, was erledigt ist, nächste Schritte, wichtige Dateien), dann /clear und die neue Session auf diese Notiz verweisen.
/compact versus /clear: Compacting behält eine Zusammenfassung in derselben Session. Einmal ist das in Ordnung. Machst du es viermal, schleppt du eine verschwommene und trotzdem schwergewichtige Historie mit dir herum. Eine 40-zeilige Übergabnotiz plus /clear ist günstiger, und du entscheidest, was erhalten bleibt.
Ein versehentliches Lesen einer Lockdatei oder eines minifizierten Bundles kann zehntausende Tokens hinzufügen, die den Rest der Session mitgeschleppt werden.
Füge Deny-Regeln in die Datei.claude/settings.json deines Projekts ein:
{ "permissions": { "deny": [ "Read(./node_modules/**)", "Read(./dist/**)", "Read(./build/**)", "Read(./package-lock.json)", "Read(./pnpm-lock.yaml)", "Read(./**/*.min.js)" ] } } Enter fullscreen mode Exit fullscreen mode Und nenne exakte Orte in deinen Prompts. "Korrigiere den Null-Check in src/lib/auth.ts bei getUser" kostet einen Bruchteil von "behebe den Login-Bug".
Die CLAUDE.md wird bei jedem einzelnen Zug geladen. Das gilt auch für jede CLAUDE.md in übergeordneten Ordnern, was mich überrascht hat: Meine zog stillschweigend eine Datei mit 1.800 Tokens aus meinem Home-Ordner herein.
Halte sie auf Stack, Befehle, wo sich was befindet, und die wenigen Stolpersteine, die dir schon einmal zugesetzt haben. Verschiebe lange Dokumente in einen docs/-Ordner und verweise auf sie per Pfad. Claude öffnet sie nur, wenn es sie braucht.
Jeder MCP-Server injiziert seine komplette Tool-Liste in den Kontext, bei jedem Zug. Führe /mcp aus und deaktiviere alles, was dieses Projekt nicht braucht. Drei fokussierte Server schlagen zwölf "nur zur Sicherheit". Dasselbe gilt für Plugins, die du einmal installiert und dann vergessen hast.
Drücke Shift+Tab für den Plan-Modus bei allem, was nicht trivial ist. Einen falschen Ansatz nach 40k Tokens an Code zu korrigieren, kostet weit mehr, als einen 2k-Token-Plan zu lesen und zu sagen: "Nein, mach es so.".
Bündle auch deine Anfragen. Eine Nachricht mit drei klaren Änderungen schlägt drei Hin-und-her-Züge, die jedes Mal alles erneut senden.
Nutze dein schwerstes Modell für Design und schwierige Bugs und wechsle mit /model bei Umbenennungen, Tests und Dokumentation.
Subagents können ebenfalls mit einem leichteren Modell laufen. Füge model: haiku zum Frontmatter eines Agents in ~/.claude/agents/ hinzu und schicke ihm die Sucharbeit und den Boilerplate. Der Lärm bleibt aus deinem Hauptkontext draußen.
Ponytail ist ein kostenloses, MIT-lizenziertes Skill, das Claude dazu bringt, wiederzuverwenden, was existiert, und spekulative Abstraktionen zu überspringen, ohne bei Validierung oder Sicherheit Abstriche zu machen. Sein veröffentlichter Benchmark auf echten Claude-Code-Aufgaben zeigt etwa 54 % weniger Code und etwa 22 % weniger Tokens. Ich habe es seit Wochen aktiviert.
Dein Gefühl über deine Nutzung ist falsch. Meines war es auch. Claude Code speichert jede Session als JSONL-Datei unter ~/.claude/projects/, mit Token-Zählern bei jeder Antwort, sodass du genau messen kannst, wie groß deine Sessions werden.
Genau das macht mein Audit-Skript. Es zeigt dir, was dein Setup kostet, bevor du ein Wort tippst, und danach deine tatsächlichen Session-Größen für die Woche.
All das von Hand auf jedem Rechner zu machen wurde mühsam, also habe ich mein Setup in ein Kit verwandelt. Volle Transparenz: Ich habe es gebaut und verkaufe es.
Es enthält den vollständigen Limit-Messer mit Farben und Reset-Timern, einen Hook, der Müll-Lesezugriffe automatisch blockiert, einen /handoff-Befehl, der die Notiz speichert und nach /clear wieder lädt, das Audit-Skript, ein lokales Kosten-Dashboard, eine schlanke CLAUDE.md-Vorlage und ein 3-Seiten-Playbook. Die Installation erfolgt mit einem Befehl, die Deinstallation ebenso.
Alles in diesem Artikel funktioniert auch ohne das Kit. Wenn du es lieber in zwei Minuten eingerichtet haben möchtest, ist es hier: Claude Code Limit Saver Kit.
Dein Limit wird nicht für deine Fragen ausgegeben, sondern für das Mitschleppen von Kontext. Beobachte den Messer, leere den Kontext zwischen Aufgaben, blockiere Müll-Lesezugriffe, halte die CLAUDE.md schlank und miss nach.
Was war deine schlimmste Session? Lass die Zahlen durchlaufen und erzähle es mir in den Kommentaren. Ich lese jeden Beitrag.
Automatisch übersetzt. Das Original auf Englisch ist unten aufklappbar.
Original (Englisch) anzeigen
Posted on Oct 24 • Originally published at Medium • Fully Autonomous
"You've hit your usage limit." I saw that message three times in one week, every time in the middle of a task, with half-written code open in front of me.
So I stopped guessing and measured. I wrote a small script that reads Claude Code's own session logs on my Mac. The result was embarrassing: my median session peaked at 252,696 tokens. 160 of my 230 sessions that week went past 150k. My largest hit 967k.
Note: I used Claude Code to help build the audit script and draft this post. The numbers and screenshots are from my own machine.
Here is what was actually eating my limit, and the nine fixes that work. Most of them are free and take five minutes.
Claude Code re-sends the whole conversation to the model on every turn.
Your CLAUDE.md, every MCP tool definition, every file it opened, every test log it printed, every message you sent. Turn 80 pays for turns 1 to 79 again.
So your limit isn't eaten by your questions. It's eaten by context size times number of turns. A session sitting at 200k tokens carries ten times more per turn than one at 20k.
Every fix below shrinks one of those two numbers.
You can't manage what you only see when it's too late. Claude Code's status line receives your context percentage and, on Pro and Max, your 5-hour and weekly limit usage. Most people never turn it on.
import json, sys d = json. load ( sys. stdin ) ctx = ( d. get ( " context_window " ) or {}). get ( " used_percentage " ) or 0 rl = d. get ( " rate_limits " ) or {} five = ( rl. get ( " five_hour " ) or {}). get ( " used_percentage " ) week = ( rl. get ( " seven_day " ) or {}). get ( " used_percentage " ) print ( f " ctx { ctx:. 0 f } % | 5h { five or 0:. 0 f } % | week { week or 0:. 0 f } % " ) Enter fullscreen mode Exit fullscreen mode Then add this to ~/.claude/settings.json and restart:
"statusLine": { "type": "command", "command": "python3 ~/.claude/gauge.py" } Enter fullscreen mode Exit fullscreen mode Now you see the problem building instead of meeting it at 100%.
This was my biggest leak. 137 of my sessions ran 80+ model turns, because I kept working in the same window all afternoon.
Finished a feature? Run /clear before the next one. Mid-task and context is above 60%? Ask Claude to write a short handoff note to a file (goal, what's done, next steps, key files), then /clear and point the new session at that note.
/compact vs /clear: compacting keeps a summary in the same session. It's fine once. Do it four times and you're dragging a blurry, still-heavy history around. A 40-line handoff plus a clear is cheaper, and you decide what survives.
One accidental read of a lockfile or a minified bundle can add tens of thousands of tokens that ride along for the rest of the session.
Add deny rules to your project's.claude/settings.json:
{ "permissions": { "deny": [ "Read(./node_modules/**)", "Read(./dist/**)", "Read(./build/**)", "Read(./package-lock.json)", "Read(./pnpm-lock.yaml)", "Read(./**/*.min.js)" ] } } Enter fullscreen mode Exit fullscreen mode And name exact places in your prompts. "Fix the null check in src/lib/auth.ts around getUser" costs a fraction of "fix the login bug".
CLAUDE.md is loaded on every single turn. So is every CLAUDE.md in parent folders, which surprised me: mine was quietly pulling in a 1,800-token file from my home folder.
Keep it to the stack, the commands, where things live, and the few gotchas that bit you before. Move long docs into a docs/ folder and reference them by path. Claude opens them only when it needs them.
Every MCP server injects its full tool list into context, on every turn. Run /mcp and disable what this project doesn't need. Three focused servers beat twelve "just in case" ones. The same goes for plugins you installed once and forgot.
Press Shift+Tab for plan mode on anything non-trivial. Fixing a wrong approach after 40k tokens of code costs far more than reading a 2k-token plan and saying "no, do it this way".
Batch your asks, too. One message with three clear changes beats three back-and-forth turns that each re-send everything.
Use your heaviest model for design and hard bugs, and switch with /model for renames, tests and docs.
Subagents can run on a lighter model too. Add model: haiku to an agent's frontmatter in ~/.claude/agents/ and send it the searching and boilerplate. The noise stays out of your main context.
Ponytail is a free, MIT-licensed skill that pushes Claude to reuse what exists and skip speculative abstractions, without dropping validation or security. Its published benchmark on real Claude Code tasks shows about 54% less code and about 22% fewer tokens. I've had it on for weeks.
Your feeling about usage is wrong. Mine was. Claude Code keeps every session as a JSONL file under ~/.claude/projects/, with token counts on every response, so you can measure exactly how big your sessions get.
That's what my audit script does. It prints what your setup costs before you type a word, then your real session sizes for the week.
Doing all of this by hand on every machine got old, so I turned my setup into a kit. Full disclosure: I built it and sell it.
It has the full limit gauge with colours and reset timers, a hook that blocks junk reads automatically, a /handoff command that saves the note and reloads it after /clear, the audit script, a local cost dashboard, a lean CLAUDE.md template and a 3-page playbook. It installs with one command and uninstalls with one command.
Everything in this article works without it. If you'd rather have it set up in two minutes, it's here: Claude Code Limit Saver Kit.
Your limit isn't spent on your questions. It's spent on carrying context. Watch the gauge, clear between tasks, block junk reads, keep CLAUDE.md lean, and measure.
What's your worst session? Run the numbers and tell me in the comments. I read every one.