# Claude Code — KI-Agent für Softwareentwicklung im Terminal

> Anthropics offizieller KI-Agent fürs Terminal: interaktive oder geskriptete Sessions, MCP-Server, Subagenten, Plugins, Worktrees und IDE-Integration.

Source: https://www.jpkc.com/db/cheatsheets/ai-cli/claude-code/

Claude Code ist Anthropics offizielles agentisches Werkzeug zum Programmieren: Es liest, schreibt und führt Code direkt in deinem Terminal aus, gesteuert über den Befehl `claude`. Standardmäßig öffnet es eine interaktive Sitzung im aktuellen Verzeichnis; mit `-p`/`--print` wird daraus ein skriptbares, pipe-freundliches Einmal-Werkzeug. Über die CLI hinaus läuft es auch als Desktop- und Web-App sowie als IDE-Erweiterung und greift auf die aktuellen Claude-Modelle zurück — derzeit Opus 5.5, Sonnet 5.5, Fable 5.1 und Haiku 5.5. Dieser Spickzettel bündelt die Flags, Subkommandos und Slash-Kommandos für den Alltag, von der Sitzungsverwaltung über Hintergrund- und Cloud-Sitzungen und Berechtigungsmodi bis zu MCP-Servern, Subagenten, Plugins und Git-Worktrees. Stand: Oktober 2026, Claude Code 2.1.294 — Claude Code entwickelt sich schnell, ein Blick in `claude --help` und `/help` lohnt sich nach jedem Update.

## Grundlagen

`claude` — Startet eine interaktive Claude-Code-Sitzung im aktuellen Verzeichnis.

```bash
claude
```

`claude "<prompt>"` — Startet eine interaktive Sitzung mit einem initialen Prompt.

```bash
claude "Explain the architecture of this project"
```

`claude --version` — Zeigt die installierte Claude-Code-Version an.

```bash
claude --version
```

`claude --help` — Zeigt alle verfügbaren Optionen und Kommandos an.

```bash
claude --help
```

`claude update` — Prüft auf Updates und installiert die neueste Version, falls verfügbar. Alias: `claude upgrade`

```bash
claude update
```

`claude doctor` — Prüft den Zustand der Installation, ohne eine Sitzung zu starten (liest die Einstellungsdateien im aktuellen Verzeichnis ohne Vertrauensabfrage). Für einen vollständigen Check, der Probleme auch behebt, rufst du in einer Sitzung `/doctor` auf.

```bash
claude doctor
```

`claude install [target]` — Installiert einen bestimmten nativen Build von Claude Code (stable, latest oder eine Versionsnummer). `--force` installiert auch dann neu, wenn er schon vorhanden ist.

```bash
claude install stable
```

`claude purge [path]` — Löscht den gesamten lokalen Claude-Code-Zustand eines Projekts: Transkripte, Aufgabenlisten, Debug-Logs, Bearbeitungsverlauf, Zeilen im Prompt-Verlauf und den Eintrag in `~/.claude.json`. Ohne Pfad öffnet sich eine Auswahlliste; `--dry-run` zeigt vorher, was gelöscht würde, `-i` fragt bei jedem Eintrag nach, `-y` überspringt die Bestätigung, `--all` räumt alle Projekte auf (nicht zusammen mit einem Pfad). Hieß vor v2.1.288 `claude project purge` (der alte Name funktioniert weiter und gibt einen Hinweis aus).

```bash
claude purge --dry-run ~/projects/old-app
```

`claude gateway --config <path>` — Startet das Enterprise-Gateway für Auth und Telemetrie aus einer YAML-Konfiguration.

```bash
claude gateway --config ./gateway.yaml
```

`claude ultrareview [target]` — Startet einen Multi-Agenten-Code-Review des aktuellen Branches (oder einer PR-Nummer / eines Basis-Branches) in der Cloud und gibt die Befunde aus. `--post` veröffentlicht sie als einen Kommentar im PR, `--json` gibt die Rohdaten aus, `--timeout` legt die Wartezeit in Minuten fest (Standard 45). In einer Sitzung nimmst du `/code-review ultra`.

```bash
claude ultrareview 42
```

`claude import [source]` — Übernimmt die Konfiguration eines anderen KI-Coding-Agenten — codex, gemini oder cursor: Anweisungsdateien, MCP-Server, Kommandos, Subagenten und Skills. `--dry-run` zeigt, was übernommen würde, ohne etwas zu schreiben.

```bash
claude import codex --dry-run
```

## Sitzungsverwaltung

`claude -c` — Setzt die letzte Konversation im aktuellen Verzeichnis fort. Lang: --continue

```bash
claude -c
```

`claude -r` — Öffnet eine interaktive Auswahl, um eine frühere Unterhaltung fortzusetzen, optional gefiltert nach einem Suchbegriff. Lang: `--resume`

```bash
claude -r
```

`claude -r <session-id|name>` — Setzt eine bestimmte Unterhaltung direkt über ihre Sitzungs-ID oder ihren Namen fort.

```bash
claude -r "auth-refactor" "Finish this PR"
```

`claude -n <name>` — Gibt der Sitzung einen Anzeigenamen (im Eingabefeld, in der `/resume`-Auswahl und im Terminal-Titel). Später setzt du sie mit `claude --resume <name>` fort. Lang: `--name`

```bash
claude -n "refactor auth module"
```

`claude --fork-session` — Erzeugt beim Fortsetzen eine neue Session-ID, statt die ursprüngliche weiterzuführen.

```bash
claude -c --fork-session
```

`claude --session-id <uuid>` — Verwendet eine bestimmte UUID als Session-ID.

```bash
claude --session-id 550e8400-e29b-41d4-a716-446655440000
```

`claude --from-pr <number>` — Setzt eine Sitzung fort, die mit einem Pull Request verknüpft ist — per Nummer oder URL; ohne Wert öffnet sich eine Auswahl.

```bash
claude --from-pr 42
```

## Hintergrund-Sitzungen

`claude --bg "<prompt>"` — Startet die Sitzung im Hintergrund und kehrt sofort zurück. Gibt die Kurz-ID aus, die `claude attach`, `logs`, `stop` und `rm` erwarten; `claude agents` listet alle Sitzungen. Mit `--resume <session-id>` läuft die genannte Sitzung im Hintergrund weiter. Lang: `--background`

```bash
claude --bg "Run the full test suite and summarize failures"
```

`claude agents` — Öffnet die Agent-Ansicht, in der du parallele Hintergrund-Sitzungen beobachtest und neue startest. In der Ansicht filtert `n:<text>` nach Sitzungsname oder Aufgabe (ab v2.1.287); Ctrl+F findet eine Sitzung über ihren Namen, Enter öffnet den besten Treffer, und Alt+↑/↓ springt zwischen den Gruppen (ab v2.1.288). `--cwd <path>` zeigt nur Sitzungen, die unter diesem Verzeichnis gestartet wurden; `--model`, `--effort` und `--permission-mode` legen die Standards für die Sitzungen fest, die du von dort startest.

```bash
claude agents --cwd ~/projects/app
```

`claude agents --json` — Gibt die aktiven Sitzungen (interaktiv und im Hintergrund) als JSON-Array für Skripte aus; `--all` nimmt auch beendete Hintergrund-Sitzungen auf.

```bash
claude agents --json --all
```

`claude attach <id|name>` — Holt eine Hintergrund-Sitzung in dieses Terminal. Nimmt die Kurz-ID, die `claude --bg` ausgibt und `claude agents` auflistet, oder einen Teil des Sitzungsnamens — Namen mit Leerzeichen setzt du in Anführungszeichen (ab v2.1.290). ← führt zurück in die Agent-Ansicht, Ctrl+Z zurück in die Shell; die Sitzung läuft weiter.

```bash
claude attach "auth refactor"
```

`claude logs <id|name>` — Gibt die letzte Terminal-Ausgabe einer Hintergrund-Sitzung aus. Statt der ID genügt auch ein Teil des Sitzungsnamens — Namen mit Leerzeichen setzt du in Anführungszeichen (ab v2.1.290).

```bash
claude logs auth
```

`claude stop <id>` — Stoppt eine Hintergrund-Sitzung. Die Unterhaltung bleibt erhalten: `claude attach <id>` öffnet sie wieder, und `claude --resume` funktioniert, sobald sie gestoppt ist. Alias: `claude kill`

```bash
claude stop 7c5dcf5d
```

`claude rm <id>` — Löscht eine Hintergrund-Sitzung und, wenn das gefahrlos geht, auch ihren Worktree. Funktioniert auch bei bereits beendeten Sitzungen.

```bash
claude rm 7c5dcf5d
```

`claude respawn <id>` — Startet eine Hintergrund-Sitzung mit erhaltener Unterhaltung neu, damit sie die aktuelle Claude-Code-Version nutzt; `--all` startet alle laufenden Sitzungen neu.

```bash
claude respawn --all
```

`claude --bg --exec '<command>'` — Führt einen Shell-Befehl als Hintergrund-Job mit eigenem Pseudo-Terminal aus, statt eine Claude-Sitzung zu starten.

```bash
claude --bg --exec 'pytest -x'
```

`claude daemon status` — Zeigt zur Diagnose Zustand, Version, Socket-Verzeichnis und Worker-Anzahl des Supervisors, der die Hintergrund-Sitzungen verwaltet.

```bash
claude daemon status
```

`claude daemon stop --any` — Stoppt den Supervisor der Hintergrund-Sitzungen samt der Sitzungen, etwa wenn er hängt; `--keep-workers` lässt die Sitzungen weiterlaufen.

```bash
claude daemon stop --any --keep-workers
```

## Nicht-interaktiver Modus (--print)

`claude -p "<prompt>"` — Gibt die Antwort aus und beendet sich. Nicht-interaktiv für Skripte und Pipes.

```bash
claude -p "What does this function do?" < src/utils.js
```

`echo "<prompt>" | claude -p` — Leitet einen Prompt an Claude weiter und erhält eine einzelne ausgegebene Antwort.

```bash
echo "Summarize this" | claude -p
```

`cat <file> | claude -p "<prompt>"` — Leitet Dateiinhalte als Kontext in einen nicht-interaktiven Prompt.

```bash
cat app.py | claude -p "Find security issues"
```

`claude -p --output-format json "<prompt>"` — Gibt die Antwort als einzelnes JSON-Objekt aus. Formate: text, json, stream-json.

```bash
claude -p --output-format json "List 3 refactoring tips"
```

