Claude Code für Fortgeschrittene: zehn Techniken, die kaum jemand kennt

Claude Code begann als Terminal-Assistent. Heute liest es ganze Codebasen, führt Befehle aus, verwaltet Git-Abläufe und startet eigene Subagenten. Wer es weiter wie einen Chat mit angeflanschter Kommandozeile bedient, nutzt einen Bruchteil davon.

Die bekannten Themen — CLAUDE.md, MCP — sind nur die Oberfläche. Darunter liegt eine Reihe von Funktionen für parallelisiertes, produktives Arbeiten, die fast niemand kennt. Dieser Beitrag zeigt zehn davon. Er richtet sich an alle, die die Grundlagen-Befehle schon sicher beherrschen — einige Techniken zahlen sich vor allem in Softwareteams aus, andere im Alltag jeder Wissensarbeit.

Vom Chat-Partner zur gesteuerten Flotte

Der rote Faden hinter allen zehn Techniken: Du hörst auf, Claude eine einzelne Frage nach der anderen zu stellen, und fängst an, mehrere Arbeitsstränge zu steuern. Sessions werden zu wiederverwendbaren Bausteinen, Aufgaben laufen parallel, und du gibst klare Grenzen vor. Das ist der Unterschied zwischen „ich nutze Claude Code” und „ich orchestriere Claude Code”.

Sessions wiederverwenden statt neu starten

Jede Sitzung trägt Kontext, den du dir hart erarbeitet hast. Ihn wegzuwerfen und neu aufzubauen, ist Verschwendung.

Kontext vorwärmen mit Session-Forking

Lädst du dieselbe Sitzung in mehreren Terminals, vermischt sich die Historie — und das Modell halluziniert irgendwann über Dateien, die es gar nicht gibt. --fork-session löst das: Es dupliziert den aktuellen Stand der Sitzung und erzeugt einen sauberen, unabhängigen Ast. Wie git branch, nur für das Kontextfenster.

Daraus wird das Muster „Vorwärmen”: Du baust einmal eine schwere Master-Sitzung mit Architektur, Doku und Regeln auf und verzweigst sie für jede neue Aufgabe, statt jedes Mal von vorn anzufangen.

claude
"Lies die Architektur-Doku und bereite dich auf die Feature-Arbeit vor"
/rename master-context

# Für eine konkrete Aufgabe abzweigen, ohne das Original zu verschmutzen:
claude --resume master-context --fork-session

Nebeneffekt: So testest du sauber zwei Lösungswege gegeneinander. Forke dieselbe Master-Sitzung zweimal — Unterschiede im Ergebnis liegen dann am Ansatz, nicht an driftendem Kontext.

Reviews direkt aus dem Pull Request

Hast du einen Pull Request während einer Claude-Sitzung erstellt, verknüpft das Werkzeug die Sitzung automatisch mit diesem PR. Kommen später Änderungswünsche, holst du den exakten Stand des Agenten zurück, der den Code geschrieben hat:

claude --from-pr 447

Der Agent kennt wieder die ganze Historie: welche Dateien er gelesen hat, welche Abwägungen er getroffen hat. Aus „umschalten, neu einlesen, neu verstehen, antworten” wird „fortsetzen, einarbeiten, abschicken”.

Besser tippen, direkter ausführen

Zwei kleine Handgriffe mit großer Wirkung auf die Qualität deiner Eingaben.

Prompts im Editor schreiben

Die einzeilige Eingabezeile ist für lange Anweisungen ungeeignet. Ctrl+G öffnet deinen gewohnten Editor — mit Syntax-Hervorhebung, mehreren Cursorn, ordentlichem mehrzeiligem Schreiben. Du verfasst den Prompt, speicherst, schließt, und der ganze Text fließt in einem Stück zu Claude. Wenn du siehst, was du schreibst, steigt die Qualität spürbar.

Befehle direkt in der Shell ausführen

Stellst du einer Eingabe ein ! voran, geht sie nicht ans Modell, sondern direkt an deine Shell. Der Clou: Die Ausgabe landet automatisch im Kontext.

! npm run test:e2e
! git log --oneline -10

Du führst den Befehl aus, das Ergebnis steht sofort im Kontext, und Claude kann darüber nachdenken. Kein Kopieren, kein „hier ist der Fehler, den ich sehe” — das Modell hat ihn schon.

Rechenleistung bewusst steuern

Nicht jede Aufgabe braucht das tiefste Nachdenken. Über /model stellst du den Denk-Aufwand in vier Stufen ein — von Low (schnell, günstig: Standardcode, Umbenennungen, Kommentare) bis Max (langsam, teuer, tief: kniffliges Debugging, komplexe Schemata, harte Merge-Konflikte).

In automatisierten Skripten setzt du das fest:

export CLAUDE_CODE_EFFORT_LEVEL=low
claude -p "Füge JSDoc-Kommentare zu src/utils.ts hinzu"

