Claude Code Token-Optimierung: Kosten mit /usage senken und Qualität halten

Token-Optimierung in Claude Code bedeutet nicht nur geringere Kosten. Wenn der Kontext zu groß wird, werden Antworten langsamer, alte Annahmen mischen sich in die aktuelle Aufgabe, und Claude liest Logs, Diffs und Entscheidungen erneut, die nicht mehr helfen. Das Ziel ist nicht die kleinste Token-Zahl, sondern dieselbe technische Qualität mit weniger irrelevanter Umgebung.

Stand Juni 2026 ist /usage der beste Einstieg. Die offizielle Command-Referenz beschreibt /usage als Befehl für session cost, plan usage limits und activity stats. /cost und /stats existieren als Aliase, aber für Artikel und Teamregeln ist /usage verständlicher. Auf Pro-, Max-, Team- und Enterprise-Plänen kann die Ansicht Nutzung nach Skills, Subagents, Plugins und MCP-Servern aufschlüsseln.

Die Methode hat vier Ebenen: Nutzung beobachten, Basiskontext reduzieren, laute Arbeit auslagern und wiederholbare Teamabläufe messen. Ein Hook ist ein Script oder Endpoint, das an einem festen Claude-Code-Lifecycle-Event läuft. Ein Subagent ist ein separater Kontext für eine schmale Aufgabe. Ein Harness ist das Gerüst, das Agentenarbeit wiederholbar und sicher macht.

flowchart LR
  A["Beobachten: /usage und /context"] --> B["Reduzieren: CLAUDE.md und begrenzte Inputs"]
  B --> C["Auslagern: Hooks / Skills / Subagents"]
  C --> D["Messen: OpenTelemetry und Teamregeln"]

Mit /usage beginnen

/usage muss nicht nach jedem Prompt laufen. Sinnvolle Zeitpunkte sind eine langsame Session, eine große Tool-Ausgabe, ein Handoff oder das Ende eines wiederholbaren Workflows. Zusammen mit /context erkennst du, ob Kosten aus der aktuellen Aufgabe, altem Verlauf, Memory-Dateien oder Tool-Kontext kommen.

Wichtig ist die Trennung zwischen Abrechnung und Arbeitsdiagnose. Der Session cost in /usage ist eine lokale Schätzung aus Token-Zahlen. API-Nutzer prüfen die verbindliche Abrechnung in Claude Console. Bei Abos ist die Dollar-Zahl der Session nicht automatisch die Rechnung; Plan-Balken und Aktivitätsaufschlüsselung sind im Alltag aussagekräftiger.

# In Claude Code ausführen
/usage
/context

# Wenn die Unterhaltung lang ist, aber weitergehen soll
/compact Preserve changed files, failing tests, decisions, and unresolved questions.

# Beim Wechsel zu einer unabhängigen Aufgabe
/clear

/compact fasst wichtigen Zustand zusammen. /clear startet einen neuen Kontext. Zu frühes Clear verliert Entscheidungen; gar kein Clear lässt spätere Aufgaben für alten Kontext zahlen.

Immer geladenes Memory kurz halten

Tokens entstehen nicht nur aus dem letzten Prompt. Gesprächsverlauf, CLAUDE.md, Auto Memory, Logs, Tool-Ausgaben, MCP-Server und Recherche-Notizen zählen mit. Teile Informationen in drei Gruppen.

Art	Bester Ort	Beispiel
Immer nötig	Kurzes CLAUDE.md	Build, Tests, harte Grenzen
Nur für diese Aufgabe	Gespräch und /compact	Geänderte Dateien, fehlschlagende Tests, offene Entscheidungen
Nach Sichtung wegwerfbar	Gefilterte Ausgabe	Lange Logs, generierte Diffs, breite Suchergebnisse

Die offizielle Memory-Dokumentation erklärt, dass CLAUDE.md als Kontext geladen wird. Je länger die Datei, desto höher der feste Preis jeder Session. Imports können Struktur schaffen, sparen aber keine Tokens, wenn die Inhalte beim Start trotzdem geladen werden.

# CLAUDE.md

## Project commands
- Build: npm run build
- Test: npm run test
- Type check: npm run typecheck

## Fast navigation
- API code: src/api/
- UI components: src/components/
- Tests: tests/