`claude -p --output-format stream-json --verbose "<prompt>"` — Streamt die Antwort in Echtzeit als zeilengetrennte JSON-Events. Mit `-p` braucht stream-json zusätzlich `--verbose`.

```bash
claude -p --output-format stream-json --verbose "Explain async/await"
```

`claude -p --json-schema '<schema>' "<prompt>"` — Validiert die Ausgabe gegen ein JSON-Schema für strukturierte, maschinenlesbare Antworten.

```bash
claude -p --json-schema '{"type":"object","properties":{"name":{"type":"string"}}}' "Extract info"
```

`claude -p --max-budget-usd <amount> "<prompt>"` — Setzt ein Ausgabenlimit in US-Dollar für diesen Aufruf.

```bash
claude -p --max-budget-usd 0.10 "Summarize these logs"
```

`claude -p --max-turns <n> "<prompt>"` — Begrenzt die Zahl der agentischen Durchläufe; bei Erreichen der Grenze endet der Aufruf mit einem Fehler. Standardmäßig gibt es keine Grenze.

```bash
claude -p --max-turns 5 "Fix the failing test"
```

`claude -p --permission-prompts none "<prompt>"` — Lehnt jede Aktion ab, die eine Berechtigungsabfrage bräuchte, statt auf eine Antwort zu warten; alles andere entscheidet weiter der Berechtigungsmodus. Der Standard `host` schickt die Abfragen an den SDK-Host oder an `--permission-prompt-tool`.

```bash
claude -p --permission-prompts none "Run the linter and fix what it finds"
```

`claude -p --permission-prompt-tool <mcp-tool> "<prompt>"` — Lässt ein MCP-Tool die Berechtigungsabfragen im nicht-interaktiven Modus beantworten.

```bash
claude -p --permission-prompt-tool mcp__approver__check "Deploy to staging"
```

`claude -p --no-session-persistence "<prompt>"` — Speichert die Sitzung nicht auf der Platte (nicht fortsetzbar).

```bash
claude -p --no-session-persistence "Quick question"
```

`claude --fallback-model <models>` — Weicht automatisch auf das angegebene Modell aus, wenn das Standardmodell überlastet oder nicht verfügbar ist. Nimmt eine kommagetrennte Liste, die der Reihe nach probiert wird; das Hauptmodell wird zu Beginn jedes Benutzer-Durchlaufs erneut versucht. Funktioniert auch in interaktiven Sitzungen; dauerhaft über die Einstellung `fallbackModel`.

```bash
claude -p --fallback-model sonnet,haiku "Generate unit tests"
```

`claude -p --input-format stream-json --output-format stream-json --verbose` — Bidirektionales JSON-Streaming für die Anbindung eigener Tools oder Orchestrierer (stream-json-Ausgabe braucht `--verbose`).

```bash
claude -p --input-format stream-json --output-format stream-json --verbose
```

`claude -p --include-partial-messages ...` — Gibt Teile einer Nachricht aus, sobald sie eintreffen (erfordert `--output-format stream-json` und `--verbose`).

```bash
claude -p --output-format stream-json --verbose --include-partial-messages "Explain this"
```

`claude -p --include-hook-events ...` — Nimmt alle Hook-Ereignisse in den Ausgabestrom auf (erfordert `--output-format stream-json` und `--verbose`).

```bash
claude -p --output-format stream-json --verbose --include-hook-events "Run the build"
```

`claude -p --replay-user-messages ...` — Gibt Benutzernachrichten von stdin zur Bestätigung wieder auf stdout aus (stream-json für Ein- und Ausgabe, dazu `--verbose`).

```bash
claude -p --input-format stream-json --output-format stream-json --verbose --replay-user-messages
```

`claude -p --prompt-suggestions "<prompt>"` — Gibt nach jedem Durchlauf eine prompt_suggestion-Nachricht mit dem vermutlich nächsten Prompt aus (erfordert `--output-format stream-json` und `--verbose`; sehr kurze Unterhaltungen liefern mitunter keinen Vorschlag). `--prompt-suggestions=false` schaltet es ab.

```bash
claude -p --output-format stream-json --verbose --prompt-suggestions "Refactor this module"
```

`claude -p --forward-subagent-text ...` — Leitet Text- und Thinking-Blöcke von Subagenten als eigene Nachrichten mit gesetzter `parent_tool_use_id` weiter (erfordert `--output-format stream-json` und `--verbose`).

```bash
claude -p --output-format stream-json --verbose --forward-subagent-text "Audit the codebase"
```

## Modell & Aufwand

`claude --model opus` — Verwendet das neueste Opus — auf der Anthropic API Opus 5.5 (ab v2.1.280). Die Aliase opus, sonnet, haiku und fable zeigen immer auf die empfohlene Version ihrer Reihe; bei anderen Anbietern (Claude Platform on AWS, Amazon Bedrock, Google Clouds Agent Platform, Microsoft Foundry) zeigen einzelne auf ältere Modelle, etwa sonnet auf Sonnet 4.5 oder 4.6 und haiku auf Haiku 4.5.

```bash
claude --model opus
```

`claude --model fable` — Verwendet Claude Fable 5.1 (ab v2.1.257), das leistungsfähigste Modell, für die schwierigsten und längsten Aufgaben. Je nach Tarif kann Fable über Nutzungsguthaben abgerechnet werden.

```bash
claude --model fable
```

`claude --model sonnet` — Verwendet das neueste Sonnet — auf der Anthropic API Sonnet 5.5 (ab v2.1.284), für die tägliche Programmierarbeit.

```bash
claude --model sonnet
```

`claude --model haiku` — Verwendet das neueste Haiku — auf der Anthropic API Haiku 5.5 (ab v2.1.293), das schnellste und kostengünstigste Modell, für einfache Aufgaben; 1M Kontext, Standard-Effort medium. Bei anderen Anbietern zeigt haiku weiterhin auf Haiku 4.5.

```bash
claude --model haiku
```

`claude --model best` — Verwendet das leistungsfähigste Modell, das dir zur Verfügung steht: Fable, wo du Zugriff hast, sonst dasselbe Modell wie opus.

```bash
claude --model best
```

`claude --model opusplan` — Nutzt im Plan-Modus Opus und wechselt für die Umsetzung zu Sonnet.

```bash
claude --model opusplan
```

`claude --model 'opus[1m]'` — Fordert das Kontextfenster von einer Million Tokens ausdrücklich an (entsprechend sonnet[1m]). Nötig nur bei Modellen, die 1M nur über eine `[1m]`-Variante erreichen, etwa Opus 4.6 oder Sonnet 4.6; Opus 4.7+, Sonnet 5+, Haiku 5.5 und Fable laufen auf der Anthropic API und hinter Gateways bereits von Haus aus mit 1M (Opus 4.7+ und Fable seit v2.1.287 auch auf Bedrock, Vertex und Foundry).

```bash
claude --model 'opus[1m]'
```

`claude --model <full-model-id>` — Verwendet ein bestimmtes Modell über seine vollständige ID. Aktuell: `claude-opus-5-5`, `claude-sonnet-5-5`, `claude-fable-5-1`, `claude-haiku-5-5`; ältere wie `claude-opus-5`, `claude-fable-5` oder `claude-haiku-4-5` (fester Snapshot `claude-haiku-4-5-20251001`) bleiben wählbar.

```bash
claude --model claude-opus-5-5
```

`claude --effort <level>` — Setzt das Aufwandsniveau für diese Sitzung: low, medium, high, xhigh, max — welche Stufen gehen, hängt vom Modell ab. `ultracode` startet mit xhigh und eingeschaltetem Ultracode (dynamische Workflows). Wird nicht als Standard gespeichert.

```bash
claude --effort high "Perform a full security audit"
```

`claude --advisor <model>` — Schaltet für diese Sitzung das serverseitige Advisor-Tool ein, das an wichtigen Stellen ein zweites Modell (fable, opus, sonnet oder eine volle ID wie `claude-haiku-5-5`) zurate zieht. Haiku 5.5 kann ab v2.1.293 beraten, Haiku 4.5 nicht.

```bash
claude --advisor opus
```

`claude --autocompact <auto|tokens>` — Legt für diese Sitzung fest, ab welcher Kontextgröße automatisch komprimiert wird — auto oder 100k–1M Tokens —, ohne die gespeicherten Einstellungen zu ändern.

```bash
claude --autocompact 500k
```

## Berechtigungsmodi & Tool-Zugriff

`claude --permission-mode manual` — Manueller Modus: fragt vor jeder Aktion außer Lesezugriffen nach. Sein Konfigurationswert ist `default`, den die CLI ebenfalls akzeptiert. Ohne Flag oder `defaultMode`-Einstellung starten nicht-interaktive Aufrufe (`-p`) und das Agent SDK in diesem Modus.

```bash
claude --permission-mode manual
```

`claude --permission-mode acceptEdits` — Genehmigt Dateiänderungen und gängige Dateisystem-Befehle (`mkdir`, `touch`, `mv`, `cp`, `rm` …) innerhalb der Arbeitsverzeichnisse automatisch; geschützte Pfade und alles außerhalb fragen weiter nach.

```bash
claude --permission-mode acceptEdits
```

`claude --permission-mode plan` — Planmodus: schlägt Änderungen vor, führt sie aber erst nach Freigabe aus.

```bash
claude --permission-mode plan
```

`claude --permission-mode auto` — Auto-Modus: Ein Klassifikator prüft jede Aktion und genehmigt sichere ohne Rückfrage. Seit v2.1.284 starten neue Terminal- und VS-Code-Sitzungen auf allen Plänen und bei allen Anbietern im Auto-Modus, sofern kein Flag oder `defaultMode` etwas anderes vorgibt; wo der Auto-Modus nicht verfügbar ist, starten sie im manuellen Modus. Mit `Shift+Tab` wechselst du zwischen den Modi.

```bash
claude --permission-mode auto
```

`claude --permission-mode dontAsk` — Fragt nie nach: Alles, was eine Freigabe bräuchte, wird automatisch abgelehnt. Lesezugriffe, reine Lesebefehle und Aufrufe, die deine Allow-Regeln treffen, laufen weiter — gedacht für CI mit fester Allowlist.

```bash
claude --permission-mode dontAsk
```

`claude --permission-mode bypassPermissions` — Überspringt die Berechtigungsabfragen; Deny-Regeln und einige Schutzmechanismen (Ask-Regeln, Löschen kritischer Pfade) greifen weiter. Nur für isolierte Sandboxes.

```bash
claude --permission-mode bypassPermissions
```

