Ich habe den Quellcode von Claude Code gelesen, damit Sie es nicht müssen

Die meisten Leute öffnen Claude Code, tippen einen Prompt, warten auf die Antwort, tippen den nächsten Prompt.

Das ist, als würde man sich einen Ferrari kaufen und ihn nur im ersten Gang fahren.

Ich wollte verstehen, warum manche Leute scheinbar 10x mehr aus Claude Code rausholen als andere. Also habe ich getan, was jeder vernünftige Mensch tun würde: Ich habe den gesamten Quellcode gelesen (wenn ich „ich“ sage, meine ich natürlich Claude Code).

11 Architekturebenen. Tausende Zeilen. Eine Agenten-Orchestrierungsplattform als Terminal-Chat getarnt.

Hier ist, was der Quellcode darüber verrät, wie man dieses Ding wirklich nutzt.

1. CLAUDE.md wird bei jedem einzelnen Durchlauf geladen. Jeder. Einzelne. Durchlauf.

Das ist die Sache mit der größten Hebelwirkung, die du machen kannst – und fast niemand macht es richtig.

Die meisten haben entweder nichts in ihrer CLAUDE.md-Datei oder sie haben die ganze Bibel hineingeschrieben.

Der Quellcode zeigt, dass Claude Code deine CLAUDE.md-Dateien bei JEDER Query- Iteration liest. Nicht nur beim Session-Start. Bei jedem Durchlauf. Das bedeutet: Jedes Mal, wenn du eine Nachricht sendest, liest es deine Anweisungen erneut.

Es gibt eine ganze Hierarchie:

• ~/.claude/CLAUDE.md – global (dein Codierungsstil, Präferenzen)

• ./CLAUDE.md – auf Projektebene (Architekturentscheidungen, Konventionen)