## Avoid by default
- Do not scan node_modules/, dist/, coverage/, or generated clients.
- Do not paste full logs. Ask for the failing command and relevant lines.

## Compact instructions
When compacting, preserve changed files, failing tests, decisions, credentials policy, and next actions.

Lange Review-Checklisten, Übersetzungsregeln, Migrations-Runbooks oder Release-Playbooks gehören eher in Skills oder separate Dokumente. Eine Skill wird bei Bedarf geladen; CLAUDE.md ist von Beginn an im Kontext.

Inputs vor dem Lesen filtern

Der häufigste Token-Verbrauch entsteht durch komplette Logs oder Diffs. Claude braucht Belege, keinen Dump. Behalte das komplette Artefakt lokal und gib zuerst nur die Zeilen weiter, die die nächste Entscheidung beeinflussen.

# Nicht das ganze Produktionslog, sondern Request-ID und Fehlerumfeld
tail -n 800 logs/app.log | grep -E -n -C 4 "request_id=abc123|ERROR|WARN"

# PR-Größe prüfen, bevor der ganze Diff gelesen wird
git diff --stat
git diff -- src/auth.ts tests/auth.test.ts

# Vollständige Testausgabe lokal speichern, Claude nur Fehlerumfeld geben
npm test 2>&1 | tee test.log
grep -E -n -C 6 "FAIL|ERROR|Error|failed|Assertion" test.log | head -160

Das versteckt keine Information. Es bestimmt nur den ersten Ausschnitt. Wenn er nicht reicht, lieferst du weitere Dateien oder Log-Zeilen nach.

Hooks vorsichtig einsetzen

Wiederholte Filter lassen sich als Hook automatisieren. Ein Hook darf Fehler nicht verschleiern und riskante Befehle nicht still genehmigen. Starte mit ask, prüfe den umgeschriebenen Befehl und teste lokal.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/hooks/filter-test-output.sh"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
set -euo pipefail

input=$(cat)
cmd=$(echo "$input" | jq -r '.tool_input.command // ""')

case "$cmd" in
  npm\ test*|pnpm\ test*|pytest*|go\ test*)
    filtered="$cmd 2>&1 | grep -E -n -C 6 '(FAIL|ERROR|Error|failed|Assertion)' | head -160"
    jq -n --arg command "$filtered" '{
      hookSpecificOutput: {
        hookEventName: "PreToolUse",
        permissionDecision: "ask",
        permissionDecisionReason: "Run test command with filtered output",
        updatedInput: { command: $command }
      }
    }'
    ;;
  *)
    echo '{}'
    ;;
esac

Das Beispiel benötigt jq. Für Teams sollte der vollständige Testlog zusätzlich gespeichert und der ursprüngliche Exit-Code erhalten bleiben. Ein Hook spart nur dann, wenn er Rauschen reduziert, nicht Beweise.

Laute Arbeit auslagern

Subagents sind sinnvoll, wenn der Prozess lang ist, die Hauptsession aber nur ein kurzes Ergebnis braucht: offizielle Docs prüfen und Änderungen zurückgeben, zehn Locale-Dateien auf Blocker prüfen oder einen fehlschlagenden Test ausführen und nur den ersten verwertbaren Stacktrace melden.

Erzeuge Subagents nicht reflexartig. Jeder hat eigenen Kontext, Memory, Tools und Kosten. Ihr Zweck ist, den Entscheidungskontext sauber zu halten, nicht unscharfe Arbeit blind zu parallelisieren. Für Skills gilt dasselbe: lange, seltene Playbooks aus CLAUDE.md herausnehmen und bei Bedarf laden.

Teamnutzung messen

Für Einzelpersonen reichen /usage und /context oft aus. In Teams macht OpenTelemetry Kosten, Token-Zahlen, Modell, Dauer und Tool-Aktivität vergleichbar. Beginne mit dem console exporter, bevor du Collector oder Dashboard anschließt.

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=console
export OTEL_LOGS_EXPORTER=console
export OTEL_METRIC_EXPORT_INTERVAL=10000
export OTEL_LOGS_EXPORT_INTERVAL=5000

claude