`claude --dangerously-skip-permissions` — Entspricht `--permission-mode bypassPermissions`: überspringt die Berechtigungsabfragen, Deny-Regeln und einige Schutzmechanismen greifen weiter. Nur für Sandboxes ohne Internetzugang.

```bash
claude --dangerously-skip-permissions
```

`claude --allow-dangerously-skip-permissions` — Macht den Modus „Berechtigungen umgehen" als Opt-in verfügbar, ohne ihn standardmäßig zu aktivieren.

```bash
claude --allow-dangerously-skip-permissions
```

`claude --allowed-tools "<tools>"` — Tools, die ohne Berechtigungsabfrage laufen, auch mit Mustern wie `Bash(git *)`. Welche Tools überhaupt verfügbar sind, legst du mit `--tools` fest.

```bash
claude --allowed-tools "Bash(git *) Edit Read"
```

`claude --disallowed-tools "<tools>"` — Verbotsregeln: Ein bloßer Tool-Name entfernt das Tool ganz, eine eingegrenzte Regel wie `Bash(rm *)` verbietet nur passende Aufrufe.

```bash
claude --disallowed-tools "Bash(rm *) WebFetch"
```

`claude --tools "<tools>"` — Legt fest, welche eingebauten Tools es in der Sitzung gibt: `""` schaltet alle ab, `"default"` stellt den Standardsatz her (unter macOS, Linux und WSL ohne Glob und Grep, außer du nennst sie). MCP-Tools betrifft das nicht.

```bash
claude --tools "Read,Glob,Grep"
```

`claude --add-dir <path>` — Gewährt Tool-Zugriff auf zusätzliche Verzeichnisse über das Arbeitsverzeichnis hinaus.

```bash
claude --add-dir ~/shared-libs --add-dir /etc/nginx
```

`claude --restricted` — Eingeschränkter Modus für geteilte Rechner und Evaluations-Umgebungen: entfernt die eingebauten Tools, die Befehle oder Code ausführen, sowie WebFetch (außer `--tools` nennt sie), ignoriert Benutzer-, Projekt- und lokale Einstellungsdateien, beschränkt die Datei-Tools auf die Arbeitsverzeichnisse und verweigert `bypassPermissions`.

```bash
claude --restricted -p "Review this diff"
```

## System-Prompts & Agenten

`claude --system-prompt "<prompt>"` — Überschreibt den Standard-System-Prompt für diese Sitzung.

```bash
claude --system-prompt "Reply only in German."
```

`claude --append-system-prompt "<prompt>"` — Hängt Anweisungen an den Standard-System-Prompt an, ohne ihn zu ersetzen.

```bash
claude --append-system-prompt "Always use Bootstrap 5."
```

`claude --system-prompt-file <path>` — Lädt die System-Prompt-Überschreibung aus einer Datei statt aus einem Inline-String.

```bash
claude --system-prompt-file ./prompts/reviewer.md
```

`claude --append-system-prompt-file <path>` — Hängt einen aus einer Datei geladenen System-Prompt an den Standard-System-Prompt an.

```bash
claude --append-system-prompt-file ./prompts/house-rules.md
```

`claude --brief` — Aktiviert das SendUserMessage-Tool, damit ein Agent Nachrichten an den Nutzer zurücksenden kann.

```bash
claude --brief
```

`claude --agent <agent-name>` — Führt die Sitzung als benannten Agenten aus — eine Subagent-Definition aus `.claude/agents/`, einem Plugin oder `--agents`. Überschreibt die Einstellung `agent`.

```bash
claude --agent reviewer
```

`claude --agents '<json>'` — Definiert Agenten für die aktuelle Sitzung direkt als JSON; mit `--print` geht auch der Pfad zu einer JSON-Datei.

```bash
claude --agents '{"tester":{"description":"Writes tests","prompt":"Write unit tests only"}}'
```

`claude --bare` — Minimalmodus: überspringt Hooks aus Einstellungen und Plugins, LSP, Plugin-Sync, Attribution, Auto-Memory, Hintergrund-Prefetches, Schlüsselbund-Zugriffe und die Suche nach CLAUDE.md; setzt `CLAUDE_CODE_SIMPLE=1`. Seit v2.1.286 verbindet es nur die MCP-Server, die du auf der Kommandozeile übergibst (`--mcp-config`), schickt dem Modell keine System-Reminder und startet keine Hintergrundaufgaben; ein Shell-Befehl, der sein Timeout erreicht, wird beendet, statt in den Hintergrund zu wechseln. Die Anmeldung bei Anthropic läuft ausschließlich über `ANTHROPIC_API_KEY` oder apiKeyHelper — OAuth und Schlüsselbund werden nie gelesen; Bedrock, Vertex und Foundry nutzen ihre eigenen Zugangsdaten. Kontext gibst du ausdrücklich mit (`--system-prompt[-file]`, `--append-system-prompt[-file]`, `--add-dir`, `--mcp-config`, `--settings`, `--agents`, `--plugin-dir`).

```bash
claude --bare -p "Quick question" --mcp-config ./mcp.json
```

`claude --init-only` — Führt die Setup- und SessionStart-Hooks aus und beendet sich dann, ohne eine Unterhaltung zu starten — praktisch für CI und Container-Images. `--init` und `--maintenance` stoßen die Setup-Hooks vor einer `-p`-Sitzung an.

```bash
claude --init-only
```

`claude --system-prompt-snapshot off` — Baut den System-Prompt bei jeder Anfrage neu auf, statt den zu Beginn der Unterhaltung aufgezeichneten wiederzuverwenden (Standard `on`) — praktisch, solange du am Prompt-Text feilst.

```bash
claude --append-system-prompt "Draft rules" --system-prompt-snapshot off
```

`claude -p --append-subagent-system-prompt "<text>"` — Hängt Text an den System-Prompt jedes Subagenten an (nur im Print-Modus; `--append-subagent-system-prompt-file` liest ihn aus einer Datei).

```bash
claude -p --append-subagent-system-prompt "Answer in German." "Audit the repo"
```

## Interaktive Slash-Kommandos: Sitzung

`/help` — Zeigt Hilfe und verfügbare Kommandos an.

```bash
/help
```

`/clear` — Beginnt eine neue Unterhaltung mit leerem Kontext; mit einem Namen beschriftest du die vorherige in der `/resume`-Auswahl. Aliase: `/reset`, `/new`

```bash
/clear
```

`/compact [instructions]` — Verdichtet die Konversation, um Kontext zu sparen, mit optionalen Fokus-Anweisungen.

```bash
/compact focus on the auth module changes
```

`/context [all]` — Zeigt die aktuelle Kontextnutzung als farbiges Raster; `all` klappt im Vollbild die Aufschlüsselung pro Eintrag auf.

```bash
/context
```

`/resume [session]` — Setzt eine Konversation per ID oder Name fort. Alias: /continue

```bash
/resume
```

`/branch [name]` — Verzweigt die Unterhaltung an dieser Stelle und wechselt in den Zweig; das Original bleibt über `/resume` erreichbar.

```bash
/branch experiment-1
```

`/fork [prompt]` — Kopiert die Unterhaltung in eine neue Hintergrund-Sitzung, während du hier weiterarbeitest; mit einem Prompt legt die Kopie sofort damit los.

```bash
/fork try the alternative approach
```

`/subtask <task>` — Gibt eine Nebenaufgabe an einen abgezweigten Subagenten ab, der die ganze Unterhaltung erbt; sein Ergebnis kommt nach Abschluss in diese Unterhaltung zurück.

```bash
/subtask write tests for the new parser
```

`/background [prompt]` — Koppelt die aktuelle Sitzung ab, damit sie als Hintergrund-Agent weiterläuft, und gibt das Terminal frei. Alias: `/bg`

```bash
/background finish the test suite
```

`/goal [condition|clear]` — Setzt ein Ziel: Claude arbeitet weiter, bis die Bedingung erfüllt ist. Nützlich für lange, autonome Läufe.

```bash
/goal all tests pass and the linter is clean
```

`/cd <path>` — Verschiebt die laufende Sitzung in ein anderes Arbeitsverzeichnis.

```bash
/cd ~/projects/other-repo
```

`/teleport` — Holt eine Cloud-Sitzung samt Branch und Unterhaltung in dieses Terminal. Alias: `/tp`; setzt ein claude.ai-Abo voraus.

```bash
/teleport
```

`/rename [name]` — Benennt die aktuelle Sitzung um; ohne Namen wird einer aus der Unterhaltung erzeugt.

```bash
/rename auth-refactor
```

`/export [filename]` — Exportiert die aktuelle Konversation als reinen Text.

```bash
/export conversation.txt
```

`/recap` — Erzeugt auf Wunsch eine einzeilige Zusammenfassung der aktuellen Sitzung.

```bash
/recap
```

`/stop` — Stoppt die Hintergrund-Sitzung, mit der du verbunden bist; Transkript und Worktree bleiben erhalten. `/exit` trennt nur die Verbindung.

```bash
/stop
```

`/exit` — Beendet die CLI; in einer verbundenen Hintergrund-Sitzung trennt es nur die Verbindung, und die Sitzung läuft weiter. Alias: `/quit`

```bash
/exit
```

## Interaktive Slash-Kommandos: Modell & Tools

`/model [model]` — Wechselt das Modell und speichert es als Standard für neue Sitzungen; in der Auswahl drückst du `s`, um nur für diese Sitzung zu wechseln.

```bash
/model opus
```

`/effort [level|auto|status|ultracode]` — Setzt das Aufwandsniveau: low, medium, high oder xhigh (wird als Standard für dieses Modell gespeichert), max (nur für diese Sitzung) oder auto; `status` zeigt es an. `ultracode [on|off]` schaltet Ultracode — die dynamische Workflow-Orchestrierung — für die Sitzung auf dem aktuellen Niveau ein oder aus.

```bash
/effort ultracode on
```

`/advisor [model|off]` — Schaltet das Advisor-Tool ein, das an wichtigen Stellen ein zweites Modell (fable, opus, sonnet oder eine volle ID wie `claude-haiku-5-5`) um Rat fragt; `off` schaltet es ab. Experimentell, nur über die Anthropic API; fable setzt Fable-Zugang voraus.

```bash
/advisor opus
```