• .claude/rules/*.md – modulare Regeln

• CLAUDE.local.md – private Notizen (gitignoriert)

Du bekommst 40.000 Zeichen. Das ist eine MENGE. Die meisten nutzen vielleicht 200.

Pack deine Architekturentscheidungen da rein. Deine Dateikonventionen. Deine Testmuster. Deine „mach das niemals“-Regeln. Das Modell liest sie bei jedem einzelnen Durchlauf. Das ist der Unterschied zwischen einem generischen Assistenten und deinem persönlichen Assistenten, der DEINE Codebase kennt.

Wenn du nach dem Lesen nur EINE Sache machst, dann diese.

2. Sub-Agents teilen sich den Prompt-Cache (Parallelität ist quasi kostenlos)

Das hat mich umgehauen.

Wenn Claude Code einen Sub-Agent abspaltet, erstellt es ein byteidentisches Abbild des Eltern-Kontexts. Die API cached das. Also kostet es kaum mehr, 5 Agents auf verschiedenen Teilen deiner Codebase arbeiten zu lassen, als einen Agent sequenziell arbeiten zu lassen.

Lies das nochmal.

5 Agents. Gleiche Kosten wie 1. Weil sie alle den Prompt-Cache treffen.

Die meisten nutzen Claude Code wie einen einzelnen Arbeiter. Eine Aufgabe nach der anderen. Warten, bis sie fertig ist. Dann die nächste geben.

Der Quellcode enthält buchstäblich drei Ausführungsmodelle für Sub-Agents:

• fork – erbt den Eltern-Kontext, cache-optimiert

• teammate – separates Panel in tmux oder iTerm, kommuniziert über dateibasierte Mailbox

• worktree – bekommt einen eigenen Git-Worktree, isolierter Branch pro Agent

Du kannst Claude Code sagen, es soll 5 Agents starten: einer macht ein Security-Audit, einer refaktoriert das Auth-Modul, einer schreibt Tests, einer aktualisiert die Doku, einer behebt Bugs. Alle gleichzeitig. Alle teilen sich den Cache.

Die Architektur ist DAFÜR gebaut. Sie single-threaded zu nutzen, ist kriminell.

3. Das Berechtigungssystem ist dafür gemacht, konfiguriert zu werden – nicht, um es wegzuklicken

Jedes Mal, wenn Claude Code fragt „Diese Aktion erlauben?“ und du auf „Ja“ klickst, ist das ein Fehler der Konfiguration, kein Feature.

Der Quellcode zeigt eine 5-stufige Einstellungskaskade:

1policy > flag > local > project > user

In ~/.claude/settings.json kannst du Glob-Muster festlegen, die immer erlaubt sind:

1{
2  "permissions": {
3    "allow": [
4      "Bash(npm *)",
5      "Bash(git *)",
6      "Edit(src/**)",
7      "Write(src/**)"
8    ]
9  }
10}

Es gibt drei Berechtigungsmodi:

• bypass – keine Berechtigungsprüfungen (gefährlich, aber schnell)

• allowEdits – erlaubt Dateibearbeitungen in deinem Arbeitsverzeichnis automatisch

• auto (das ist neu) – führt einen LLM-Klassifikator für jede Aktion aus. Das ist der Sweet Spot.

Der Auto-Modus hat eigene Allow-/Deny-Listen, die du konfigurieren kannst. Der Quellcode zeigt, dass er mehrere Resolver parallel laufen lässt: Benutzerklick, Hook-Klassifikator, Bridge – wer zuerst antwortet, gewinnt.

Jedes Mal, wenn du stoppst, um auf „Erlauben“ zu klicken, ist verschwendete Zeit. Einmal konfigurieren. Nie wieder klicken.

4. Es gibt 5 Komprimierungsstrategien. Kontextdruck ist ein echtes Problem

Der Quellcode enthält FÜNF verschiedene Methoden, um deine Unterhaltung zu komprimieren, wenn sie zu lang wird:

1. microcompact – zeitbasiertes Löschen alter Tool-Ergebnisse

1. context collapse – fasst Gesprächsabschnitte zusammen

1. session memory – extrahiert Schlüsselkontext in eine Datei

1. full compact – fasst den gesamten Verlauf zusammen

1. PTL truncation – verwirft die ältesten Nachrichtengruppen

Das sagt dir etwas Wichtiges: Kontextüberlauf ist ein zentrales Problem, an dem die Entwickler SEHR viel Zeit verbracht haben.

Was das für dich bedeutet:

• Verwende \/compact\ proaktiv. Warte nicht darauf, dass das System automatisch komprimiert und dabei Kontext verliert, der dir wichtig ist.

• Das Standardfenster liegt bei 200K Tokens. Du kannst dich aber für 1M Tokens entscheiden, indem du das \[1m]\-Modell-Suffix verwendest. Für große Refaktorisierungen über viele Dateien hinweg ist das wichtig.

• Lange Sessions sammeln „Session Memory“ – strukturierte Zusammenfassungen von Aufgaben-spezifikationen, Dateilisten, Workflow-Status, Fehlern und Erkenntnissen. Deshalb ist es besser, eine Session fortzusetzen, als eine neue zu starten.

• Große Tool-Ergebnisse werden auf der Festplatte gespeichert, wobei nur eine 8KB-Vorschau an das Modell gesendet wird. Wenn du eine riesige Datei einfügst, sieht das Modell möglicherweise nur einen Bruchteil. Halte die Eingaben fokussiert.

Die Leute, die das meiste aus Claude Code herausholen, verwenden \/compact\ wie manuellen Speicherpunkt in einem Videospiel. Bewahre, was wichtig ist, lösche, was nicht, und mach weiter.

5. Das Hook-System ist die echte Extension-API (25+ Lifecycle-Events)

Das ist die Power-User-Funktion, die fast niemand kennt.

Der Quellcode zeigt 25+ Lifecycle-Events, in die du einhaken kannst:

• PreToolUse – wird ausgeführt, bevor ein Tool ausgeführt wird

• PostToolUse – wird ausgeführt, nachdem ein Tool ausgeführt wurde

• UserPromptSubmit – wird ausgeführt, wenn du eine Nachricht sendest

• SessionStart / SessionEnd – Session-Lebenszyklus

• und 20+ weitere

Mit 5 Arten von Hooks:

• command – führt einen Shell-Befehl aus

• prompt – injiziert Kontext über LLM

• agent – führt eine vollständige Agent-Verifizierungsschleife aus

• HTTP – ruft einen Webhook auf

• function – führt JavaScript aus

Echte Beispiele, was du machen kannst:

• Vor jedem Datei-Schreiben automatisch Linting ausführen

• Nach jeder Bearbeitung Tests laufen lassen

• Relevante Doku automatisch in jeden Prompt einfügen

• Eine Slack-Benachrichtigung senden, wenn eine Aufgabe abgeschlossen ist

• Validieren, dass Sicherheitsmuster eingehalten werden, bevor Code ausgeliefert wird

Der \UserPromptSubmit\-Hook ist besonders verrückt. Du kannst \additional Context\ in jede einzelne Nachricht einfügen, die du sendest. Stell dir vor, du hängst automatisch Testergebnisse, aktuelle Git-Diffs oder den Projektstatus an jeden Prompt an, ohne etwas tippen zu müssen.

So baust du eine benutzerdefinierte Entwicklungsumgebung auf Basis von Claude Code. Nicht durch bessere Prompts, sondern indem du dich direkt in das System einklinkst.

6. Sessions sind persistent und fortsetzbar (hör auf, immer neu zu starten)

Jede Unterhaltung wird als JSONL gespeichert unter

1~/.claude/projects/{hash}/{sessionId}.jsonl

Der Quellcode unterstützt:

• --continue – setze deine letzte Session fort

• --resume – wähle eine bestimmte vergangene Session aus

• --fork-session – zweige von einer vergangenen Unterhaltung ab (ich persönlich liebe das)

Die Session-Memory-Extraktion bewahrt Schlüsselkontext über Komprimierungen hinweg: Aufgaben-spezifikationen, Dateilisten, Workflow-Status, Fehler und Erkenntnisse.

Die meisten starten jedes Mal eine neue Session, wenn sie Claude Code öffnen. Das ist, als würdest du deine IDE schließen und von Grund auf neu öffnen – jede Stunde. Der ganze Kontext darüber, was du gemacht hast, was fehlgeschlagen ist, was du gelernt hast – weg.

Verwende \--continue\. Immer. Lass Kontext akkumulieren. Lass das Session-Memory im Laufe der Zeit Erkenntnisse aufbauen. Der Quellcode hat buchstäblich Infrastruktur dafür. Nutze sie.

7. Das Tool-System umfasst 60+ Tools mit intelligentem Batching

Claude Code hat 60+ eingebaute Tools. Aber der interessante Teil ist WIE es sie ausführt.

Der Quellcode unterteilt Tool-Aufrufe in zwei Kategorien:

• concurrent – reine Leseoperationen (Dateien lesen, suchen, globbing) laufen parallel

• serial – ändernde Operationen (Bearbeitungen, Schreibvorgänge, Bash-Befehle) laufen nacheinander

Das bedeutet: Wenn Claude Code 10 Dateien lesen muss, um deine Codebase zu verstehen, liest es alle 10 gleichzeitig. Aber wenn es 3 Dateien bearbeiten muss, macht es das nacheinander, um Konflikte zu vermeiden.

Zusätzlich zu den eingebauten Tools kannst du MCP-Server anschließen, die weitere Tools hinzufügen. Der Quellcode verwendet verzögertes Laden (deferred loading). MCP-Tools werden nur geladen, wenn sie benötigt werden. Das Anschließen von 5 MCP-Servern verlangsamt also nicht jede Anfrage.

Und es gibt ToolSearch für die verzögerte Entdeckung von Tools, die der Agent noch nicht kennt.

Die praktische Erkenntnis: Wenn dein Workflow externe Systeme (Datenbanken, Cloud-Anbieter, CI/CD) umfasst, schließe MCP-Server dafür an. Die Architektur handhabt die Komplexität. Du bekommst einfach mehr Fähigkeiten.

8. Die Streaming-Architektur macht Unterbrechungen günstig

Die gesamte Pipeline verwendet asynchrone Generatoren, die einzelne Events liefern. Drücke Escape, um den aktuellen Stream sauber abzubrechen, ohne vorherigen Kontext zu verlieren.

Das klingt klein, aber es verändert, wie du Claude Code nutzen solltest.

Warte nicht auf eine Antwort, von der du weißt, dass sie falsch läuft. Unterbrich sofort und lenke um. Der Quellcode ist dafür ausgelegt. Dein vorheriger Kontext bleibt erhalten. Die unterbrochene Antwort wird sauber verworfen. Null Kosten.

Stell es dir wie Pair Programming vor. Wenn dein Partner anfängt, in die falsche Richtung zu gehen, wartest du nicht, bis er fertig ist. Du sagst „Eigentlich, geh lieber da lang.“ Gleiche Energie.

9. Das Wiederholungssystem ist ausgeklügelter, als du denkst

Der Quellcode zeigt:

• 10 Wiederholungen mit exponentiellem Backoff und Jitter (500ms Basis)

• Automatische OAuth-Token-Aktualisierung bei 401/403

• Modell-Fallback: Wenn Opus 3 Mal mit 529-Fehlern fehlschlägt, fällt es automatisch auf Sonnet zurück

• 90-Sekunden-Idle-Watchdog bei Streams – wenn das Streaming ins Stocken gerät, wird auf Nicht-Streaming zurückgegriffen

• Der persistente Modus hat unendliche Wiederholungen mit maximalem Backoff von 5 Minuten

Das bedeutet, Claude Code ist dafür gemacht, einfach laufen zu lassen. Es behandelt API-Aussetzer, Ratenlimits und Ausfälle elegant. Du musst es nicht bemuttern. Lass es im Hintergrund laufen und komm zu den Ergebnissen zurück.

Die Zusammenfassung: Die Aktionen mit der größten Hebelwirkung aus dem Quellcode:

• Schreibe eine echte CLAUDE.md → wird bei jedem Durchlauf geladen. 40K Zeichen. Höchste Hebelwirkung.

• Parallelisiere mit Sub-Agents → Fork-Modell teilt Prompt-Cache. 5 Agents ≈ Kosten von 1.

• Konfiguriere Berechtigungen in settings.json → eliminiere Klick-Müdigkeit für immer.

• Verwende /compact proaktiv → 5 Komprimierungsstrategien existieren, weil Kontextdruck real ist.

• Richte Hooks ein → 25+ Events, 5 Typen. Das ist die echte Extension-API.

• Verwende immer --continue → JSONL-Persistenz + Session Memory = akkumulierter Kontext.

• Schließe MCP-Server an → verzögertes Laden bedeutet null Kosten bis zur Nutzung.

• Unterbrich frei → Async Generators bedeuten null Kosten für Umleitung.

Das Fazit: Claude Code ist eine Agenten-Orchestrierungsplattform, die ein Terminal-UI trägt.

Die Leute, die 10x Output daraus holen, sind keine besseren Prompter. Sie haben es konfiguriert. Sie haben es parallelisiert. Sie haben sich eingeklinkt. Sie haben Kontext über Sessions hinweg akkumulieren lassen.

Der Quellcode macht das offensichtlich. Jetzt weißt du, was es eigentlich unter der Haube macht.

Teile, wenn dir das geholfen hat 🫶