# 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/

<!-- PROSE:intro -->
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 — Fable 5 und die Claude-4.x-Familie (Opus 4.8, Sonnet 4.6, Haiku 4.5). Dieser Spickzettel bündelt die Flags, Subkommandos und Slash-Kommandos für den Alltag, von der Sitzungsverwaltung über Berechtigungsmodi bis zu MCP-Servern, Subagenten, Plugins und Git-Worktrees.
<!-- PROSE:intro:end -->

## 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.

```bash
claude update
```

`claude doctor` — Prüft den Zustand der Claude-Code-Installation und des Auto-Updaters.

```bash
claude doctor
```

`claude install <target>` — Installiert einen bestimmten nativen Claude-Code-Build (stable, latest oder Versionsnummer).

```bash
claude install stable
```

`claude project` — Verwaltet den Projektzustand von Claude Code.

```bash
claude project
```

`claude ultrareview [target]` — Führt ein cloud-gehostetes Multi-Agenten-Code-Review des aktuellen Branches (oder einer PR-Nummer / eines Basis-Branches) aus und gibt die Ergebnisse aus.

```bash
claude ultrareview 42
```

## Sitzungsverwaltung

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

```bash
claude -c
```

`claude -r` — Öffnet einen interaktiven Auswähler, um eine frühere Konversation fortzusetzen. Lang: --resume

```bash
claude -r
```

`claude -r <session-id>` — Setzt eine bestimmte Konversation direkt über ihre Session-ID fort.

```bash
claude -r a1b2c3d4-...
```

`claude -n <name>` — Vergibt einen Anzeigenamen für diese Sitzung (erscheint in /resume und im Terminal-Titel).

```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 00000000-0000-0000-0000-000000000001
```

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

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

## 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 "<prompt>"` — Streamt die Antwort als zeilengetrennte JSON-Chunks in Echtzeit.

```bash
claude -p --output-format stream-json "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 --no-session-persistence "<prompt>"` — Speichert die Sitzung nicht auf der Platte (nicht fortsetzbar).

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

`claude -p --fallback-model sonnet "<prompt>"` — Wechselt automatisch zum angegebenen Modell, falls das Standardmodell überlastet ist.

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

`claude -p --input-format stream-json --output-format stream-json` — Bidirektionales JSON-Streaming für die Integration mit eigenen Tools oder Orchestratoren.

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

`claude -p --include-partial-messages ...` — Gibt Teil-Nachrichten-Chunks aus, sobald sie eintreffen (erfordert --output-format stream-json).

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

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

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

`claude -p --replay-user-messages ...` — Gibt Nutzer-Nachrichten von stdin zur Bestätigung auf stdout zurück (nur stream-json ein- und ausgangsseitig).

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

`claude -p --prompt-suggestions "<prompt>"` — Gibt nach jedem Zug eine prompt_suggestion-Nachricht aus, die den nächsten Nutzer-Prompt vorhersagt.

```bash
claude -p --prompt-suggestions "Refactor this module"
```

## Modell & Aufwand

`claude --model opus` — Verwendet Claude Opus (am leistungsfähigsten). Akzeptiert Aliase: opus, sonnet, haiku.

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

`claude --model sonnet` — Verwendet Claude Sonnet (ausgewogen zwischen Geschwindigkeit und Leistung).

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

`claude --model haiku` — Verwendet Claude Haiku (am schnellsten, am kostengünstigsten).

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

`claude --model <full-model-id>` — Verwendet ein bestimmtes Modell über seine vollständige ID.

```bash
claude --model claude-opus-4-8
```

`claude --effort <level>` — Setzt das Aufwandsniveau: low, medium, high, xhigh, max. Höher = gründlicher, aber langsamer.

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

## Berechtigungsmodi & Tool-Zugriff

`claude --permission-mode default` — Normalmodus: fragt bei potenziell gefährlichen Aktionen nach Bestätigung.

```bash
claude --permission-mode default
```

`claude --permission-mode acceptEdits` — Akzeptiert alle Dateiänderungen automatisch ohne Nachfrage.

```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: klassifiziert Aktionen und gibt sichere automatisch frei.

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

`claude --permission-mode dontAsk` — Fragt nicht nach Berechtigungen; überspringt Aktionen, die eine Freigabe bräuchten, stillschweigend, statt sie auszuführen.

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

`claude --permission-mode bypassPermissions` — Umgeht alle Berechtigungsprüfungen. Nur für isolierte Sandboxes.

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

`claude --dangerously-skip-permissions` — Umgeht alle Berechtigungsprüfungen (entspricht dem Modus bypassPermissions). 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>"` — Beschränkt Claude auf bestimmte Tools. Unterstützt Subkommando-Muster.

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

`claude --disallowed-tools "<tools>"` — Blockiert bestimmte Tools, erlaubt aber alle übrigen.

```bash
claude --disallowed-tools "Bash Write"
```