`/fast [on|off]` — Schaltet den Fast Mode um: dasselbe Opus-Modell mit bis zu 2,5-facher Ausgabegeschwindigkeit zu einem höheren Preis pro Token, ohne Wechsel auf ein kleineres Modell. Unterstützt auf Opus 5.5 (Standard für Fast Mode seit v2.1.280), Opus 5 und Opus 4.8; auf Abo-Tarifen wird er ausschließlich über Nutzungsguthaben abgerechnet. Mitten in einer Antwort umgeschaltet, gilt er ab dem nächsten Durchlauf.

```bash
/fast on
```

`/usage` — Zeigt Sitzungskosten, Nutzungslimits des Tarifs und Aktivitätsstatistiken. Aliase: `/cost`, `/stats` (öffnet direkt den Reiter Stats)

```bash
/usage
```

`/permissions` — Verwaltet Erlauben-, Nachfragen- und Verbieten-Regeln, Arbeitsverzeichnisse und die Regeln des Auto-Modus. Alias: `/allowed-tools`

```bash
/permissions
```

`/tasks` — Zeigt und verwaltet die Hintergrundarbeit der aktuellen Sitzung, auch bereits beendete Subagenten. Alias: `/bashes`

```bash
/tasks
```

`/autocompact [auto|<tokens>]` — Legt fest, wie voll das Kontextfenster vor der automatischen Komprimierung werden darf, etwa `500k`, oder `auto`, um zum auf dein Modell abgestimmten Wert zurückzukehren. Wird pro Modell in den Benutzereinstellungen gespeichert (unter `modelSettings`), sodass jedes Modell beim Wechsel seinen eigenen Wert behält (ab v2.1.288).

```bash
/autocompact 500k
```

`/sandbox` — Schaltet den Sandbox-Modus um (nur auf unterstützten Plattformen).

```bash
/sandbox
```

## Interaktive Slash-Kommandos: Code & Git

`/diff` — Öffnet einen interaktiven Diff-Betrachter mit den nicht committeten Änderungen.

```bash
/diff
```

`/rewind` — Setzt Unterhaltung und/oder Code auf einen früheren Stand zurück oder fasst ab einer gewählten Nachricht zusammen. Aliase: `/checkpoint`, `/undo`

```bash
/rewind
```

`/code-review [level] [--fix] [--comment] [target]` — Prüft den aktuellen Diff — oder eine PR-Nummer, einen Branch oder Pfad — auf Fehler. Stufen: low, medium, high, xhigh, max oder ultra (Multi-Agenten-Review in der Cloud, setzt ein claude.ai-Konto voraus; auf Pro/Max 3 Läufe gratis, danach Nutzungsguthaben; `/ultrareview` ist ein Alias). `--fix` wendet die Befunde an, `--comment` veröffentlicht sie im GitHub-PR oder GitLab-Merge-Request; `--max-findings <n>|all` meldet mehr oder weniger Befunde als üblich und bleibt gespeichert, bis du `--max-findings default` angibst (ab v2.1.288).

```bash
/code-review high --max-findings all
```

`/review [level] [--fix] [--comment] [target]` — Alias von `/code-review` mit denselben Stufen, Optionen und Zielen.

```bash
/review 42
```

`/security-review` — Untersucht den Diff zwischen deinem Branch und dem Standard-Branch von origin auf Sicherheitslücken wie Injection, Authentifizierungsfehler und Datenlecks.

```bash
/security-review
```

`/copy [N]` — Kopiert die letzte (oder N-letzte) Antwort in die Zwischenablage; bei Code-Blöcken öffnet sich eine Auswahl, in der `w` die Auswahl in eine Datei schreibt.

```bash
/copy
```

`/btw [question]` — Stellt eine kurze Nebenfrage, ohne sie der Unterhaltung hinzuzufügen; ohne Frage blätterst du durch frühere Nebenantworten.

```bash
/btw what's the syntax for a ternary in PHP?
```

## Interaktive Slash-Kommandos: Konfiguration

`/config [key=value ...]` — Öffnet die Einstellungen (Theme, Modell, Ausgabestil, Editor-Modus und mehr) oder setzt Werte direkt, etwa `/config theme=dark`. Der Vim-Bearbeitungsmodus steckt jetzt hier; `/vim` wurde entfernt. Alias: `/settings`

```bash
/config model=sonnet
```

`/status` — Öffnet die Einstellungen im Reiter Status: Version, Modell, Konto und Verbindung.

```bash
/status
```

`/theme` — Wechselt das Farbschema: auto (folgt dem Terminal-Hintergrund), helle und dunkle Varianten, farbenblindenfreundliche und ANSI-Themes sowie eigene Themes.

```bash
/theme
```

`/color [color|default]` — Setzt die Farbe der Eingabeleiste: red, blue, green, yellow, purple, orange, pink oder cyan; `default` setzt sie zurück, ohne Argument wird zufällig gewählt.

```bash
/color blue
```

`/voice [hold|tap|off]` — Schaltet die Sprachdiktierfunktion um oder wählt einen Modus: hold, tap oder off. Setzt ein Claude.ai-Konto voraus.

```bash
/voice tap
```

`/keybindings` — Öffnet oder erstellt die Konfigurationsdatei für Tastenkürzel.

```bash
/keybindings
```

`/terminal-setup` — Richtet die Zeilenumbruch-Taste für dein Terminal ein: Shift+Enter in VS Code, Cursor, Alacritty oder Zed; Option+Enter im Apple Terminal; Zugriff auf die Zwischenablage in iTerm2.

```bash
/terminal-setup
```

`/tui [default|fullscreen]` — Wählt den Renderer der Terminal-Oberfläche und startet mit erhaltener Unterhaltung neu hinein: `fullscreen` (flackerfreier Vollbild-Renderer, wird als Einstellung `tui` gespeichert — `CLAUDE_CODE_NO_FLICKER=1` bewirkt dasselbe für einen einzelnen Start) oder `default`. Ohne Argument zeigt es den aktiven Renderer an.

```bash
/tui fullscreen
```

`/statusline` — Konfiguriert die Statuszeile von Claude Code (oder übernimmt sie automatisch aus dem Shell-Prompt).

```bash
/statusline
```

`/focus` — Schaltet die Fokus-Ansicht um: nur dein letzter Prompt, eine einzeilige Tool-Zusammenfassung und die Antwort (nur im Vollbild-Renderer).

```bash
/focus
```

`/debug [description]` — Aktiviert das Debug-Logging für die laufende Sitzung und hilft bei der Fehlersuche.

```bash
/debug mcp server keeps disconnecting
```

`/heapdump` — Schreibt einen JavaScript-Heap-Snapshot und eine Speicheraufstellung nach `~/Desktop` (oder ins Home-Verzeichnis), um hohen Speicherverbrauch zu untersuchen. Nicht im Menü — tippe es vollständig; weitergeben solltest du nur die Datei `-diagnostics.json`.

```bash
/heapdump
```

`/memory` — Bearbeitet CLAUDE.md, aktiviert/deaktiviert Auto-Memory, zeigt Auto-Memory-Einträge an.

```bash
/memory
```

`/output-style [style]` — Listet die Ausgabestile auf oder wechselt zu einem.

```bash
/output-style concise
```

`/init` — Richtet das Projekt mit einer CLAUDE.md ein; `CLAUDE_CODE_NEW_INIT=1` startet einen interaktiven Ablauf, der auch Skills, Hooks und persönliche Memory-Dateien abdeckt.

```bash
/init
```

`/hooks` — Zeigt Hook-Konfigurationen für Tool-Events an.

```bash
/hooks
```

`/reload-skills` — Durchsucht die Skill- und Kommando-Verzeichnisse neu, sodass auf der Platte hinzugefügte oder geänderte Skills ohne Neustart verfügbar sind.

```bash
/reload-skills
```

`/add-dir <path>` — Fügt der aktuellen Sitzung ein weiteres Arbeitsverzeichnis hinzu.

```bash
/add-dir ~/other-project
```

## Interaktive Slash-Kommandos: Integrationen

`/mcp [reconnect <server>|enable|disable]` — Verwaltet MCP-Verbindungen und OAuth; `reconnect <server>` oder `enable`/`disable` mit Servername oder `all` wirken, ohne den Dialog zu öffnen.

```bash
/mcp reconnect sentry
```

`/ide` — Verwaltet IDE-Integrationen (VS Code, JetBrains) und zeigt den Status an.

```bash
/ide
```

`/chrome` — Konfiguriert die „Claude in Chrome"-Integration.

```bash
/chrome
```

`/plugin [subcommand]` — Verwaltet Claude-Code-Plugins: ohne Argument das Menü, oder direkt `list`, `install`, `enable`, `disable`.

```bash
/plugin
```

`/reload-plugins [--force]` — Lädt alle aktiven Plugins neu, um ausstehende Änderungen ohne Neustart zu übernehmen; würde der Reload die MCP-Tools ändern und den Prompt-Cache verwerfen, warnt er und bricht ab, außer du gibst `--force` mit.

```bash
/reload-plugins
```

`/skills` — Listet die verfügbaren Skills; tippen filtert, `t` sortiert nach Token-Kosten, und du legst fest, was Claude und das `/`-Menü sehen.

```bash
/skills
```

`/skill-doctor` — Zeigt, was jeder Skill an Kontext kostet und wie oft er genutzt wird — so findest du Skills zum Abschalten.

```bash
/skill-doctor
```

`/agents` — Seit v2.1.198 nur noch ein Hinweis: Bitte Claude, Subagenten anzulegen oder zu verwalten, oder bearbeite `.claude/agents/` bzw. `~/.claude/agents/` direkt.

```bash
/agents
```

`/plan [description]` — Wechselt direkt aus dem Prompt in den Planmodus.

```bash
/plan refactor the authentication module
```

`/schedule [description]` — Legt Routinen an, die in der Cloud laufen, und aktualisiert, listet oder startet sie; setzt ein claude.ai-Abo voraus. Alias: `/routines`

```bash
/schedule
```

`/import [codex|gemini|cursor]` — Übernimmt Anweisungsdateien, MCP-Server, Kommandos, Subagenten und Skills aus OpenAI Codex, Gemini CLI oder Cursor.

```bash
/import cursor
```

`/remote-env` — Wählt die Standard-Cloud-Umgebung für Cloud-Sitzungen, die du aus der CLI startest.

```bash
/remote-env
```

`/web-setup` — Verbindet dein GitHub-Konto für Cloud-Sitzungen über die lokalen Zugangsdaten von `gh`.

```bash
/web-setup
```

`/workflows` — Öffnet die Fortschrittsansicht der Workflows, um laufende und beendete Workflows zu beobachten, anzuhalten, fortzusetzen oder zu speichern.