Miss Qualität daneben. Wenn Tokens um 30 % sinken, aber Korrekturrunden oder Review-Defekte steigen, ist der Prozess schlechter geworden.

Praxisfälle

Log-Analyse

Gib Request-ID, aktuelle Fehler, Zeitstempel, erwartetes Verhalten und Kontextzeilen. Starte klein und erweitere nur bei fehlenden Beweisen.

Code Review

Beginne mit git diff --stat, geänderten Dateien, Testergebnis und Review-Fokus. Große PRs werden besser in Security, Performance und Kompatibilität getrennt.

Mehrsprachiges Publishing

Die Entscheidungen des kanonischen Artikels bleiben in der Hauptsession. Übersetzung, Links, Description-Länge und CTAs werden in getrennten Kontexten geprüft.

Trainingstag

In Workshops ist die gleichzeitige Nutzung höher. Regeln wie “erst fünf Dateien”, “maximal 160 Fehlerzeilen” und “Scope-Erweiterung begründen” halten Kosten und Ablauf stabil.

Fehler vermeiden

• Nur /cost dokumentieren. Nutze /usage und erwähne /cost und /stats als Aliase.
• Beweise wegkürzen. Reproduktion, Erwartung, Fehlerbefehl und Entscheidungen müssen bleiben.
• CLAUDE.md als Betriebsnotizbuch nutzen. Seltene Workflows gehören in Skills.
• Zu viele MCP aktivieren. Prüfe /mcp und nutze CLI, wenn es reicht.
• Fehler mit Hooks verstecken. Speichere den vollständigen Log und zeige einen gefilterten Ausschnitt.
• Subagents für automatisch günstiger halten. Sie isolieren Rauschen, haben aber eigenen Kontext.

Kleines Handoff-Script

Dieses dependency-freie Node.js-Script erstellt ein kurzes Briefing aus geänderten Dateien, Diff-Größe und Testfehlern.

#!/usr/bin/env node
import { execFileSync } from "node:child_process";
import { existsSync, readFileSync } from "node:fs";

function git(args) {
  return execFileSync("git", args, { encoding: "utf8" }).trim();
}

const testLogPath = process.argv[2];
const changedFiles = git(["diff", "--name-only"])
  .split(/\r?\n/)
  .filter(Boolean);
const diffStat = git(["diff", "--stat"]);
const testLog = testLogPath && existsSync(testLogPath)
  ? readFileSync(testLogPath, "utf8")
  : "";
const failures = testLog
  .split(/\r?\n/)
  .filter((line) => /(FAIL|ERROR|Error|failed|Assertion)/.test(line))
  .slice(0, 80);

console.log("# Claude handoff brief\n");
console.log("## Changed files");
console.log(changedFiles.length ? changedFiles.map((file) => `- ${file}`).join("\n") : "- None");
console.log("\n## Diff stat");
console.log(diffStat || "No diff");
console.log("\n## Test failures");
console.log(failures.length ? failures.map((line) => `- ${line}`).join("\n") : "- No matching failure lines");

node scripts/claude-brief.mjs test.log > claude-brief.md

Geprüfte offizielle Dokumentation

• Commands für /usage, /context, /compact und /clear.
• Manage costs effectively für Kosten, MCP, Hooks, Skills, Subagents und Modellaufwand.
• How Claude remembers your project für CLAUDE.md und Auto Memory.
• Hooks reference und Monitoring für PreToolUse und OpenTelemetry.

Passende Artikel sind Geschwindigkeitsoptimierung, Berechtigungsleitfaden und Harness-Engineering-Leitfaden.

Praktisch geprüft

Für diese Überarbeitung habe ich den japanischen Artikel als kanonische Fassung genutzt und die offiziellen Dokumente geprüft, bevor alle zehn Locales aktualisiert wurden. Der größte praktische Gewinn war die Trennung von dauerhafter Memory, Aufgabenstatus und wegwerfbaren Logs. Ein kurzes Briefing mit geänderten Dateien, Fehlerzeilen und Verifikation führte zu stabileren Antworten als eine vollständige Testausgabe.

Für wiederverwendbare Prompts und Setup-Material starte mit ClaudeCodeLab products. Für Team-Rollout, Permissions, Review-Policy, Telemetrie und Training nutze Claude Code training and consultation.