`claude --tools "<tools>"` — Legt die verfügbaren eingebauten Tools fest. "" deaktiviert alle, "default" aktiviert alle.

```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
```

## 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>` — Verwendet einen benannten, in den Einstellungen konfigurierten Agenten.

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

`claude agents` — Listet alle konfigurierten Agenten aus Nutzer-, Projekt- und lokalen Einstellungen auf.

```bash
claude agents
```

`claude --agents '<json>'` — Definiert Inline-Agenten als JSON für die aktuelle Sitzung.

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

`claude --bare` — Minimalmodus: überspringt Hooks, LSP, Plugins, Auto-Memory und CLAUDE.md-Erkennung.

```bash
claude --bare -p "Quick question"
```

## Interaktive Slash-Kommandos: Sitzung

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

```bash
/help
```

`/clear` — Löscht den Konversationsverlauf und gibt Kontext frei. 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` — Visualisiert die aktuelle Kontextnutzung als farbiges Raster.

```bash
/context
```

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

```bash
/resume
```

`/branch [name]` — Erzeugt an dieser Stelle einen Branch der aktuellen Konversation. Alias: /fork

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

`/rename [name]` — Benennt die aktuelle Sitzung um.

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

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

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

`/exit` — Beendet die CLI. Alias: /quit

```bash
/exit
```

## Interaktive Slash-Kommandos: Modell & Tools

`/model [model]` — Wählt oder wechselt das KI-Modell mitten in der Sitzung.

```bash
/model opus
```

`/effort [level]` — Setzt das Aufwandsniveau: low, medium, high, xhigh, max, auto.

```bash
/effort high
```

`/fast [on|off]` — Schaltet den Schnellmodus um (gleiches Modell, schnellere Ausgabe).

```bash
/fast on
```

`/cost` — Zeigt die Token-Nutzungsstatistik der aktuellen Sitzung an.

```bash
/cost
```

`/usage` — Zeigt die Nutzungslimits des Tarifs und den Rate-Limit-Status an.

```bash
/usage
```

`/permissions` — Zeigt oder aktualisiert Berechtigungen. Alias: /allowed-tools

```bash
/permissions
```

`/tasks` — Listet und verwaltet Hintergrund-Tasks.

```bash
/tasks
```

## Interaktive Slash-Kommandos: Code & Git

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

```bash
/diff
```

`/rewind` — Spult Konversation und Code auf einen früheren Stand zurück. Alias: /checkpoint

```bash
/rewind
```

`/pr-comments [PR]` — Holt und zeigt Kommentare aus einem GitHub-Pull-Request an.

```bash
/pr-comments 42
```

`/security-review` — Analysiert ausstehende Änderungen im aktuellen Branch auf Sicherheitslücken.

```bash
/security-review
```

`/copy [N]` — Kopiert die letzte (oder N-letzte) Assistenten-Antwort in die Zwischenablage.

```bash
/copy
```

`/btw <question>` — Stellt eine kurze Nebenfrage, ohne sie zum Konversationskontext hinzuzufügen.

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

## Interaktive Slash-Kommandos: Konfiguration

`/config` — Öffnet die Einstellungsoberfläche (Theme, Modell, Ausgabestil). Alias: /settings

```bash
/config
```

`/status` — Zeigt Version, Modell, Konto und Verbindungsstatus an.

```bash
/status
```

`/theme` — Ändert das Farbschema (hell/dunkel, farbenblind-tauglich, ANSI).

```bash
/theme
```

`/color [color]` — Setzt die Farbe der Prompt-Leiste (rot, blau, grün, gelb, lila usw.).

```bash
/color blue
```

`/vim` — Schaltet zwischen Vim- und Normal-Editiermodus um.

```bash
/vim
```

`/voice` — Schaltet die Push-to-Talk-Sprachdiktierung um.

```bash
/voice
```

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

```bash
/keybindings
```

`/terminal-setup` — Richtet Terminal-Tastenkürzel für Shift+Enter und andere Shortcuts ein.

```bash
/terminal-setup
```

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

```bash
/statusline
```

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

```bash
/memory
```

`/init` — Initialisiert das Projekt mit einer CLAUDE.md-Anleitung.

```bash
/init
```

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

```bash
/hooks
```

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

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

## Interaktive Slash-Kommandos: Integrationen

`/mcp` — Verwaltet MCP-Server-Verbindungen und OAuth-Authentifizierung.

```bash
/mcp
```

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

```bash
/ide
```

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

```bash
/chrome
```

`/plugin` — Verwaltet Claude-Code-Plugins.

```bash
/plugin
```

`/skills` — Listet verfügbare Skills (eigene Slash-Kommandos) auf.

```bash
/skills
```

`/agents` — Verwaltet Agenten-Konfigurationen.

```bash
/agents
```

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

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

`/schedule [description]` — Erstellt, aktualisiert, listet oder startet geplante Cloud-Tasks (Trigger).

```bash
/schedule
```

## 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` — Diagnostiziert und prüft Claude-Code-Installation und -Einstellungen.