```bash
/workflows
```

`/artifacts` — Listet deine und mit dir geteilte Artifacts auf; du hängst eins an die Sitzung an, öffnest es im Browser oder kopierst den Link (wo Artifacts verfügbar sind).

```bash
/artifacts
```

`/list-agents` — Listet Subagenten, Teammates und andere Sitzungen, denen Claude Nachrichten schicken kann, jeweils mit dem zu verwendenden Namen (nur mit sitzungsübergreifendem Messaging). Alias: `/peers`

```bash
/list-agents
```

## Interaktive Slash-Kommandos: Konto & Infos

`/login` — Meldet dich bei deinem Anthropic-Konto an.

```bash
/login
```

`/logout` — Meldet dich von deinem Anthropic-Konto ab.

```bash
/logout
```

`/doctor` — Skill: ein Einrichtungs-Check, der Probleme findet und beheben kann — Installation, Einstellungsdateien, ungenutzte Skills, MCP-Server und Plugins, langsame Hooks, Updates; fragt vor jeder Änderung nach. `/doctor prompt-audit` prüft CLAUDE.md und Skills auf veraltete oder widersprüchliche Anweisungen. Alias: `/checkup`

```bash
/doctor
```

`/insights` — Erzeugt einen HTML-Bericht über deine letzten Sitzungen auf diesem Rechner: Projekte, Nutzungsmuster, was schiefgeht und welche Funktionen sich lohnen.

```bash
/insights
```

`/release-notes` — Blättert den Changelog in einer interaktiven Versionsauswahl durch.

```bash
/release-notes
```

`/feedback [report]` — Schickt Feedback oder einen Fehlerbericht: öffnet denselben Einwilligungsdialog wie `/bug`, in dem du festlegst, wie viel Sitzungsverlauf mitgeht. Ohne Argument öffnet es die Warteschlange der Feedback-Entwürfe, die Claude angelegt hat, falls es welche gibt.

```bash
/feedback
```

`/bug [report]` — Meldet einen Fehler oder teilt die Unterhaltung; du wählst, wie viel Sitzungsverlauf mitgeht, und bestätigst vor dem Senden. Ohne Anthropic-Zugangsdaten landet der Bericht unter `~/.claude/feedback-bundles/`. Alias: `/share`

```bash
/bug the diff viewer freezes on large files
```

`/desktop` — Setzt die aktuelle Sitzung in der Desktop-App von Claude Code fort (macOS oder x64-Windows, Claude-Abo). Alias: `/app`

```bash
/desktop
```

`/mobile` — Zeigt einen QR-Code zum Download der mobilen Claude-App an. Aliase: /ios, /android

```bash
/mobile
```

`/remote-control` — Macht die Sitzung über claude.ai fernsteuerbar (setzt ein claude.ai-Abo voraus, nicht mit API-Keys). Alias: `/rc`

```bash
/remote-control
```

`/install-github-app` — Installiert die Claude-GitHub-App für ein Repository, optional samt GitHub-Actions-Workflows und Secrets (nur github.com).

```bash
/install-github-app
```

`/usage-credits` — Richtet Nutzungsguthaben ein oder fordert es bei deinem Admin an, wenn du an ein Limit stößt (früher `/extra-usage`, das weiter funktioniert).

```bash
/usage-credits
```

`/rate-limit-options` — Zeigt, wie du weiterarbeiten kannst, wenn ein Nutzungslimit greift: warten und automatisch fortsetzen, Nutzungsguthaben hinzufügen oder auf einen höheren Tarif wechseln (setzt ein claude.ai-Abo voraus).

```bash
/rate-limit-options
```

`/team-onboarding` — Erzeugt aus deiner Claude-Code-Nutzung der letzten 30 Tage eine Einstiegsanleitung für Teammitglieder.

```bash
/team-onboarding
```

`/powerup` — Stellt Funktionen von Claude Code in kurzen interaktiven Lektionen mit animierten Demos vor.

```bash
/powerup
```

`/upgrade` — Öffnet die Upgrade-Seite für einen höheren Tarif.

```bash
/upgrade
```

`/privacy-settings` — Zeigt und ändert deine Datenschutzeinstellungen (Pro und Max).

```bash
/privacy-settings
```

`/setup-bedrock` — Interaktiver Assistent für Authentifizierung, Region und Modell-Pins bei Amazon Bedrock; erst sichtbar mit `CLAUDE_CODE_USE_BEDROCK=1` (`/setup-vertex` entsprechend für Google Cloud mit `CLAUDE_CODE_USE_VERTEX=1`).

```bash
/setup-bedrock
```

## Gebündelte Skills & Workflows

`/batch <instruction>` — Orchestriert großflächige Änderungen parallel über die Codebasis hinweg.

```bash
/batch replace all deprecated API calls with the v2 equivalent
```

`/loop [interval] [prompt]` — Führt einen Prompt wiederholt aus, solange die Sitzung offen ist. Ohne Intervall bestimmt das Modell den Takt selbst; ohne Prompt läuft der eingebaute Wartungs-Prompt oder deine `loop.md`. Alias: `/proactive`

```bash
/loop 5m check whether the deploy finished
```

`/verify` — Prüft, ob eine Änderung tut, was sie soll: Claude baut, startet und beobachtet die App deines Projekts, statt dass du dich nur auf Tests verlässt (läuft nur, wenn du es aufrufst).

```bash
/verify
```

`/run` — Startet und bedient die App deines Projekts, damit du eine Änderung in Aktion siehst — nicht nur bestandene Tests.

```bash
/run
```

`/run-skill-generator` — Bringt `/run` und `/verify` bei, wie die App deines Projekts gebaut, gestartet und bedient wird, und legt dafür einen Projekt-Skill an.

```bash
/run-skill-generator
```

`/claude-in-chrome [task]` — Lässt Claude über Claude in Chrome eine Aufgabe in deinem Browser erledigen — eine Seite testen, ein Formular ausfüllen, Konsolen-Logs lesen.

```bash
/claude-in-chrome check the signup form for console errors
```

`/simplify [target]` — Vier parallele Review-Agenten suchen nach Wiederverwendung vorhandener Helfer, Vereinfachung, Effizienz und der passenden Abstraktionsebene und wenden die Verbesserungen an. Keine Fehlersuche — dafür gibt es `/code-review`.

```bash
/simplify src/auth/
```

`/update-config [request]` — Du beschreibst eine Einstellungsänderung — einen Befehl erlauben, eine Umgebungsvariable setzen, einen Hook anlegen —, und Claude bearbeitet die passende settings.json.

```bash
/update-config allow npm test without asking
```

`/plugin-authoring [request]` — Lädt die Referenz, nach der Claude einen Mod schreibt: ein Live-Panel, ein Band, eine Statuszeile, einen Toast oder einen Hook in Claude Code, gebaut als Plugin aus Funktions-Hooks, das in der laufenden Sitzung per Hot-Reload neu lädt. Claude lädt sie auch von selbst, wenn du nach einem Mod fragst, und nennt dir seit v2.1.290 den einen Befehl, mit dem andere ihn installieren. Ab v2.1.287; stammt aus einem eingebauten Plugin, das du in `/plugin` abschalten kannst.

```bash
/plugin-authoring a mod that shows the current git branch above the prompt
```

`/claude-api [subcommand]` — Lädt Referenzmaterial zur Claude API und zu Managed Agents für die Sprache deines Projekts; Unterbefehle wie `migrate` oder `cost-optimize` setzen einen Schwerpunkt. Seit v2.1.290 richtet `managed-agents-onboard <url>` das Managed-Agents-Muster, das eine Seite beschreibt, als `ant apply`-Dateien ein, und `managed-agents-onboard <quickstart-name>` baut einen Console-Quickstart wie `deep-researcher` mit der `ant`-CLI.

```bash
/claude-api managed-agents-onboard deep-researcher
```

`/design [brief]` — Entwirft UI-Mockups, Screen-Abläufe oder Landingpages als Artboards auf einer Claude-Design-Leinwand (setzt eine Sitzung mit Artifacts voraus).

```bash
/design a settings screen for a mobile banking app
```

`/slides [brief]` — Erstellt aus deiner Vorgabe eine neue Präsentation als Claude-Slides-Artifact (setzt eine Sitzung mit Artifacts voraus).

```bash
/slides a quarterly review of the platform team
```

`/fewer-permission-prompts` — Wertet deine Transkripte nach häufigen lesenden Bash- und MCP-Aufrufen aus und trägt eine priorisierte Allowlist in die `.claude/settings.json` des Projekts ein.

```bash
/fewer-permission-prompts
```

`/dataviz [request]` — Design-Leitfaden für Diagramme, Graphen und Dashboards.

```bash
/dataviz a bar chart comparing quarterly revenue
```

`/deep-research <question>` — Workflow: verteilt Websuchen, gleicht Quellen ab und schreibt einen Bericht mit Belegen. Setzt das WebSearch-Tool voraus; auf Pro schaltest du Dynamic Workflows vorher in `/config` ein.

```bash
/deep-research how do European accessibility laws differ from WCAG?
```

`/autofix-pr [prompt]` — Startet eine Cloud-Sitzung, die den PR des aktuellen Branches beobachtet und Korrekturen pusht, wenn die CI fehlschlägt oder Reviewer kommentieren (setzt die gh-CLI und Zugang zu Cloud-Sitzungen voraus).

```bash
/autofix-pr
```

## MCP-Server

`claude mcp list` — Listet alle konfigurierten MCP-Server (Model Context Protocol) auf.

```bash
claude mcp list
```

`claude mcp add <name> -- <command> [args...]` — Fügt einen stdio-MCP-Server als Subprozess hinzu.

```bash
claude mcp add my-server -- npx my-mcp-server --port 3000
```

`claude mcp add --transport http <name> <url>` — Fügt einen HTTP/SSE-MCP-Server per URL hinzu.

```bash
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
```

`claude mcp add <name> -e <KEY>=<val> -- <command>` — Fügt einen stdio-MCP-Server mit Umgebungsvariablen hinzu. `-e` gehört hinter den Servernamen: Es nimmt mehrere Paare auf und würde einen direkt folgenden Namen als weiteres Paar lesen.

```bash
claude mcp add my-server -e API_KEY=xxx -- npx -y my-mcp-server
```

`claude mcp add -s <scope> <name> ...` — Legt fest, wo der Server gespeichert wird: `local` (Standard, nur du in diesem Projekt), `project` (geteilt über `.mcp.json`) oder `user` (alle deine Projekte). Lang: `--scope`

