원본 영상을 바탕으로 AI의 도움을 받아 작성했습니다. 원본 영상이 기준입니다.
Log in to leave a comment
아직 작성된 글이 없습니다
Wenn ein einzelner Entwickler mit weniger als einem Jahr Erfahrung Claude Code auf eine riesige Legacy-Codebasis ansetzt, ist das Token-Budget in weniger als einer Stunde erschöpft. Es gibt keinen Senior im Unternehmen, den man fragen kann, und nachdem man sich nur mit den grundlegenden CLI-Befehlen vertraut gemacht hat, öffnet man das Terminal und erhält im Minutentakt Benachrichtigungen über Kreditkartenbelastungen.
Claude Code speichert den Konversationsstatus nicht auf dem Server. Der System-Prompt, die Projektkonfigurationsdatei CLAUDE.md, der kumulierte Konversationsverlauf und die Ergebnisse von Tool-Aufrufen werden in jeder Runde zu einer einzigen Nutzlast zusammengefasst und erneut an die Anthropic API gesendet. In den ersten ein bis zwei Runden direkt nach Sitzungsbeginn liegt der Wert bei etwa 15.000 Tokens, doch sobald der Agent mit der Erkundung beginnt und Build-Artefakte oder Zehntausende Zeilen Logs liest, schwillt die Nutzlast auf bis zu 80.000 Tokens an. Nach mehr als 6 bis 10 Runden fliessen pro Runde 120.000 bis 200.000 Tokens hin und her. Es ist eine Struktur, bei der die Kosten pro Runde im Zinseszinseffekt berechnet werden.
Betrachtet man die offiziellen Prompt-Caching-Preise von Anthropic, wird die Ursache noch deutlicher. Wenn derselbe Präfix-Kontext beibehalten wird, fallen nur 10% der Kosten im Vergleich zu den standardmässigen Eingabetokens an. Wenn der Agent jedoch unregelmässig Zehntausende Zeilen Code liest und dadurch das Cache-Präfix bricht, fallen basierend auf einer 5-minütigen TTL neue Cache-Erstellungskosten an, die das 1,25-Fache betragen. Aus diesem Grund schnellen die Gebühren bereits nach wenigen Suchvorgängen in eine Höhe, die man alleine kaum tragen kann.
Viele Entwickler erstellen eine .claude-Datei im Stammverzeichnis und fühlen sich sicher. Um es vorwegzunehmen: Eine solche Konfigurationsdatei existiert in der offiziellen CLI-Engine von Claude Code überhaupt nicht. Auch die Methode, in CLAUDE.md zu hinterlassen: „Protokollordner nicht lesen“, wird vom Modell ignoriert, sobald es dies für erforderlich hält.
Um den Dateizugriff des Agenten auf Engine-Ebene physisch zu unterbinden, müssen Sie die Einstellung permissions.deny in der Datei .claude/settings.json verwenden.
Fassen Sie Build-Artefakte und Sicherheitsdateien zunächst in .claude/settings.json im Projektstammverzeichnis zusammen:
json { "permissions": { "deny": [ "Read(./.env*)", "Read(./secrets/**)", "Read(**/node_modules/**)", "Read(**/dist/**)", "Read(**/build/**)", "Read(**/coverage/**)", "Read(**/target/**)", "Read(**/*.log)", "Read(**/*.map)", "Read(legacy-backups/**)", "Edit(**/dist/**)", "Write(**/dist/**)" ], "ask": [ "Bash(git push *)", "Bash(npm publish)", "Bash(rm -rf *)" ], "allow": [ "Read", "Edit", "Bash(npm test)", "Bash(npm run lint)", "Bash(git status)", "Bash(git diff *)" ] } }
Um zu verhindern, dass bei der Bearbeitung der Backend-Logik auch Frontend-Code mitgesammelt wird, verwenden Sie eine separate lokale Konfiguration namens .claude/settings.local.json:
json { "permissions": { "deny": [ "Read(apps/web/**)", "Read(frontend/**)", "Read(public/**)", "Edit(apps/web/**)", "Write(apps/web/**)" ] } }
Sie müssen auch verhindern, dass der Agent grosse Protokolldateien über Shell-Befehle wie cat oder head komplett ins Terminal ausgibt. Fangen Sie Befehle im Vorfeld ab, indem Sie einen PreToolUse-Hook in .claude/settings.json einrichten:
json { "hooks": { "PreToolUse": [ { "matcher": "Bash", "hooks": [ { "type": "command", "command": "bash", "args": ["${CLAUDE_PROJECT_DIR}/.claude/hooks/block-large-reads.sh"] } ] } ] } }
Erstellen Sie die Datei .claude/hooks/block-large-reads.sh und erteilen Sie mit chmod +x Ausführungsrechte:
`bash
#!/usr/bin/env bash
PAYLOAD=(echo "$PAYLOAD" | jq -r '.tool_input.command // empty')
if echo "$COMMAND" | grep -Eq '(cat|head|tail|less)\s+.*(.log|.map|.lock|dist/|build/)'; then
echo "Direktes Ausgeben grosser Dateien erkannt. Ausführung wird abgebrochen." >&2
exit 2
fi
exit 0
`
Wenn auf Betriebssystemprozessebene der Exit-Code 2 zurückgegeben wird, stoppt die Dateiausgabe des Agenten sofort. Durch das Blockieren unnötiger Dateiscanvorgänge wird der Token-Verbrauch in den ersten Runden um mehr als die Hälfte gesenkt.
Wenn Sie den Agenten eine über 1.000 Zeilen lange Legacy-Datei komplett neu schreiben lassen, nur um eine einzige Variable zu ändern, führt dies zu Bugs und verschwendet zudem Ausgabetokens. Innerhalb von Claude Code wird zwischen dem Write-Tool zum Überschreiben von Dateien und dem Edit-Tool zum Ersetzen nur bestimmter Zeichenfolgenblöcke unterschieden.
In der Datei CLAUDE.md im Projektstammverzeichnis müssen Bearbeitungsregeln verankert werden:
`markdown
Anstatt dem Agenten die gesamte grosse Datei zu übergeben, ist es besser, nur die betroffene Funktion zu extrahieren. Hier ist ein Shell-Skript (extract-func.sh), das das AST-Parser-Tool ast-grep verwendet:
`bash
#!/usr/bin/env bash
TARGET_FILE=2
if [ -z "FUNC_NAME" ]; then
echo "Nutzung: ./extract-func.sh " >&2
exit 1
fi
if command -v sg &> /dev/null; then
sg run --pattern "function TARGET_FILE"
else
LINE_START=TARGET_FILE" 2>/dev/null | grep -w "$FUNC_NAME" | awk '{print 3}')
if [ -n "LINE_START" ]; then
sed -n "((LINE_START + 100))p" "$TARGET_FILE"
else
grep -n -A 60 "function TARGET_FILE"
fi
fi
`
Übergeben Sie nur die extrahierte Funktion oder das gestagte git diff im Headless-Modus (claude -p), um Korrekturen anzufordern:
`bash
./extract-func.sh src/billing.js processRefund | claude -p "Gib nur den Ersatz-Codeblock (new_string) für Edit aus, der den Berechnungsfehler in der obigen Funktion behebt."
git diff --staged src/services/OrderService.js | claude -p "Zeige in diesem diff nur auf mögliche Parallelitätsprobleme oder Null-Referenzen hin."
`
Indem Sie als Eingabe anstelle des gesamten Quellcodes nur Slices von 50 bis 100 Zeilen übergeben, können Sie den Token-Verbrauch pro Runde um fast 90% reduzieren.
Es gibt keinen Grund, eine Arbeit über eine Sitzung hinweg künstlich in die Länge zu ziehen. Je mehr sich der Konversationsverlauf ansammelt, desto höher fallen die Fixkosten an, die für jede Runde anfallen. Das Claude-Modell unterstützt /autocompact, wodurch der Konversationsverlauf bei Erreichen von ca. 967.000 Tokens automatisch zusammengefasst wird, allerdings löscht das System beim Kürzen des Codes häufig den Kontext wichtiger Parameter oder Randfälle. Sie müssen den Kontext selbst leeren.
Überprüfen Sie den aktuellen Status im Terminal mit drei integrierten Befehlen:
/context: Zeigt das Speicherverhältnis an, das vom System-Prompt und dem Konversationsverlauf beansprucht wird./usage: Überprüft die Token-Nutzung der Sitzung und die Auslastungsrate des Tariflimits./cost: Überprüft die kumulierten tatsächlichen Dollar-Kosten für die aktuelle Sitzung.Wenn die Anzahl der Tokens 100.000 überschreitet oder eine bestimmte Arbeitseinheit abgeschlossen ist, weisen Sie Claude Code an, HANDOFF.md zu schreiben, bevor Sie die Sitzung beenden:
text Zeichne den Arbeitsstatus der aktuellen Sitzung im Projektstamm in HANDOFF.md im folgenden Format auf: Goal: Arbeitsziel und Zielmodul Current Progress: Modifizierte Dateien und konkrete Zeilen What Worked: Verifizierte Logik und bestandene Tests What Failed: Fehlgeschlagene Ansätze und Vorsichtsmassnahmen Immediate Next Step: Einzelne Aufgabe, die unmittelbar zu Beginn der nächsten Sitzung ausgeführt werden muss
Sobald die Aufzeichnung abgeschlossen ist, leeren Sie das Kontextfenster mit dem Befehl /clear. Öffnen Sie eine neue Sitzung und übergeben Sie nur die Zusammenfassung der vorherigen Sitzung:
text Lies die Datei HANDOFF.md und setze die Arbeit ab dem Punkt 'Immediate Next Step' fort. Versuche nicht noch einmal die zuvor fehlgeschlagenen Ansätze.
Wenn Sie dreimal oder öfter im selben Fehlerkreis feststecken, müssen Sie sofort die Escape-Taste drücken, um abzubrechen. Wenn es unpraktisch ist, die gesamte Sitzung zu leeren, kehren Sie mit /rewind zur vorherigen Runde zurück, in der alles noch ordnungsgemäss funktionierte. Da /rewind den etablierten System-Präfix-Prompt-Cache beibehält, kehren Sie zur normalen Verzweigung zurück, ohne zusätzliche Cache-Schreibkosten zahlen zu müssen.
| Verteidigungsschicht | Einstellungsposition | Steuerungsebene | Gemessene Token-Einsparung |
|---|---|---|---|
| Harness-Dateifilterung | .claude/settings.json (permissions.deny) |
CLI-Engine erzwungen | Blockierung von 50% ~ 80% der initialen Scantokens pro Sitzung |
| Shell-Befehls-Firewall | PreToolUse Hook (block-large-reads.sh) |
OS-Prozessblockade (Exit 2) | 100% Abwehr der massiven Ausgabe von Logs und Bundles |
| Kontext-Slicing | ast-grep, git diff Pipeline |
Einschränkung des Eingabebereichs | Reduzierung der Tokens pro Dateianalyse- und Korrekturrunde um 90% |
| Sitzungslebensdauer-Verwaltung | /context, /clear, HANDOFF.md |
Manuelle Statuspersistenz | Einsparung von über 60% der kumulierten Zinseszins-Token-Gebühren in der zweiten Sitzungshälfte |
Sie müssen die Regeln einhalten, unnötige Pfade mit .claude/settings.json zu blockieren und statt grosser Dateien nur geslicten Code zu übergeben, damit Claude Code in einer Solo-Entwicklungsumgebung als praktisches Entwicklungswerkzeug genutzt werden kann.