Über hunderte automatische Aufrufe summiert sich das — in Geschwindigkeit und in Kosten. Eine Funktion, deren Nutzen man erst auf der Rechnung sieht.

Mehrere Agenten parallel — ohne Chaos

Mehrere Sitzungen ohne Trennung auf dasselbe Repository loszulassen, endet im Konflikt: Agenten überschreiben sich gegenseitig.

Isolierte Arbeitskopien mit Worktrees

--worktree nutzt im Hintergrund git worktree und legt für jeden Agenten ein eigenes Verzeichnis an — gleiche Git-Historie, getrennte Arbeitskopie.

# Terminal 1
claude --worktree feature/auth-refactor
# Terminal 2
claude --worktree feature/dashboard-ui

Beide arbeiten am selben Repo, ohne sich in die Quere zu kommen. Am Ende führst du die Stränge ganz normal über Git zusammen.

Subagenten spontan definieren

Feste Subagenten leben als Dateien im Projekt. Für spontane Abläufe definierst du sie direkt beim Start — mit eigenem Modell und eingeschränkten Werkzeugen. Der eigentliche Hebel ist das Modell-Routing: Die Hauptsitzung läuft auf einem starken Modell, wiederkehrende Kleinarbeit delegierst du an ein schnelles, günstiges. Erkennt Claude eine geänderte Datei, kann ein Test-Subagent im Hintergrund Tests nachziehen, während die Hauptarbeit weiterläuft. Wie Subagenten grundsätzlich funktionieren, steht im Konzept-Überblick.

Kontext gezielt zusammenfassen

Lange Fehlersuchen füllen das Kontextfenster mit totem Ballast — jeder „versuch dies, nein, versuch das”-Schritt kostet Token und verschlechtert die Antworten. Zweimal Esc öffnet das Rückspul-Menü. Die meisten nutzen es, um Änderungen zurückzunehmen. Der wahre Wert ist „ab hier zusammenfassen”.

Du wählst eine Nachricht aus der Mitte der Sitzung. Claude behält alles davor exakt — die anfänglichen Regeln, den frühen Kontext — und presst das Hin und Her danach in eine dichte Zusammenfassung. Die Sackgassen werden auf ihre Lehre eingedampft, ohne weiter Platz zu fressen. Du bekommst Token-Budget zurück, ohne den Faden zu verlieren. Mehr dazu im Beitrag zum Kontextmanagement.

Maschinenlesbar und abgesichert automatisieren

Hier verlässt Claude den Chat und wird Teil deiner Abläufe — mit klaren Grenzen.

Strukturierte JSON-Ausgabe

Gesprächstext ist in einer Pipeline nutzlos. Mit -p, --output-format json und einem vorgegebenen Schema zwingst du das Modell in eine feste, maschinenlesbare Form:

claude -p \
  --output-format json \
  --json-schema ./schemas/security-audit.schema.json \
  "Prüfe src/ auf Schwachstellen" | jq '.high_severity[]'

Du legst die Form fest, das Modell liefert genau die. Das Ergebnis lässt sich verlässlich weiterverarbeiten — in Skripte, Dienste, Dashboards.

Autonom in der Pipeline, aber mit hartem Limit

Einen Agenten ohne Grenzen in eine CI/CD-Pipeline zu setzen, ist riskant: Eine Endlosschleife verbrennt still dein Guthaben. Drei Schalter zusammen machen es sicher — -p (nicht-interaktiv), --max-turns (gegen Endlosschleifen), --max-budget-usd (harte Kostengrenze).

gh pr diff $PR_NUMMER | claude -p \
  --max-turns 3 \
  --max-budget-usd 1.50 \
  "Prüfe diesen Diff auf Sicherheitslücken. Nur umsetzbares Feedback."

Du brauchst beide Grenzen: --max-turns fängt entgleisende Logik ab, --max-budget-usd ist der Notausschalter für alles andere. Einzeln hat jede Lücken.

Was das im Kern bedeutet

Das sind keine Spielereien. Session-Forking, parallele Worktrees, spontane Subagenten und budgetierte Automatisierung markieren einen echten Wechsel: weg von „KI als Gesprächspartner”, hin zu „KI als gesteuerte Flotte spezialisierter Arbeiter”.

Du musst nicht alle zehn auf einmal können. Die meisten sind für Softwareteams gedacht; im Alltag jeder Wissensarbeit zahlen sich vor allem drei aus: Prompts im Editor schreiben, Befehle mit ! direkt ausführen und den Rechen-Aufwand über /model bewusst wählen. Der Abstand zwischen „ich nutze Claude Code” und „ich orchestriere Claude Code” ist groß — und er wächst.

Wenn du herausfinden willst, welche dieser Techniken sich in deinem Team wirklich lohnen und wie ihr sie sauber einführt, ist ein Gespräch der schnellste Weg.