```bash
claude mcp add -s user --transport http sentry https://mcp.sentry.dev/mcp
```

`claude mcp add --transport http <name> <url> --header "Authorization: Bearer <token>"` — Fügt einen HTTP-MCP-Server mit eigenem Auth-Header hinzu.

```bash
claude mcp add --transport http api https://api.example.com/mcp --header "Authorization: Bearer xxx"
```

`claude mcp add-json <name> '<json>'` — Fügt einen MCP-Server (stdio, SSE, HTTP oder WebSocket) über einen vollständigen JSON-Konfigurationsstring hinzu.

```bash
claude mcp add-json myserver '{"type":"stdio","command":"npx","args":["my-server"]}'
```

`claude mcp get <name>` — Zeigt die vollständigen Konfigurationsdetails eines bestimmten MCP-Servers an.

```bash
claude mcp get sentry
```

`claude mcp remove <name>` — Entfernt einen konfigurierten MCP-Server.

```bash
claude mcp remove my-server
```

`claude mcp login <name>` — Führt den OAuth-Ablauf eines konfigurierten Servers ohne das `/mcp`-Panel aus (HTTP, SSE und claude.ai-Connectoren); `--no-browser` gibt stattdessen die URL aus, etwa für SSH.

```bash
claude mcp login sentry --no-browser
```

`claude mcp logout <name>` — Löscht die gespeicherten OAuth-Zugangsdaten eines MCP-Servers.

```bash
claude mcp logout sentry
```

`claude mcp add-from-claude-desktop` — Importiert MCP-Server aus der Claude-Desktop-App (nur Mac und WSL).

```bash
claude mcp add-from-claude-desktop
```

`claude mcp serve` — Startet Claude Code selbst als MCP-Server (zur Integration mit anderen Tools).

```bash
claude mcp serve
```

`claude --mcp-config <path>` — Lädt zusätzliche MCP-Server für diese Sitzung aus einer JSON-Konfigurationsdatei.

```bash
claude --mcp-config ~/.config/mcp-servers.json
```

`claude --strict-mcp-config --mcp-config <path>` — Verwendet nur MCP-Server aus der angegebenen Konfiguration und ignoriert alle anderen.

```bash
claude --strict-mcp-config --mcp-config config.json
```

`claude mcp reset-project-choices` — Setzt alle genehmigten/abgelehnten projektbezogenen MCP-Server-Entscheidungen zurück.

```bash
claude mcp reset-project-choices
```

## Authentifizierung

`claude auth login` — Meldet dich bei deinem Anthropic-Konto an (öffnet den Browser). `--console` rechnet über die Anthropic Console statt über ein Claude-Abo ab, `--sso` erzwingt SSO, `--email` füllt die Adresse vor.

```bash
claude auth login
```

`claude auth logout` — Meldet dich vom aktuellen Anthropic-Konto ab.

```bash
claude auth logout
```

`claude auth status` — Zeigt den aktuellen Anmeldestatus und das aktive Konto — standardmäßig als JSON, mit `--text` lesbar.

```bash
claude auth status --text
```

`claude setup-token` — Richtet einen langlebigen Authentifizierungs-Token ein (erfordert ein Claude-Abonnement).

```bash
claude setup-token
```

## Worktrees, IDE & Cloud

`claude -w` — Erstellt für diese Sitzung einen neuen Git-Worktree (isolierter Branch). Lang: --worktree

```bash
claude -w
```

`claude -w <name>` — Erstellt einen benannten Git-Worktree.

```bash
claude -w feature-refactor
```

`claude -w --tmux` — Erstellt einen Worktree und öffnet ihn in einer neuen tmux-Sitzung (native iTerm2-Panes, falls verfügbar; --tmux=classic erzwingt klassisches tmux).

```bash
claude -w --tmux
```

`claude --ide` — Verbindet sich beim Start automatisch mit der IDE, wenn genau eine passende IDE verfügbar ist.

```bash
claude --ide
```

`claude --cloud "<task>"` — Legt eine Cloud-Sitzung für die Aufgabe an; mit einer Sitzungs-ID oder claude.ai/code-URL (und `-p`) stellt es stattdessen eine Nachricht in eine bestehende Sitzung. `--remote` ist ein veralteter Alias.

```bash
claude --cloud "Fix the login bug"
```

`claude --environment <id>` — Legt eine neue Cloud-Sitzung an, die in einer selbst gehosteten Umgebung läuft (IDs beginnen mit `ccpool_`).

```bash
claude -p "Fix the login bug" --environment ccpool_abc123
```

`claude --teleport [session]` — Setzt eine Cloud-Sitzung im lokalen Terminal fort.

```bash
claude --teleport
```

`claude --desktop` — Öffnet die Sitzung in der Claude-Desktop-App statt im Terminal, mit `--continue` oder `--resume <id>` wählst du die Sitzung (ab v2.1.285, nur macOS und x64-Windows, Anmeldung mit Claude-Konto nötig, kein Prompt-Argument).

```bash
claude --desktop --continue
```

`claude --remote-control [name]` — Startet eine interaktive Sitzung mit aktivierter Remote Control (optional benannt), steuerbar über claude.ai. Kurz: `--rc`; setzt ein claude.ai-Abo voraus.

```bash
claude --remote-control "laptop session"
```

`claude --remote-control-session-name-prefix <prefix>` — Setzt den Präfix für automatisch erzeugte Remote-Control-Sitzungsnamen (Standard: Hostname).

```bash
claude --remote-control --remote-control-session-name-prefix laptop
```

`claude remote-control` — Startet einen Remote-Control-Server ohne lokale interaktive Sitzung, um Claude Code von claude.ai oder der Claude-App aus zu steuern.

```bash
claude remote-control
```

## Plugins

`claude plugin list` — Listet alle installierten Plugins auf (`claude plugins` funktioniert als Alias für die ganze Befehlsgruppe).

```bash
claude plugin list
```

`claude plugin install <plugin>` — Installiert ein Plugin aus den verfügbaren Marketplaces; mit `plugin@marketplace` wählst du einen bestimmten. `--marketplace <source>` (owner/repo, Git- oder https-URL oder ein Pfad) installiert den bloßen Plugin-Namen aus diesem Marketplace und trägt den Marketplace bei Bedarf vorher in deine Benutzereinstellungen ein — mit denselben Prüfungen wie `claude plugin marketplace add` (ab v2.1.292). Alias: `i`

```bash
claude plugin install my-plugin --marketplace your-org/claude-plugins
```

`claude plugin enable <plugin>` — Aktiviert ein zuvor deaktiviertes Plugin.

```bash
claude plugin enable my-plugin
```

`/plugin enable cc-plugin-you-should-know@builtin` — Schaltet You should know ein, einen eingebauten Mod: Ein Neben-Agent beobachtet längere Aufgaben und blendet über dem Prompt einen Hinweis ein, wenn er etwas findet, das dir oder Claude entgehen könnte (neu in v2.1.287; standardmäßig aus; für First-Party-Sitzungen mit eingeschalteter Telemetrie, sofern für deine Organisation verfügbar).

```bash
/plugin enable cc-plugin-you-should-know@builtin
```

`claude plugin disable <plugin>` — Deaktiviert ein installiertes Plugin, ohne es zu entfernen.

```bash
claude plugin disable my-plugin
```

`claude plugin update <plugin>` — Aktualisiert ein Plugin auf die neueste Version (Neustart erforderlich).

```bash
claude plugin update my-plugin
```

`claude plugin uninstall <plugin>` — Deinstalliert ein Plugin vollständig. Alias: `remove`

```bash
claude plugin uninstall my-plugin
```

`claude plugin validate <path>` — Prüft ein Plugin- oder Marketplace-Manifest oder die Skills, Agenten und Kommandos in einem Verzeichnis.

```bash
claude plugin validate ./my-plugin/
```

`claude plugin test [dir]` — Führt die Tests eines Mods aus: jede `*.test.ts`/`*.test.tsx` unter dem Ordner (Standard: der aktuelle); ihr Test-Kit importieren die Dateien aus `claude-code/testing`. Läuft aus deiner Shell ohne Sitzung, Anmeldung oder Netzwerk und endet mit Exit-Code 1, wenn ein Test fehlschlägt. Ein Mod ist ein Plugin, dessen JavaScript-/TypeScript-Event-Handler ändern, wie Claude Code aussieht und sich verhält (Mods sind neu in v2.1.287).

```bash
claude plugin test ./my-mod
```

`claude plugin eval [target]` — Führt die Eval-Fälle eines Plugins (`evals/**/case.yaml` oder `prompt.md` + `graders/*.md`) auf deinem Rechner und unter deinem Konto aus und meldet bewertete Ergebnisse, standardmäßig im Vergleich mit einem Lauf ohne Plugin (jeder Fall läuft 3-mal; der HTML-Bericht landet auf claude.ai, außer du gibst `--no-publish` an). Ziel ist ein Pfad, ein Plugin-Name oder `plugin@marketplace`. Bewerte nur Plugins, denen du vertraust; `--trust-plugin` beantwortet die Rückfrage beim ersten Lauf in CI.

```bash
claude plugin eval ./my-plugin
```

`claude plugin init <name>` — Legt ein neues Plugin unter `~/.claude/skills/<name>/` an; ab der nächsten Sitzung lädt es als `<name>@skills-dir`. Alias: `new`

```bash
claude plugin init my-helpers
```

`claude plugin details <name>` — Zeigt die Bestandteile eines Plugins und die voraussichtlichen Token-Kosten.

```bash
claude plugin details my-plugin
```

`claude plugin configure <plugin>` — Zeigt die Optionen eines Plugins und welche davon noch nicht gesetzt sind; `--values-stdin` speichert neue Werte aus stdin (neu in v2.1.285).

```bash
claude plugin configure my-plugin
```

`claude plugin marketplace add <source>` — Fügt einen Marketplace aus einer URL, einem Pfad oder einem GitHub-Repo hinzu; `list`, `update` und `remove` verwalten die eingerichteten.

```bash
claude plugin marketplace add your-org/claude-plugins
```

`claude plugin prune` — Entfernt automatisch installierte Abhängigkeiten, die nicht mehr gebraucht werden. Alias: `autoremove`

```bash
claude plugin prune
```

`claude --plugin-dir <path>` — Lädt ein lokales Plugin-Verzeichnis oder eine .zip nur für diese Sitzung; ein Ordner mit mehreren Plugins lädt jedes davon (mehrfach verwendbar).