```bash
/doctor
```

`/stats` — Visualisiert tägliche Nutzung, Sitzungsverlauf, Streaks und Modellpräferenzen.

```bash
/stats
```

`/insights` — Erstellt einen Bericht, der deine Claude-Code-Sitzungen analysiert.

```bash
/insights
```

`/release-notes` — Zeigt das vollständige Changelog mit den neuesten Versionen zuerst an.

```bash
/release-notes
```

`/feedback [report]` — Sendet Feedback zu Claude Code. Alias: /bug

```bash
/feedback
```

`/desktop` — Setzt die aktuelle Sitzung in der Claude-Code-Desktop-App fort. Alias: /app

```bash
/desktop
```

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

```bash
/mobile
```

`/remote-control` — Gibt die Sitzung zur Fernsteuerung über claude.ai frei. Alias: /rc

```bash
/remote-control
```

`/install-github-app` — Richtet die Claude-GitHub-Actions-App für ein Repository ein.

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

`/extra-usage` — Konfiguriert zusätzliche Nutzung, um bei erreichten Rate-Limits weiterarbeiten zu können.

```bash
/extra-usage
```

## 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 -e <KEY>=<val> <name> -- <command>` — Fügt einen stdio-MCP-Server mit Umgebungsvariablen hinzu.

```bash
claude mcp add -e GITHUB_TOKEN=ghp_xxx github -- npx @modelcontextprotocol/server-github
```

`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 mit einem 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 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 für OAuth).

```bash
claude auth login
```

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

```bash
claude auth logout
```

`claude auth status` — Zeigt den aktuellen Authentifizierungsstatus und das aktive Konto an.

```bash
claude auth status
```

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

```bash
claude setup-token
```

## Worktrees & IDE

`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 einer offenen IDE (VS Code, JetBrains).

```bash
claude --ide
```

`claude --remote-control [name]` — Startet eine interaktive Sitzung mit aktivierter Fernsteuerung (optional benannt) zur Steuerung über claude.ai.

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

## Plugins

`claude plugin list` — Listet alle installierten Plugins auf.

```bash
claude plugin list
```

`claude plugin install <plugin>` — Installiert ein Plugin aus dem Marketplace.

```bash
claude plugin install my-plugin
```

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

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

`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.

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

`claude plugin validate <path>` — Validiert ein lokales Plugin oder ein Marketplace-Manifest.

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

`claude --plugin-dir <path>` — Lädt ein lokales Plugin-Verzeichnis oder eine .zip nur für diese Sitzung (wiederholbar).

```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 effektive Auto-Modus-Konfiguration als JSON aus.

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

`claude auto-mode defaults` — Gibt die Standard-Allow/Deny-Regeln des Auto-Modus als JSON aus.

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

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

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

## 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. Mit ! als Präfix ausschließen.

```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
```

## 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 ein Beta-Feature per Header (nur für API-Key-Nutzer).

```bash
claude -p --betas interleaved-thinking-2025-05-14 "Think step by step"
```

`claude --disable-slash-commands` — Deaktiviert alle Slash-Kommando-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"
```

`CLAUDE_MODEL=<model> claude` — Setzt das Standardmodell ohne den Schalter --model.

```bash
CLAUDE_MODEL=claude-sonnet-4-6 claude
```

`CLAUDE_CODE_SIMPLE=1 claude` — Vereinfachter Modus (wie --bare): überspringt Hooks, LSP, Plugins, Auto-Memory.

```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
```

`DISABLE_AUTOUPDATE=1 claude` — Deaktiviert die automatische Update-Prüfung beim Start.

```bash
DISABLE_AUTOUPDATE=1 claude
```

`CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1` — Setzt das Arbeitsverzeichnis des Bash-Tools zwischen Befehlen immer auf das Projektstammverzeichnis zurück.

```bash
CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=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
```

## 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 abzusenden (erfordert /terminal-setup).

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

`Ctrl+C` — Bricht die aktuelle Operation oder Generierung ab.

```bash
Press Ctrl+C to stop a long response
```

`Escape` — Bricht ab oder geht in Menüs und Auswählern zurück.

```bash
Press Escape to close the session picker
```

`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
```

<!-- PROSE:outro -->
## Fazit

Claude Code belohnt eine durchdachte Einrichtung: Sichere riskante Operationen über die Berechtigungsmodi ab, 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://docs.claude.com/en/docs/claude-code/overview) – offizielle Anthropic-Anleitung zu Installation, Konfiguration, Slash-Kommandos, Hooks und MCP (englisch)
- [anthropics/claude-code auf GitHub](https://github.com/anthropics/claude-code) – Issue-Tracker, Release-Notes und Referenzmaterial (englisch)
<!-- PROSE:outro:end -->