```bash
claude --plugin-dir ./my-plugin/ --plugin-dir ./other.zip
```

`claude --plugin-url <url>` — Holt eine Plugin-.zip von einer URL nur für diese Sitzung (wiederholbar).

```bash
claude --plugin-url https://example.com/my-plugin.zip
```

## Auto-Modus

`claude auto-mode config` — Gibt die wirksame Auto-Modus-Konfiguration als JSON aus: deine Einstellungen, wo gesetzt, sonst die Standardwerte.

```bash
claude auto-mode config
```

`claude auto-mode defaults` — Gibt die mitgelieferten Standardregeln des Auto-Modus als JSON aus (environment, allow, soft_deny, hard_deny).

```bash
claude auto-mode defaults
```

`claude auto-mode critique` — Holt KI-Feedback zu deinen eigenen Auto-Modus-Regeln ein.

```bash
claude auto-mode critique
```

`claude auto-mode reset` — Setzt den Auto-Modus auf die mitgelieferten Standards zurück, indem der Abschnitt autoMode aus deiner Benutzereinstellungsdatei entfernt wird; fragt vorher nach, `-y` überspringt die Rückfrage.

```bash
claude auto-mode reset
```

`/auto-mode-setup` — Entwirft `autoMode.environment`-Einträge aus deinem Projekt und den letzten Sitzungen; du prüfst den Entwurf und speicherst ihn in deinen Benutzereinstellungen (Pro-, Max- oder Team-Tarif).

```bash
/auto-mode-setup
```

## Debugging & Diagnose

`claude --debug` — Aktiviert den Debug-Modus: ausführliche Logs, Tool-Aufrufe, API-Anfragen.

```bash
claude --debug
```

`claude --debug=<filter>` — Filtert die Debug-Ausgabe nach Kategorie; `!` schließt eine aus (`--debug='!1p,!file'`). Der Filter greift nur in der `=`-Form — `--debug api,hooks` schaltet den Debug-Modus ohne Filter ein.

```bash
claude --debug=api,hooks
```

`claude --debug-file <path>` — Schreibt Debug-Logs in eine Datei (aktiviert implizit den Debug-Modus).

```bash
claude --debug-file /tmp/claude-debug.log
```

`claude --verbose` — Aktiviert den ausführlichen Ausgabemodus.

```bash
claude --verbose
```

`claude --safe-mode` — Startet mit allen Anpassungen deaktiviert (CLAUDE.md, Skills, installierte Plugins, Hooks, MCP-Server, eigene Kommandos und Agenten, Ausgabestile, Workflows, eigene Themes, Tastenbelegungen), um eine kaputte Konfiguration einzugrenzen. Richtlinien-Einstellungen, Anmeldung, Modellwahl, eingebaute Tools und Plugins sowie Berechtigungen funktionieren weiter. Setzt `CLAUDE_CODE_SAFE_MODE=1`.

```bash
claude --safe-mode
```

`claude --ax-screen-reader` — Gibt screenreader-freundliche Ausgabe aus (flacher Text, keine dekorativen Rahmen oder Animationen).

```bash
claude --ax-screen-reader
```

## Skripting & Automatisierung

`git diff HEAD~1 | claude -p "Summarize these changes"` — Leitet ein git diff an Claude, um eine Commit-Message zu generieren.

```bash
git diff HEAD~1 | claude -p "Write a conventional commit message"
```

`claude -p --output-format json "<prompt>" | jq '.result'` — Leitet die JSON-Ausgabe an jq zur Verarbeitung in Shell-Skripten.

```bash
claude -p --output-format json "Extract function names" | jq '.result'
```

`claude --settings '<json>'` — Lädt Einstellungen aus einem JSON-Dateipfad oder einem Inline-JSON-String.

```bash
claude --settings '{"model":"sonnet","verbose":true}'
```

`claude --setting-sources <sources>` — Steuert, welche Einstellungsquellen geladen werden: user, project, local.

```bash
claude --setting-sources user,project
```

`claude -p --betas <feature> "<prompt>"` — Aktiviert eine Beta-Funktion per API-Header (nur mit API-Key); verwende den exakten, datierten Header-Namen aus der API-Doku.

```bash
claude -p --betas <beta-header-name> "Think step by step"
```

`claude --disable-slash-commands` — Deaktiviert alle Skills für diese Sitzung.

```bash
claude --disable-slash-commands
```

`claude --chrome` — Aktiviert die „Claude in Chrome"-Integration für diese Sitzung.

```bash
claude --chrome
```

`claude --no-chrome` — Deaktiviert die „Claude in Chrome"-Integration für diese Sitzung.

```bash
claude --no-chrome
```

`claude --file <file_id:path>` — Lädt Datei-Ressourcen beim Start herunter. Format: file_id:relativer_pfad (wiederholbar).

```bash
claude --file file_abc:doc.txt --file file_def:img.png
```

`claude --exclude-dynamic-system-prompt-sections` — Verschiebt maschinenspezifische Abschnitte (cwd, Umgebung, Memory-Pfade, Git-Status) in die erste Nutzer-Nachricht, um den Prompt-Cache über Nutzer hinweg besser wiederzuverwenden.

```bash
claude --exclude-dynamic-system-prompt-sections -p "Review"
```

## Umgebungsvariablen

`CLAUDE_CONFIG_DIR=<path> claude` — Verwendet ein eigenes Konfigurationsverzeichnis statt des Standards ~/.claude. Ermöglicht getrennte Konfigurationen für verschiedene Projekte oder Kontexte.

```bash
CLAUDE_CONFIG_DIR=~/.claude-work claude
```

`alias claude-<name>="CLAUDE_CONFIG_DIR=~/.<dir> claude"` — Erstellt Shell-Aliase für verschiedene Claude-Konfigurationen (in .bashrc/.zshrc eintragen).

```bash
alias claude-private="CLAUDE_CONFIG_DIR=~/.claude-private claude"
alias claude-work="CLAUDE_CONFIG_DIR=~/.claude-work claude"
```

`ANTHROPIC_API_KEY=<key> claude` — Setzt den API-Key direkt, statt sich per OAuth anzumelden.

```bash
ANTHROPIC_API_KEY=sk-ant-xxx claude -p "Hello"
```

`ANTHROPIC_MODEL=<model> claude` — Setzt das Modell ohne die Option `--model` — als Alias oder vollständigen Modellnamen.

```bash
ANTHROPIC_MODEL=sonnet claude
```

`ANTHROPIC_DEFAULT_MODEL=<model>` — Legt fest, mit welchem Modell neue Sitzungen standardmäßig starten (ab v2.1.236) — aber nur, wenn weder `--model`, `ANTHROPIC_MODEL` noch ein gespeichertes Modell (etwa per `/model`) greift.

```bash
export ANTHROPIC_DEFAULT_MODEL=opus
```

`ANTHROPIC_DEFAULT_OPUS_MODEL=<model-id>` — Legt fest, worauf der Alias opus zeigt; `ANTHROPIC_DEFAULT_SONNET_MODEL`, `…_HAIKU_MODEL` und `…_FABLE_MODEL` funktionieren genauso. `…_HAIKU_MODEL` bestimmt zusätzlich das Modell für Hintergrundaufgaben (ersetzt das veraltete `ANTHROPIC_SMALL_FAST_MODEL`).

```bash
ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-5 claude
```

`CLAUDE_CODE_DISABLE_1M_CONTEXT=1 claude` — Schaltet die Unterstützung für 1M Kontext ab: `[1m]`-Varianten verschwinden aus der Modellauswahl, und Modelle mit nativem 1M-Fenster (etwa Opus 4.7+, Sonnet 5.5, Fable) werden auf ein 200K-Fenster begrenzt (sie komprimieren bei 200K oder brechen mit dem Kontextlimit-Fehler ab, wenn die automatische Komprimierung aus ist). Das hebt auch den 1M-Standard auf, den Opus 4.7+ und Fable seit v2.1.287 auf Bedrock, Vertex, Foundry und dem Claude-Apps-Gateway haben.

```bash
CLAUDE_CODE_DISABLE_1M_CONTEXT=1 claude --model opus
```

`CLAUDE_CODE_SIMPLE=1 claude` — Minimaler System-Prompt und nur die Tools für Bash, Dateien lesen und Dateien bearbeiten; wird auch von `--bare` gesetzt. Der OAuth-Login wird dabei nicht gelesen — du brauchst `ANTHROPIC_API_KEY` oder einen apiKeyHelper.

```bash
CLAUDE_CODE_SIMPLE=1 claude -p "Quick question"
```

`ANTHROPIC_BASE_URL=<url> claude` — Verwendet einen eigenen API-Endpunkt (Proxy oder kompatibler Anbieter).

```bash
ANTHROPIC_BASE_URL=https://my-proxy.example.com claude
```

`CLAUDE_CODE_OVERLOADED_RETRY_BASE_DELAY_MS=<ms>` — Setzt eine längere Basisverzögerung (ms) für das Backoff, wenn Claude Code eine Anfrage wiederholt, die die API als überlastet (529) abgelehnt hat (ab v2.1.292).

```bash
CLAUDE_CODE_OVERLOADED_RETRY_BASE_DELAY_MS=5000 claude -p "Summarize this repo"
```

`CLAUDE_CODE_DISABLE_STRUCTURED_OUTPUTS=1` — Schickt das Anfragefeld für Structured Outputs (samt Beta-Header) nicht mehr mit — für Mantle oder ein LLM-Gateway, dessen Upstream es ablehnt. Ohne die Variable scheitern dort Sitzungstitel, Memory-Abruf und Prompt-Hooks (ab v2.1.288).

```bash
CLAUDE_CODE_DISABLE_STRUCTURED_OUTPUTS=1 claude
```

`MCP_PROTOCOL_NEGOTIATION=legacy claude` — Hält alle MCP-Server beim bisherigen Handshake, statt die Protokollrevision 2026-07-28 abzufragen, die auf der v2-MCP-Laufzeit standardmäßig bei stdio- und HTTP-Servern angefragt wird (bei stdio seit v2.1.292 auf jeder Installation). Hilft, wenn sich ein älterer Server nicht mehr verbindet. `auto` fragt bei HTTP-Servern, claude.ai-Connectoren und stdio-Servern nach.

```bash
MCP_PROTOCOL_NEGOTIATION=legacy claude
```

`CLAUDE_CODE_WEB_SEARCH_REFILLS_PER_HOUR=<n>` — Legt fest, wie schnell sich das WebSearch-Kontingent einer Sitzung (standardmäßig 200 Aufrufe) wieder auffüllt, in Aufrufen pro Stunde. Standard sind 100 in interaktiven Sitzungen und 0 (kein Auffüllen) bei nicht-interaktiven `-p`-Läufen; `0` schaltet das Auffüllen ab (ab v2.1.290; vorher füllte sich das Kontingent nie wieder auf).

```bash
CLAUDE_CODE_WEB_SEARCH_REFILLS_PER_HOUR=300 claude
```

`DISABLE_AUTOUPDATER=1 claude` — Schaltet die automatischen Hintergrund-Updates ab; ein manuelles `claude update` funktioniert weiter. `DISABLE_UPDATES=1` sperrt beides.

```bash
DISABLE_AUTOUPDATER=1 claude
```

`CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1` — Kehrt nach jedem Bash- oder PowerShell-Befehl der Hauptsitzung ins ursprüngliche Arbeitsverzeichnis zurück.

```bash
CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1 claude
```

`CLAUDE_CODE_NO_FLICKER=1 claude` — Schaltet das Vollbild-Rendering ein (Research Preview): weniger Flackern und gleichbleibender Speicherbedarf in langen Unterhaltungen; wie `/tui fullscreen`.

```bash
CLAUDE_CODE_NO_FLICKER=1 claude
```

## Nützliche Aliase & Tipps

`alias claude-private="CLAUDE_CONFIG_DIR=~/.claude-private claude"` — Eigene Konfiguration für kreative/private Projekte — eigene Einstellungen, Memory und MCP-Server.

```bash
# In ~/.bashrc or ~/.zshrc:
alias claude-private="CLAUDE_CONFIG_DIR=~/.claude-private claude"
```

`alias claude-work="CLAUDE_CONFIG_DIR=~/.claude-work claude"` — Eigene Konfiguration für Arbeitsprojekte — eigener API-Key, Berechtigungen und Agenten.

```bash
# In ~/.bashrc or ~/.zshrc:
alias claude-work="CLAUDE_CONFIG_DIR=~/.claude-work claude"
```

`alias cq='claude -p'` — Kurz-Alias für nicht-interaktive Einmal-Abfragen.

```bash
cq "What's the regex for an email address?"
```

`alias cr='claude -c'` — Kurz-Alias, um die letzte Konversation fortzusetzen.

```bash
cr
```

`alias claude-review='claude -p --model opus "Review this code for bugs and security issues"'` — Vordefinierter Alias für ein Code-Review mit einem bestimmten Modell.

```bash
cat src/auth.py | claude-review
```

`ccommit() { git diff --cached | claude -p "Write a conventional commit message for these staged changes"; }` — Shell-Funktion, die Commit-Messages aus gestageten Änderungen generiert.

```bash
git add -p && ccommit
```

`cexplain() { cat "$1" | claude -p "Explain this file concisely"; }` — Shell-Funktion, um schnell eine beliebige Datei erklären zu lassen.

```bash
cexplain src/config.ts
```

`ultracode` — Stichwort-Auslöser: Steht 'ultracode' im Prompt, läuft diese Aufgabe als dynamischer Workflow, ohne das Aufwandsniveau der Sitzung zu ändern; `Option+W` / `Alt+W` verwirft die Markierung. `/effort ultracode` schaltet das für jede größere Aufgabe der Sitzung ein.

```bash
ultracode: refactor the auth module and add full test coverage
```

`ultrathink` — Stichwort: Steht `ultrathink` im Prompt, denkt Claude in diesem Durchlauf gründlicher nach, ohne das Aufwandsniveau zu ändern.

```bash
ultrathink: why does this race condition only show up under load?
```

## Tastenkürzel (interaktive Sitzung)

`Enter` — Sendet den aktuellen Prompt ab (konfigurierbar in /keybindings).

```bash
Type your prompt and press Enter to send
```

`Shift+Enter` — Fügt einen Zeilenumbruch ein, ohne abzuschicken — nativ in iTerm2, WezTerm, Ghostty, Kitty, Warp, Apple Terminal und Windows Terminal; anderswo `\`+Enter oder Ctrl+J, oder du führst `/terminal-setup` aus (VS Code, Cursor, Alacritty, Zed).

```bash
Write multi-line prompts with Shift+Enter
```

`Ctrl+Enter` — Jetzt senden: Schickt deine eingereihten Nachrichten samt Entwurf ab, ohne zu warten (ab v2.1.275). Laufende Shell-Befehle und Subagenten wechseln in den Hintergrund und laufen weiter (ab v2.1.281); schreibt Claude gerade nur, wird der Durchlauf unterbrochen. `Ctrl+X Ctrl+S` tut dasselbe in Terminals, die Ctrl+Enter nicht melden.

```bash
Type a correction mid-turn and press Ctrl+Enter
```

`Ctrl+C` — Unterbricht einen laufenden Vorgang; läuft nichts, leert der erste Druck die Eingabe und der zweite beendet Claude Code. Mit Up bei leerem Prompt holst du einen geleerten Entwurf zurück, samt eingefügtem Text und Bildern (ab v2.1.288; seit v2.1.292 auch nach einem Slash-Kommando oder einer abgeschickten Nachricht).

```bash
Press Ctrl+C, then Up to restore the draft
```

`Escape` — Unterbricht Claude mitten in der Antwort (bisherige Arbeit bleibt erhalten) oder schließt einen Dialog.

```bash
Press Escape to stop and redirect Claude
```

`Escape Escape` — Leert den Eingabeentwurf (er landet im Verlauf) oder öffnet bei leerer Eingabe das Rewind-Menü.

```bash
Press Escape twice to rewind to an earlier point
```

`Shift+Tab` — Wechselt reihum zwischen den Berechtigungsmodi: Manual, acceptEdits, plan und, wo verfügbar, bypassPermissions und auto.

```bash
Press Shift+Tab until the mode indicator shows plan
```

`Ctrl+R` — Durchsucht den Prompt-Verlauf rückwärts.

```bash
Press Ctrl+R and type part of an earlier prompt
```

`Ctrl+O` — Blendet die Transkript-Ansicht mit allen Tool-Aufrufen ein und aus.

```bash
Press Ctrl+O to see what a tool call did
```

`Ctrl+T` — Blendet Claudes To-do-Checkliste im Statusbereich ein und aus (laufende Shells und Subagenten zeigt `/tasks`).

```bash
Press Ctrl+T to see Claude's task list
```

`Ctrl+B` — Schickt laufende Bash-Befehle und Agenten in den Hintergrund (in tmux zweimal drücken).

```bash
Press Ctrl+B while a long test run is going
```

`Ctrl+X Ctrl+K` — Stoppt alle laufenden Hintergrund-Subagenten dieser Sitzung (zum Bestätigen zweimal innerhalb von 3 Sekunden drücken). Funktioniert auch, während die Berechtigungsabfrage eines Hintergrund-Subagenten offen ist; seit v2.1.290 zeigen diese Abfragen das Tastenkürzel an.

```bash
Press Ctrl+X Ctrl+K twice to stop every background agent
```

`Ctrl+G` — Öffnet den Prompt in deinem Standard-Texteditor.

```bash
Press Ctrl+G to write a long prompt in your editor
```

`Ctrl+S` — Parkt den Prompt: Steht Text in der Eingabe, wird er gespeichert und die Eingabe geleert; drückst du erneut bei leerem Prompt, kommt er zurück — samt Cursorposition, eingefügten Inhalten und Shell-Modus.

```bash
Press Ctrl+S to park a half-written prompt and ask something else first
```

`Ctrl+V` — Fügt ein Bild aus der Zwischenablage als `[Image #N]`-Chip an der Cursorposition ein (`Cmd+V` in iTerm2, `Alt+V` unter Windows; unter WSL nimmst du `Alt+V`, wenn das Terminal Ctrl+V abfängt).

```bash
Press Ctrl+V to paste a screenshot into the prompt
```

`Alt+P / Option+P` — Wechselt das Modell, ohne den Prompt zu löschen.

```bash
Press Alt+P (Option+P on macOS) to pick another model
```

`Alt+O / Option+O` — Schaltet den Fast Mode um.

```bash
Press Alt+O (Option+O on macOS) to toggle fast mode
```

`Up / Down Arrow` — Navigiert durch den Prompt-Verlauf.

```bash
Press Up to recall previous prompts
```

`/` — Öffnet die Autovervollständigung für Slash-Kommandos. Tippen zum Filtern.

```bash
Type / to see all available commands
```

`!` — Am Anfang des Prompts: Shell-Modus — führt einen Befehl direkt aus und nimmt seine Ausgabe in die Sitzung auf.

```bash
!git status
```

`@` — Erwähnt einen Dateipfad mit Autovervollständigung.

```bash
Explain @src/utils/date.ts
```

## Fazit

Claude Code belohnt eine durchdachte Einrichtung: Sichere riskante Operationen über die Berechtigungsmodi ab — interaktive Sitzungen starten inzwischen, wo verfügbar, im Auto-Modus, mit `Shift+Tab` oder `--permission-mode manual` holst du dir die Rückfragen zurück —, halte `--dangerously-skip-permissions` ausschließlich für Wegwerf-Sandboxes zurück und setze auf `-p` plus `--output-format json`, wenn du das Tool in Skripte und CI einbindest. Hast du den Umgang mit Sitzungen, Agenten und MCP-Servern erst verinnerlicht, skaliert dieselbe Binary von der schnellen Einmal-Frage bis zum langlaufenden, mehrstufigen Refactoring. Nimm die Flags hier als Ausgangspunkt und wirf zwischen den Releases einen Blick in die offizielle Doku nach neuen Kommandos.

## Weiterführende Links

- [Claude-Code-Dokumentation](https://code.claude.com/docs/de/overview) – offizielle Anthropic-Anleitung zu Installation, Konfiguration, Slash-Kommandos, Hooks und MCP
- [Kommando-Referenz](https://code.claude.com/docs/de/commands) – vollständige Liste der eingebauten Slash-Kommandos und gebündelten Skills
- [CLI-Referenz](https://code.claude.com/docs/de/cli-reference) – alle Befehle und Optionen der Kommandozeile
- [Modell-Konfiguration](https://code.claude.com/docs/de/model-config) – Aliase, Modellversionen je Anbieter und Umgebungsvariablen zur Modellwahl
- [anthropics/claude-code auf GitHub](https://github.com/anthropics/claude-code) – Issue-Tracker, Release-Notes und Referenzmaterial (englisch)