Zum Hauptinhalt springen

Claude Code Guide

Claude Code Guide

FĂŒr Updates und BeitrĂ€ge besuche die offizielle Claude Code Dokumentation

Claude Code Status License

AbschnittStatusWeitere Ressourcen
Einstieg✅ Claude-Code Changelogs
Konfiguration & Umgebungsvariablen✅Claude-Code via Discord
Befehle & Nutzung✅Security Agents SKILL.md
OberflĂ€che & Eingabe✅Agent erstellt SKILL.md
Erweiterte Funktionen✅954+ Agent Skills
Automatisierung & Integration✅Kostenlose KI-Ressourcen
Hilfe & Fehlerbehebung✅250+ Mermaid-Vorlagen
Drittanbieter-Integrationen✅Discord Communication MCP

Inhalt

Schnelllinks: Installation · Befehle · TastaturkĂŒrzel · MCP · Fehlerbehebung

Einstieg

Ton-Benachrichtigungen aktivieren, wenn Claude eine Aufgabe abgeschlossen hat:

claude config set --global preferredNotifChannel terminal_bell

Schnellstart

[!TIP] claude oder npx claude im Terminal eingeben, um die OberflÀche zu starten

Zur Hilfe & Fehlerbehebung bei Problemen...

# Native Installation (empfohlen — kein Node.js erforderlich) ⭐
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Windows
/* Via CMD (nativ)       */ curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
/* Via Powershell        */ irm https://claude.ai/install.ps1 | iex
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# macOS / Linux / WSL
/* Via Terminal          */ curl -fsSL https://claude.ai/install.sh | bash
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Arch
/* Via Terminal          */ yay -S claude-code*/
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

# Alternative (npm) — zugunsten des nativen Installers veraltet
# Erfordert Node.js 18+
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Windows
/* Via CMD (npm)         */ npm install -g @anthropic-ai/claude-code
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# macOS
/* Via Terminal          */ brew install node && npm install -g @anthropic-ai/claude-code
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Linux
/* Via Terminal          */ sudo apt update && sudo apt install -y nodejs npm
/* Via Terminal          */ npm install -g @anthropic-ai/claude-code
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# WSL/GIT
/* Via Terminal          */ npm install -g @anthropic-ai/claude-code
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Docker
/* Windows (CMD)         */ docker run -it --rm -v "%cd%:/workspace" -e ANTHROPIC_API_KEY="sk-your-key" node:20-slim bash -lc "npm i -g @anthropic-ai/claude-code && cd /workspace && claude"
/* macOS/Linux (bash/zsh)*/ docker run -it --rm -v "$PWD:/workspace" -e ANTHROPIC_API_KEY="sk-your-key" node:20-slim bash -lc 'npm i -g @anthropic-ai/claude-code && cd /workspace && claude'
/* Kein bash Fallback    */ docker run -it --rm -v "$PWD:/workspace" -e ANTHROPIC_API_KEY="sk-your-key" node:20-slim sh -lc 'npm i -g @anthropic-ai/claude-code && cd /workspace && claude'
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# PrĂŒfen ob claude korrekt installiert ist
/* Linux                 */ which claude
/* Windows               */ where claude
/* Universal             */ claude --version
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# HĂ€ufige Verwaltungsbefehle
/*claude config          */ Einstellungen konfigurieren
/*claude mcp list        */ MCP-Server einrichten, "list" durch add/remove ersetzen
/*claude /agents         */ Subagenten fĂŒr verschiedene Aufgaben konfigurieren
/*claude update          */ Auf neueste Version aktualisieren

[!Tip] Projekt ĂŒber Terminal in VS Code / Cursor öffnen

$ - cd /path/to/project​

$ - code .​

Stelle sicher, dass die (Claude Code Erweiterung) in VS Code / Cursor installiert ist

Systemanforderungen

  • Betriebssystem: macOS 10.15+, Ubuntu 20.04+/Debian 10+, oder Windows 10/11 oder WSL
  • Hardware: Mindestens 4 GB RAM, 8 GB+ empfohlen
  • Software: Node.js 18+ oder git 2.23+ (optional) & GitHub oder GitLab CLI fĂŒr PR-Workflows (optional)
  • Node.js wird nur fĂŒr die npm-basierte Installation benötigt. Der native Installer bringt seine eigene Runtime mit.
  • Internet: Verbindung fĂŒr API-Aufrufe
  • Node.js 18+ (nur fĂŒr npm-basierte Installation erforderlich; der native Installer bringt seine eigene Runtime mit)

Ersteinrichtung

[!Tip] API-SchlĂŒssel in der Anthropic Console finden

KEINE echten SchlĂŒssel committen — git-ignorierte Dateien, OS-SchlĂŒsselspeicher oder Secret-Manager verwenden

# Universal
/* Login starten                      */ claude /login
/* Langlebigen Auth-Token einrichten  */ claude setup-token
/* Via Anthropic-Konto authentifizieren */ claude auth login
----------------------------------------------------------------------------------------------------------------------------------
# Windows
/* API-SchlĂŒssel setzen   */ set ANTHROPIC_API_KEY=sk-your-key-here-here
/* Maskierte PrĂŒfung      */ echo OK: %ANTHROPIC_API_KEY:~0,8%***
/* Dauerhaft setzen       */ setx ANTHROPIC_API_KEY "sk-your-key-here-here"
/* SchlĂŒssel entfernen    */ set ANTHROPIC_API_KEY=
----------------------------------------------------------------------------------------------------------------------------------
# Linux
/* API-SchlĂŒssel setzen   */ export ANTHROPIC_API_KEY="sk-your-key-here-here"
/* Maskierte PrĂŒfung      */ echo "OK: ${ANTHROPIC_API_KEY:0:8}***"
/* Sitzung entfernen      */ unset ANTHROPIC_API_KEY
----------------------------------------------------------------------------------------------------------------------------------
# Powershell
/* Sitzung               */ $env:ANTHROPIC_API_KEY = "sk-your-key-here-here"
/* Maskierte PrĂŒfung     */ "OK: $($env:ANTHROPIC_API_KEY.Substring(0,8))***"
/* Dauerhaft             */ [Environment]::SetEnvironmentVariable("ANTHROPIC_API_KEY","sk-your-key-here-here","User")
/* Rotieren              */ $env:ANTHROPIC_API_KEY = "sk-new-key"
/* Entfernen             */ Remove-Item Env:\ANTHROPIC_API_KEY
----------------------------------------------------------------------------------------------------------------------------------
# Sonstiges...
# persist-bash/*      */ echo 'export ANTHROPIC_API_KEY="sk-your-key-here-here"' >> ~/.bashrc && source ~/.bashrc
# persist-zsh /*      */ echo 'export ANTHROPIC_API_KEY="sk-your-key-here-here"' >> ~/.zshrc  && source ~/.zshrc
# persist-fish/*      */ fish -lc 'set -Ux ANTHROPIC_API_KEY sk-your-key-here-here'
----------------------------------------------------------------------------------------------------------------------------------

Konfiguration & Umgebung

Umgebungsvariablen

Alle hier aufgefĂŒhrten Variablen können auch in settings.json unter dem SchlĂŒssel "env" gesetzt werden, damit sie automatisch angewendet werden.

[!Important] Windows-Nutzer ersetzen export durch set oder setx fĂŒr dauerhafte Einstellungen

# Umgebungs-Schalter (in ~/.bashrc oder ~/.zshrc eintragen)
export ANTHROPIC_API_KEY="sk-your-key-here-here"      # API-SchlĂŒssel als X-Api-Key-Header (interaktiv: /login)
export ANTHROPIC_AUTH_TOKEN="my-auth-token"           # Benutzerdefinierter Authorization-Header; Claude fĂŒgt "Bearer " automatisch hinzu
export ANTHROPIC_CUSTOM_HEADERS="X-Trace-Id: 12345"   # ZusÀtzliche Request-Header (Format: "Name: Value")

export ANTHROPIC_MODEL="claude-sonnet-4-6-20260217"                # Benutzerdefinierter Modellname
export ANTHROPIC_DEFAULT_SONNET_MODEL="claude-sonnet-4-6-20260217" # Standard-Sonnet-Modell-Alias
export ANTHROPIC_DEFAULT_OPUS_MODEL="claude-opus-4-6-20260130"   # Standard-Opus-Modell-Alias (Opus 4.6 jetzt verfĂŒgbar)
export ANTHROPIC_SMALL_FAST_MODEL="haiku-model"                  # Haiku-Klasse-Modell fĂŒr Hintergrundaufgaben
export ANTHROPIC_SMALL_FAST_MODEL_AWS_REGION="REGION"            # AWS-Region fĂŒr kleines/schnelles Modell auf Bedrock ĂŒberschreiben

export AWS_BEARER_TOKEN_BEDROCK="bedrock_..."         # Amazon Bedrock API-SchlĂŒssel/Token

export BASH_DEFAULT_TIMEOUT_MS=60000                  # Standard-Timeout (ms) fĂŒr lang laufende Bash-Befehle
export BASH_MAX_TIMEOUT_MS=300000                     # Maximales Timeout (ms) fĂŒr lang laufende Bash-Befehle
export BASH_MAX_OUTPUT_LENGTH=20000                   # Max. Zeichen in Bash-Ausgaben vor Mittelabschneidung

export CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1     # (0 oder 1) nach jedem Bash-Befehl ins ursprĂŒngliche Projektverzeichnis zurĂŒckkehren
export CLAUDE_BASH_NO_LOGIN=1                         # Wenn gesetzt, verwendet BashTool keine Login-Shell
export CLAUDE_CODE_API_KEY_HELPER_TTL_MS=600000       # Intervall (ms) zum Aktualisieren der Credentials bei apiKeyHelper
export CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL=1            # (0 oder 1) automatische Installation von IDE-Erweiterungen ĂŒberspringen
export CLAUDE_CODE_MAX_OUTPUT_TOKENS=4096             # Max. Ausgabe-Tokens fĂŒr die meisten Anfragen

export CLAUDE_CODE_USE_BEDROCK=1                      # (0 oder 1) Amazon Bedrock verwenden
export CLAUDE_CODE_USE_VERTEX=0                       # (0 oder 1) Google Vertex AI verwenden
export CLAUDE_CODE_SKIP_BEDROCK_AUTH=0                # (0 oder 1) AWS-Auth fĂŒr Bedrock ĂŒberspringen
export CLAUDE_CODE_SKIP_VERTEX_AUTH=0                 # (0 oder 1) Google-Auth fĂŒr Vertex ĂŒberspringen

export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=0     # (0 oder 1) nicht-wesentlichen Traffic deaktivieren
export CLAUDE_CODE_DISABLE_TERMINAL_TITLE=0           # (0 oder 1) automatische Terminal-Titelaktualisierungen deaktivieren

export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1         # (0 oder 1) Agenten-Teams-Vorschau aktivieren
export CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1 # (0 oder 1) CLAUDE.md aus --add-dir-Pfaden laden
export CLAUDE_CODE_ENABLE_TASKS=false                 # Auf "false" setzen, um das neue Task-System zu deaktivieren

export DISABLE_AUTOUPDATER=0                          # (0 oder 1) automatische Updates deaktivieren
export DISABLE_BUG_COMMAND=0                          # (0 oder 1) /bug-Befehl deaktivieren
export DISABLE_COST_WARNINGS=0                        # (0 oder 1) Kostenwarnmeldungen deaktivieren
export DISABLE_ERROR_REPORTING=0                      # (0 oder 1) Sentry-Fehlerberichterstattung deaktivieren
export DISABLE_NON_ESSENTIAL_MODEL_CALLS=0            # (0 oder 1) Modellaufrufe fĂŒr unkritische Pfade deaktivieren
export DISABLE_TELEMETRY=0                            # (0 oder 1) Statsig-Telemetrie deaktivieren

export HTTP_PROXY="http://proxy:8080"                 # HTTP-Proxy-Server-URL
export HTTPS_PROXY="https://proxy:8443"               # HTTPS-Proxy-Server-URL

export MAX_THINKING_TOKENS=0                          # (0 oder 1) Denkbudget fĂŒr das Modell erzwingen
export MCP_TIMEOUT=120000                             # MCP-Server-Starttimeout (ms)
export MCP_TOOL_TIMEOUT=60000                         # MCP-Tool-AusfĂŒhrungstimeout (ms)
export MAX_MCP_OUTPUT_TOKENS=25000                    # Max. Tokens in MCP-Tool-Antworten (Standard: 25000)

export USE_BUILTIN_RIPGREP=0                          # (0 oder 1) 0 = system-installiertes rg statt integriertem verwenden

export VERTEX_REGION_CLAUDE_3_5_HAIKU="REGION"        # Region fĂŒr Claude 3.5 Haiku auf Vertex AI
export VERTEX_REGION_CLAUDE_3_5_SONNET="REGION"       # Region fĂŒr Claude 3.5 Sonnet auf Vertex AI
export VERTEX_REGION_CLAUDE_3_7_SONNET="REGION"       # Region fĂŒr Claude 3.7 Sonnet auf Vertex AI
export VERTEX_REGION_CLAUDE_4_0_OPUS="REGION"         # Region fĂŒr Claude 4.0 Opus auf Vertex AI
export VERTEX_REGION_CLAUDE_4_0_SONNET="REGION"       # Region fĂŒr Claude 4.0 Sonnet auf Vertex AI
export VERTEX_REGION_CLAUDE_4_1_OPUS="REGION"         # Region fĂŒr Claude 4.1 Opus auf Vertex AI
export VERTEX_REGION_CLAUDE_4_6_OPUS="REGION"         # Region fĂŒr Claude 4.6 Opus auf Vertex AI
export VERTEX_REGION_CLAUDE_4_6_SONNET="REGION"       # Region fĂŒr Claude 4.6 Sonnet auf Vertex AI

# ── Neu in v2.1.32–2.1.63 ──────────────────────────────────────────────────────
export CLAUDE_CODE_SIMPLE=1                            # Minimalmodus: deaktiviert MCP-Tools, AnhÀnge, Hooks, CLAUDE.md und Skills
export CLAUDE_CODE_DISABLE_1M_CONTEXT=1                # 1-M-Token-Kontextfenster deaktivieren
export CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1          # Hintergrundaufgaben vollstÀndig deaktivieren
export CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1        # Experimentelle Beta-Funktionen deaktivieren
export CLAUDE_CODE_AUTO_CONNECT_IDE=false              # Automatische IDE-Verbindung beim Start deaktivieren
export CLAUDE_CODE_TMPDIR="/custom/tmp"                # TemporĂ€res Verzeichnis ĂŒberschreiben
export CLAUDE_CODE_SHELL="/bin/zsh"                    # Shell-Erkennung ĂŒberschreiben
export CLAUDE_CODE_SHELL_PREFIX="command-wrapper"      # Jeden Shell-Befehl mit PrÀfix/Wrapper versehen
export CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS=50000   # Max. Ausgabe-Tokens fĂŒr das Read-Tool ĂŒberschreiben
export CLAUDE_CODE_PROXY_RESOLVES_HOSTS=true           # HTTP/HTTPS-Proxy DNS-Auflösung ĂŒberlassen
export CLAUDE_CODE_EXIT_AFTER_STOP_DELAY=30000         # Nach N ms Leerlauf im SDK-Modus automatisch beenden
export CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS=30000         # Timeout (ms) fĂŒr Plugin-Git-Operationen
export CLAUDE_CODE_ACCOUNT_UUID="uuid"                 # Konto-UUID ĂŒberschreiben (SDK/Automatisierungsflows)
export CLAUDE_CODE_USER_EMAIL="user@example.com"       # Nutzer-E-Mail ĂŒberschreiben (SDK/Automatisierungsflows)
export CLAUDE_CODE_ORGANIZATION_UUID="uuid"            # Organisations-UUID ĂŒberschreiben (SDK/Automatisierungsflows)
export ENABLE_CLAUDEAI_MCP_SERVERS=false               # Von claude.ai synchronisierte MCP-Server deaktivieren
export FORCE_AUTOUPDATE_PLUGINS=1                      # Plugin-Auto-Update auch bei deaktiviertem Haupt-Updater erlauben
export IS_DEMO=1                                       # Demo-Modus — E-Mail/Org in der UI ausblenden
export NO_PROXY="localhost,127.0.0.1"                  # Proxy fĂŒr bestimmte Hosts umgehen (kommagetrennt)

Globale Konfigurationsoptionen

claude config set -g theme dark                               # Theme: dark | light | light-daltonized | dark-daltonized
claude config set -g preferredNotifChannel iterm2_with_bell   # Benachrichtigungskanal: iterm2 | iterm2_with_bell | terminal_bell | notifications_disabled
claude config set -g autoUpdates true                         # Updates automatisch herunterladen & installieren
claude config set -g verbose true                             # VollstÀndige Bash/Befehlsausgaben anzeigen

claude config set -g attribution false                        # "co-authored-by Claude" in git-Commits/PRs weglassen
claude config set -g forceLoginMethod claudeai                 # Login-Flow einschrÀnken: claudeai | console
claude config set -g model "claude-sonnet-4-6-20260217"       # Standard-Modell ĂŒberschreiben
claude config set -g statusLine '{"type":"command","command":"~/.claude/statusline.sh"}'  # Benutzerdefinierte Statuszeile

claude config set -g enableAllProjectMcpServers true              # Alle MCP-Server aus .mcp.json automatisch genehmigen
claude config set -g enabledMcpjsonServers '["memory","github"]'  # Bestimmte MCP-Server genehmigen
claude config set -g disabledMcpjsonServers '["filesystem"]'      # Bestimmte MCP-Server ablehnen

Konfigurationsdateien

(Speichertypen) Claude Code bietet vier Speicherorte in einer hierarchischen Struktur, jeder mit einem anderen Zweck:

SpeichertypSpeicherortZweckAnwendungsbeispieleGeteilt mit
Enterprise-RichtliniemacOS: /Library/Application Support/ClaudeCode/CLAUDE.md
Linux: /etc/claude-code/CLAUDE.md
Windows: C:\ProgramData\ClaudeCode\CLAUDE.md		Organisationsweite Anweisungen, verwaltet von IT/DevOpsUnternehmens-Coding-Standards, Sicherheitsrichtlinien, ComplianceAlle Nutzer der Organisation
ProjektgedĂ€chtnis./CLAUDE.mdTeam-geteilte Anweisungen fĂŒr das ProjektProjektarchitektur, Coding-Standards, hĂ€ufige WorkflowsTeammitglieder via Versionskontrolle
NutzergedĂ€chtnis~/.claude/CLAUDE.mdPersönliche PrĂ€ferenzen fĂŒr alle ProjekteCode-Stil-PrĂ€ferenzen, persönliche Tool-ShortcutsNur du (alle Projekte)
ProjektgedÀchtnis (lokal)./CLAUDE.local.mdPersönliche projektspezifische PrÀferenzen (git-ignoriert)Sandbox-URLs, bevorzugte Testdaten, persönliche OverridesNur du (aktuelles Projekt)
Projektregeln.claude/rules/*.mdModulare Projektregeln (zusammen mit CLAUDE.md geladen)Lint-Regeln, API-Konventionen, verzeichnisspezifische StandardsTeammitglieder via Versionskontrolle

Alle Speicherdateien werden beim Start automatisch in den Kontext von Claude Code geladen. Dateien höher in der Hierarchie haben Vorrang und werden zuerst geladen.

.claude/rules/-Verzeichnis (v2.0.64+)​

Das .claude/rules/-Verzeichnis ermöglicht es, Projektanweisungen auf separate Markdown-Dateien aufzuteilen statt einer großen CLAUDE.md. Jede *.md-Datei darin wird automatisch zusammen mit CLAUDE.md in den Kontext geladen. NĂŒtzlich fĂŒr:

  • Modulare Organisation: Belange trennen (z.B. api-conventions.md, testing-rules.md)
  • Verzeichnisspezifische Overrides: Verschachtelte rules/-Verzeichnisse können bereichsbezogene Regeln anwenden
  • Teamzusammenarbeit: Verschiedene Teammitglieder können verschiedene Regelgruppen ĂŒber PR-Reviews verwalten

Auto-Memory (v2.1.32+)​

Claude speichert jetzt wĂ€hrend der Sitzungen automatisch nĂŒtzlichen Kontext. Verwaltete Erinnerungen umfassen Projektkonventionen, Tool-PrĂ€ferenzen und Architekturentscheidungen. /memory verwenden, um auto-gespeicherte Erinnerungen anzuzeigen und zu verwalten.

Befehle & Nutzung

Slash-Befehlsreferenz

BefehlZweck
/add-dirZusĂ€tzliche Arbeitsverzeichnisse hinzufĂŒgen
/agentsBenutzerdefinierte KI-Subagenten fĂŒr spezialisierte Aufgaben verwalten
/bugFehler melden (sendet GesprÀch an Anthropic)
/clearGesprÀchsverlauf löschen
/compact [instructions]GesprÀch mit optionalen Fokusanweisungen komprimieren
/configEinstellungsoberflÀche öffnen (Config-Tab)
/contextAktuelle Kontextnutzung als farbiges Raster visualisieren
/copyGesprÀchsinhalt in die Zwischenablage kopieren
/costToken-Nutzungsstatistiken und Abrechnungsinformationen anzeigen
/debugAktuelle Sitzung debuggen und Probleme diagnostizieren
/doctorGesundheit der Claude Code-Installation prĂŒfen
/exitREPL beenden
/export [filename]Aktuelles GesprÀch in eine Datei oder Zwischenablage exportieren
/extra-usageExtra-Nutzungsmodus aktivieren (vor /fast erforderlich)
/fastSchnellmodus fĂŒr beschleunigte Opus 4.6-Antworten umschalten
/forkAktuelles GesprÀch in eine neue Sitzung forken
/helpNutzungshilfe anzeigen
/initProjekt mit CLAUDE.md-Leitfaden initialisieren
/insightsInteraktiven HTML-Bericht ĂŒber Coding-Gewohnheiten generieren
/keybindingsBenutzerdefinierte TastaturkĂŒrzel konfigurieren
/loginAnthropic-Konto wechseln
/logoutVom Anthropic-Konto abmelden
/mcpMCP-Server-Verbindungen und OAuth-Authentifizierung verwalten
/memoryCLAUDE.md-Speicherdateien bearbeiten
/modelKI-Modell auswÀhlen oder wechseln
/permissionsTool-Berechtigungen anzeigen oder aktualisieren
/planPlanungsmodus direkt aus der Eingabeaufforderung starten
/pluginsPlugins verwalten (installieren, aktivieren, deaktivieren, Marktplatz)
/pr_commentsPull-Request-Kommentare anzeigen
/rename <name>Aktuelle Sitzung umbenennen
/resume [session]GesprÀch nach ID oder Name fortsetzen oder Sitzungsauswahl öffnen
/reviewCode-Review anfordern
/rules.claude/rules/-Verzeichnis anzeigen und verwalten
/rewindGesprĂ€ch und/oder Code auf einen frĂŒheren Stand zurĂŒcksetzen
/sandboxSandbox-AbhÀngigkeitsstatus mit Installationsanweisungen anzeigen
/statsTÀgliche Nutzung, Sitzungsverlauf, Streaks und ModellprÀferenzen visualisieren
/settingsEinstellungsoberflĂ€che öffnen (Alias fĂŒr /config)
/simplifyAusgewÀhlten Code oder GesprÀch vereinfachen (eingebetteter Skill)
/statusEinstellungsoberflÀche öffnen (Status-Tab) mit Version, Modell, Konto
/statuslineClaude Code-Statuszeilen-UI einrichten
/tasksHintergrundaufgaben auflisten und verwalten
/teleportRemote-Sitzung von claude.ai fortsetzen (nur Abonnenten)
/terminal-setupShift+Enter-Tastenbelegung fĂŒr ZeilenumbrĂŒche installieren (iTerm2, VS Code, Kitty, Alacritty, Zed, Warp, WezTerm)
/remote-envRemote-Umgebungseinstellungen konfigurieren
/themeFarbthema Àndern
/todosAktuelle TODO-Elemente auflisten
/usagePlan-Nutzungslimits und Rate-Limit-Status anzeigen (AbonnementplÀne)
/vimVim-Modus aktivieren
/batchBatch-Operationen auf mehreren Dateien ausfĂŒhren (eingebetteter Skill)

Befehlszeilen-Flags

Flag / BefehlBeschreibungBeispiel
-d, --debugDebug-Modus aktivieren (zeigt detaillierte Debug-Ausgabe).claude -d -p "query"
--include-partial-messagesPartielles Nachrichten-Streaming via CLI-Flag
--mcp-debug[VERALTET] MCP-Debug-Modus. Stattdessen --debug verwenden.claude --mcp-debug
--verboseVerbose-Modus aus Konfiguration ĂŒberschreiben (zeigt erweiterte Protokollierung).claude --verbose
-p, --printAntwort ausgeben und beenden (nĂŒtzlich fĂŒr Pipe-Ausgabe).claude -p "query"
--output-format <format>Ausgabeformat (nur mit --print): text (Standard), json oder stream-json.claude -p "query" --output-format json
--input-format <format>Eingabeformat (nur mit --print): text (Standard) oder stream-json.claude -p --output-format stream-json --input-format stream-json
--replay-user-messagesNutzernachrichten aus stdin zurĂŒck auf stdout ausgeben — nur mit --input-format=stream-json und --output-format=stream-json.claude --input-format stream-json --output-format stream-json --replay-user-messages
--allowedTools, --allowed-tools <tools...>Komma-/leerzeichengetrennte Liste erlaubter Tool-Namen.--allowed-tools "Bash(git:*)" Edit"
--disallowedTools, --disallowed-tools <tools...>Komma-/leerzeichengetrennte Liste verbotener Tool-Namen.--disallowed-tools "Edit"
--mcp-config <configs...>MCP-Server aus JSON-Dateien oder Strings laden.claude --mcp-config ./mcp-servers.json
--strict-mcp-configNur MCP-Server aus --mcp-config verwenden.claude --mcp-config ./a.json --strict-mcp-config
--append-system-prompt <prompt>System-Prompt an Standard-System-Prompt anhÀngen.claude -p --append-system-prompt "Do X then Y"
--permission-mode <mode>Berechtigungsmodus fĂŒr die Sitzung (acceptEdits, bypassPermissions, default, plan).claude --permission-mode plan
--permission-prompt-tool <tool>MCP-Tool fĂŒr Berechtigungsanfragen im nicht-interaktiven Modus angeben.claude -p --permission-prompt-tool mcp_auth_tool "query"
--fallback-model <model>Automatischen Fallback auf ein bestimmtes Modell aktivieren, wenn das Standard-Modell ĂŒberlastet ist.claude -p --fallback-model claude-haiku-20240307 "query"
--model <model>Modell fĂŒr die aktuelle Sitzung. Aliase wie sonnet/opus oder vollstĂ€ndiger Modellname.claude --model sonnet
--settings <file-or-json>ZusÀtzliche Einstellungen aus JSON-Datei oder JSON-String laden.claude --settings ./settings.json
--add-dir <directories...>ZusĂ€tzliche Verzeichnisse fĂŒr Tool-Zugriff hinzufĂŒgen.claude --add-dir ../apps ../lib
--ideBeim Start automatisch mit einer IDE verbinden, wenn genau eine gĂŒltige IDE verfĂŒgbar ist.claude --ide
-c, --continueZuletzt verwendetes GesprÀch im aktuellen Verzeichnis fortsetzen.claude --continue
-r, --resume [sessionId]GesprÀch fortsetzen; Sitzungs-ID angeben oder interaktiv auswÀhlen.claude -r "abc123"
--session-id <uuid>Bestimmte Sitzungs-ID fĂŒr das GesprĂ€ch verwenden (muss gĂŒltige UUID sein).claude --session-id 123e4567-e89b-12d3-a456-426614174000
--agents <json>Benutzerdefinierte Subagenten dynamisch via JSON definieren.claude --agents '{"reviewer":{"description":"...","prompt":"..."}}'
--agent <name>Bestimmten Agenten fĂŒr die aktuelle Sitzung angeben.claude --agent my-custom-agent
--chromeChrome-Browser-Integration fĂŒr Web-Automatisierung und Tests aktivieren.claude --chrome
--no-chromeChrome-Browser-Integration fĂŒr diese Sitzung deaktivieren.claude --no-chrome
--remoteNeue Web-Sitzung auf claude.ai mit der angegebenen Aufgabenbeschreibung erstellen.claude --remote "Fix the login bug"
--teleportWeb-Sitzung im lokalen Terminal fortsetzen.claude --teleport
--fork-sessionBeim Fortsetzen neue Sitzungs-ID erstellen statt ursprĂŒngliche wiederzuverwenden.claude --resume abc123 --fork-session
--json-schema <schema>Validierte JSON-Ausgabe passend zu einem JSON-Schema erhalten (nur Print-Modus).claude -p --json-schema '{"type":"object",...}' "query"
--max-budget-usd <amount>Maximalen Dollar-Betrag fĂŒr API-Aufrufe begrenzen (nur Print-Modus).claude -p --max-budget-usd 5.00 "query"
--max-turns <n>Anzahl der Agenten-Runden begrenzen (nur Print-Modus). Beendet mit Fehler bei Überschreitung.claude -p --max-turns 3 "query"
--betas <headers>Beta-Header in API-Anfragen einbeziehen (nur fĂŒr API-SchlĂŒssel-Nutzer).claude --betas interleaved-thinking
--tools <tools>Eingebaute Tools einschrĂ€nken. "" fĂŒr alle deaktivieren, "default" fĂŒr alle, oder bestimmte Tool-Namen.claude --tools "Bash,Edit,Read"
--system-prompt <prompt>Gesamten System-Prompt durch benutzerdefinierten Text ersetzen.claude --system-prompt "You are a Python expert"
--system-prompt-file <file>System-Prompt aus Datei laden (nur Print-Modus).claude -p --system-prompt-file ./custom-prompt.txt "query"
--append-system-prompt-file <file>ZusÀtzlichen System-Prompt-Text aus Datei laden und anhÀngen (nur Print-Modus).claude -p --append-system-prompt-file ./extra-rules.txt "query"
--plugin-dir <dir>Plugins aus Verzeichnissen nur fĂŒr diese Sitzung laden (wiederholbar).claude --plugin-dir ./my-plugins
--setting-sources <sources>Kommagetrennte Liste der zu ladenden Einstellungsquellen (user, project, local).claude --setting-sources user,project
--no-session-persistenceSitzungspersistenz deaktivieren (nur Print-Modus).claude -p --no-session-persistence "query"
--disable-slash-commandsAlle Skills und Slash-Befehle fĂŒr diese Sitzung deaktivieren.claude --disable-slash-commands
--dangerously-skip-permissionsAlle BerechtigungsprĂŒfungen umgehen (nur fĂŒr vertrauenswĂŒrdige Sandboxes).claude --dangerously-skip-permissions
--worktree, -wIn einem isolierten git-Worktree starten (v2.1.49).claude -w "implement feature"
--from-pr <url>Sitzung aus einer Pull-Request-URL starten (v2.1.27).claude --from-pr https://github.com/org/repo/pull/123
--initSetup-Hook-Ereignis auslösen (v2.1.10).claude --init
--init-onlySetup-Hook ausfĂŒhren und beenden (v2.1.10).claude --init-only
--maintenanceSetup-Hook im Wartungsmodus ausfĂŒhren (v2.1.10).claude --maintenance
-v, --versionInstallierte claude-CLI-Version anzeigen.claude --version
-h, --helpHilfe/Nutzung anzeigen.claude --help

Das Flag --output-format json ist besonders nĂŒtzlich fĂŒr Skripting und Automatisierung.

CLI-Kurzreferenz & Konfigurationsbeispiele

## Claude Spickzettel

# Grundlagen / interaktiv

claude # Interaktives REPL starten
claude "explain this project" # REPL mit Prompt vorbelegt starten
claude -p "summarize README.md" # Nicht-interaktiver Print-Modus
cat logs.txt | claude -p "explain" # Eingabe an Claude pipen und beenden
claude -c # Letztes GesprÀch fortsetzen (--continue)
claude -r "<session-id>" "finish this" # Sitzung nach ID fortsetzen
claude --model claude-sonnet-4-6-20260217 # Modell fĂŒr diesen Lauf wĂ€hlen
claude --max-turns 3 -p "lint this" # Agenten-Runden im Print-Modus begrenzen
claude --replay-user-messages # Nutzernachrichten zurĂŒck auf stdout ausgeben

# Update & Installation

claude update # Claude Code manuell aktualisieren
claude doctor # Installation/Version diagnostizieren
claude install # Nativen BinÀr-Installer starten (Beta)
claude migrate-installer # Von globalem npm zu lokalem Installer migrieren

# Authentifizierung (v2.1.41+)

claude auth login # Beim Anthropic-Konto anmelden
claude auth status # Authentifizierungsstatus prĂŒfen
claude auth logout # Abmelden

# Agentenverwaltung (v2.1.50+)

claude agents # Alle konfigurierten Agenten auflisten
claude remote-control # Fernsteuerungsmodus starten

# Konfiguration: interaktiver Assistent + direkte Operationen

claude config # Interaktiver Konfigurationsassistent
claude config get <key> # Wert abrufen
claude config set <key> <val> # Wert setzen
claude config add <key> <vals
> # An Array-SchlĂŒssel anhĂ€ngen
claude config remove <key> <vals
> # Elemente aus Listen-SchlĂŒsseln entfernen
claude config list # Alle aktuellen Einstellungen fĂŒr Projekt anzeigen

# Beispiel: Projektbezogene Einstellungen

claude config set model "claude-sonnet-4-6-20260217" # Standard-Modell fĂŒr dieses Projekt ĂŒberschreiben
claude config set attribution false # "co-authored-by Claude" in git/PRs deaktivieren
claude config set forceLoginMethod claudeai # Login-Flow einschrÀnken
claude config set enableAllProjectMcpServers true # Alle MCP-Server aus .mcp.json automatisch genehmigen
claude config set defaultMode "acceptEdits" # Standard-Berechtigungsmodus setzen

# Listeinstellungen verwalten (Projektbereich)

claude config add enabledMcpjsonServers github # Bestimmten MCP-Server aus .mcp.json genehmigen
claude config add enabledMcpjsonServers memory # Weiteren hinzufĂŒgen
claude config remove enabledMcpjsonServers memory # Einen entfernen
claude config add disabledMcpjsonServers filesystem # Bestimmten MCP-Server ausdrĂŒcklich ablehnen

# Globaler Bereich (-g oder --global)

claude config set -g autoUpdates false # Automatische Updates global deaktivieren
claude config set --global preferredNotifChannel iterm2_with_bell
claude config set -g theme dark # Theme: dark | light | light-daltonized | dark-daltonized
claude config set -g verbose true # VollstĂ€ndige Bash/Befehlsausgaben ĂŒberall anzeigen
claude config get -g theme # Globalen Wert bestÀtigen

# MCP-Verwaltung

claude mcp # MCP-Assistent starten / MCP-Server konfigurieren
claude mcp list # Konfigurierte MCP-Server auflisten
claude mcp get <name> # Details zu einem Server anzeigen
claude mcp remove <name> # Server entfernen
claude mcp add <name> <command> [args...] # Lokalen stdio-Server hinzufĂŒgen
claude mcp add --transport sse <name> <url> # Remote-SSE-Server hinzufĂŒgen
claude mcp add --transport http <name> <url> # Remote-HTTP-Server hinzufĂŒgen
claude mcp add <name> --env KEY=VALUE -- <cmd> [args...] # Umgebung an Server-Befehl ĂŒbergeben
claude mcp add --transport sse private-api https://api.example/mcp \
 --header "Authorization: Bearer TOKEN" # Mit Auth-Header hinzufĂŒgen
claude mcp add-json <name> '<json>' # Server via JSON-Blob hinzufĂŒgen
claude mcp add-from-claude-desktop # Server aus Claude Desktop importieren
claude mcp reset-project-choices # Genehmigungen fĂŒr .mcp.json-Server zurĂŒcksetzen
claude mcp serve # Claude Code selbst als MCP-stdio-Server ausfĂŒhren

# Weitere nĂŒtzliche Flags (Print / SDK-Modus)

claude --add-dir ../apps ../lib # Weitere Arbeitsverzeichnisse hinzufĂŒgen
claude --allowedTools "Bash(git log:\*)" "Read" # Tools ohne Berechtigungsaufforderung erlauben
claude --disallowedTools "Edit" # Tools ohne Berechtigungsaufforderung verbieten
claude --append-system-prompt "Custom instruction" # An System-Prompt anhÀngen (nur mit -p)
claude -p "query" --output-format json --input-format stream-json # IO-Formate fĂŒr Skripting
claude --verbose # Verbose-Protokollierung
claude --dangerously-skip-permissions # Berechtigungsaufforderungen ĂŒberspringen (mit Vorsicht)
claude --permission-mode plan # Im Planungsmodus starten (nur Lesen)
claude --max-turns 3 -p "query" # Agenten-Runden begrenzen (nur Print-Modus)
claude --max-budget-usd 5.00 -p "query" # Ausgaben pro Sitzung begrenzen (nur Print-Modus)
claude --json-schema '{"type":"object"}' -p "query" # Validierte JSON-Ausgabe

# Sitzungsverwaltung

claude -c # Letztes GesprÀch fortsetzen
claude -r "session-name" # Nach Name oder ID fortsetzen
claude --fork-session -r abc123 # Statt ursprĂŒngliche Sitzung forken
claude -w "implement feature" # In isoliertem git-Worktree starten
/rename auth-refactor # Aktuelle Sitzung benennen
/resume # Sitzungsauswahl öffnen
/export output.md # GesprÀch in Datei exportieren
/fork # Aktuelles GesprÀch forken

# Hinweise

# - Projektbereich ist Standard fĂŒr 'claude config'; -g/--global fĂŒr alle Projekte verwenden.
# - Einstellungsvorrang: Enterprise > CLI-Args > lokales Projekt > geteiltes Projekt > Nutzer (~/.claude).
# - 'add' / 'remove' nur mit Listen-SchlĂŒsseln verwenden (z.B. enabledMcpjsonServers).

OberflÀche & Eingabe

TastaturkĂŒrzel

KĂŒrzelBeschreibungKontext
Ctrl+CAktuelle Eingabe oder Generierung abbrechenStandard-Interrupt
Ctrl+DClaude Code-Sitzung beendenEOF-Signal
Ctrl+GIm Standard-Texteditor öffnenPrompt oder benutzerdefinierte Antwort bearbeiten
Ctrl+LTerminal-Bildschirm leerenGesprÀchsverlauf bleibt erhalten
Ctrl+OVerbose-Ausgabe umschaltenDetaillierte Tool-Nutzung anzeigen
Ctrl+RUmgekehrte BefehlsverlaufssucheFrĂŒhere Befehle durchsuchen
Ctrl+V oder Cmd+V (iTerm2)Bild aus Zwischenablage einfĂŒgenBild oder Pfad zu Bilddatei einfĂŒgen
Ctrl+BLaufende Aufgaben in HintergrundBash-Befehle und Agenten in Hintergrund
Ctrl+F (zweimal drĂŒcken)Alle Hintergrundagenten beendenZweifache BestĂ€tigung zum Stoppen
Hoch/Runter-PfeileBefehlsverlauf navigierenFrĂŒhere Eingaben aufrufen
Links/Rechts-PfeileDialog-Tabs wechselnZwischen Tabs in Dialogen wechseln
Esc + EscCode/GesprĂ€ch zurĂŒcksetzenAuf frĂŒheren Stand wiederherstellen
Shift+Tab oder Alt+MBerechtigungsmodi umschaltenZwischen Auto-Accept, Plan, Normal wechseln
Option+P (macOS) / Alt+PModell wechselnModell wechseln ohne Prompt zu löschen
Option+T (macOS) / Alt+TErweitertes Denken umschaltenErweiterter Denkmodus ein/aus

Textbearbeitung

KĂŒrzelBeschreibungKontext
Ctrl+KBis Zeilenende löschenGelöschter Text zum EinfĂŒgen gespeichert
Ctrl+UGesamte Zeile löschenGelöschter Text zum EinfĂŒgen gespeichert
Ctrl+YGelöschten Text einfĂŒgenMit Ctrl+K/U gelöschten Text einfĂŒgen
Alt+Y (nach Ctrl+Y)EinfĂŒgeverlauf durchgehenFrĂŒher gelöschten Text durchgehen
Alt+BCursor ein Wort zurĂŒckOption als Meta auf macOS erforderlich
Alt+FCursor ein Wort vorOption als Meta auf macOS erforderlich

Mehrzeilige Eingabe

MethodeKĂŒrzelKontext
Schnell-Escape\ + EnterFunktioniert in allen Terminals
macOS StandardOption+EnterStandard auf macOS
Terminal-SetupShift+EnterNach /terminal-setup
SteuersequenzCtrl+JZeilenvorschub fĂŒr mehrzeilige Eingabe
EinfĂŒgemodusDirekt einfĂŒgenFĂŒr Code-Blöcke, Logs

Schnellbefehle

KĂŒrzelBeschreibungHinweise
/ am AnfangBefehl oder SkillEingebaute Befehle und Skills
! am AnfangBash-ModusBefehle direkt ausfĂŒhren, Kontext hinzufĂŒgen
@Dateipfad-ErwÀhnungDateipfad-AutovervollstÀndigung auslösen

[!Tip] PDF-Seitenbereiche: Den pages-Parameter beim Read-Tool fĂŒr PDFs verwenden (z.B. pages: "1-5"). Große PDFs (>10 Seiten) geben eine kompakte Referenz zurĂŒck, wenn sie per @ erwĂ€hnt werden.

Vim-Modus

[!Note] Vim-Bearbeitung mit /vim-Befehl aktivieren oder dauerhaft ĂŒber /config konfigurieren.

Vim-Modus-Wechsel

BefehlAktionAus Modus
EscNORMAL-Modus einschaltenINSERT
iVor Cursor einfĂŒgenNORMAL
IAm Zeilenanfang einfĂŒgenNORMAL
aNach Cursor einfĂŒgenNORMAL
AAm Zeilenende einfĂŒgenNORMAL
oZeile darunter öffnenNORMAL
OZeile darĂŒber öffnenNORMAL

Vim-Navigation

BefehlAktion
h/j/k/lLinks/Runter/Hoch/Rechts
wNĂ€chstes Wort
eWortende
bVorheriges Wort
0Zeilenanfang
$Zeilenende
^Erstes Nicht-Leerzeichen
ggAnfang der Eingabe
GEnde der Eingabe

Vim-Bearbeitung

BefehlAktion
xZeichen löschen
ddZeile löschen
DBis Zeilenende löschen
dw/de/dbWort/bis Ende/rĂŒckwĂ€rts löschen
ccZeile Àndern
CBis Zeilenende Àndern
cw/ce/cbWort/bis Ende/rĂŒckwĂ€rts Ă€ndern
.Letzte Änderung wiederholen

[!Tip] Bevorzugtes Zeilenumbruchverhalten in den Terminal-Einstellungen konfigurieren. /terminal-setup ausfĂŒhren, um Shift+Enter-Belegung fĂŒr iTerm2, VS Code, Kitty, Alacritty, Zed, Warp und WezTerm zu installieren.

Befehlsverlauf

Claude Code pflegt einen Befehlsverlauf fĂŒr die aktuelle Sitzung:

* Verlauf wird pro Arbeitsverzeichnis gespeichert
* Wird mit /clear-Befehl gelöscht
* Hoch/Runter-Pfeile zur Navigation verwenden (siehe TastaturkĂŒrzel oben)
* Ctrl+R: Umgekehrte Verlaufssuche (wenn vom Terminal unterstĂŒtzt)
* Hinweis: Verlaufserweiterung (!) ist standardmĂ€ĂŸig deaktiviert

Erweiterte Funktionen

Denk-SchlĂŒsselwörter

[!Note] Gibt Claude zusĂ€tzliche Planungszeit vor der Antwort durch HinzufĂŒgen EINES dieser SchlĂŒsselwörter zum Prompt. Reihenfolge (niedrigster → höchster) Token-Verbrauch

think -------------> Niedrigster

think hard

think harder

ultrathink --------> Höchster

Damit verbringt Claude mehr Zeit mit:

  1. Lösungsplanung

  2. Schritten zerlegen​

  3. Alternativen/AbwĂ€gungen abwĂ€gen​

  4. EinschrĂ€nkungen & RandfĂ€lle prĂŒfen​

    Höhere Stufen erhöhen meist Latenz und Token-Verbrauch — kleinste ausreichende Stufe wĂ€hlen.​

Beispiele
# Kleiner Boost

claude -p "Think. Outline a plan to refactor the auth module."

# Mittlerer Boost

claude -p "Think harder. Draft a migration plan from REST to gRPC."

# Maximaler Boost

claude -p "Ultrathink. Propose a step-by-step strategy to fix flaky payment tests and add guardrails."

Schnellmodus

[!Note] Der Schnellmodus bietet beschleunigte Antwortzeiten fĂŒr Opus 4.6, optimiert fĂŒr schnelle Iteration.

Schnellmodus aktivieren:

# Schnellmodus im REPL aktivieren (erfordert vorher extra-usage)
/extra-usage
/fast

# Oder wÀhrend des GesprÀchs umschalten
# Die Statusleiste zeigt an, wenn Schnellmodus aktiv ist

Hauptfunktionen:

  • Schnellere Antworten — Reduzierte Latenz fĂŒr schnelle Aufgaben
  • FĂŒr Opus 4.6 verfĂŒgbar — Neu in Version 2.1.36
  • Erfordert extra-usage — Zuerst /extra-usage aktivieren

Wann Schnellmodus verwenden:

  • Schnelle Code-Reviews und Bearbeitungen
  • Schnelles Prototyping
  • Einfache Fragen und Befehle
  • Iteratives Debugging

Schnellmodus tauscht etwas Tiefe gegen Geschwindigkeit. Normalen Modus fĂŒr komplexe Analyse und Planungsaufgaben verwenden.

Planungsmodus

[!Note] Der Planungsmodus weist Claude an, die Codebase nur lesend zu analysieren — ideal fĂŒr die Erkundung von Codebases, Planung komplexer Änderungen oder sicheres Code-Review.

Wann Planungsmodus verwenden:

  • Mehrstufige Implementierung: Wenn deine Funktion Bearbeitungen in vielen Dateien erfordert
  • Code-Erkundung: Wenn du die Codebase grĂŒndlich erforschen möchtest, bevor du etwas Ă€nderst
  • Interaktive Entwicklung: Wenn du die Richtung mit Claude iterativ festlegen möchtest

Planungsmodus aktivieren:

# Neue Sitzung im Planungsmodus starten
claude --permission-mode plan

# Oder wÀhrend der Sitzung mit Shift+Tab umschalten
# (wechselt zwischen: Normal → Auto-Accept → Planungsmodus)

# Planungsmodus aus dem Prompt starten
/plan

# Headless-Abfragen im Planungsmodus
claude --permission-mode plan -p "Analyze the authentication system and suggest improvements"

Planungsmodus als Standard konfigurieren:

// .claude/settings.json
{
  "permissions": {
    "defaultMode": "plan"
  }
}

Hintergrundaufgaben

[!Note] Claude Code unterstĂŒtzt das AusfĂŒhren von Bash-Befehlen im Hintergrund, sodass du weiterarbeiten kannst, wĂ€hrend lang laufende Prozesse ausgefĂŒhrt werden.

Hintergrundaufgaben verwenden:

MethodeBeschreibung
Claude fragenClaude bitten, "das im Hintergrund auszufĂŒhren"
Ctrl+BLaufendes Bash-Tool in Hintergrund verschieben (tmux-Nutzer zweimal drĂŒcken)

Hauptfunktionen:

  • Ausgabe wird gepuffert und Claude kann sie mit dem TaskOutput-Tool abrufen
  • Hintergrundaufgaben haben eindeutige IDs fĂŒr Verfolgung und Ausgabeabruf
  • Werden automatisch bereinigt, wenn Claude Code beendet wird
  • /tasks zum Auflisten und Verwalten von Hintergrundaufgaben verwenden

HĂ€ufig im Hintergrund ausgefĂŒhrte Befehle:

  • Build-Tools (webpack, vite, make)
  • Paketmanager (npm, yarn, pnpm)
  • Test-Runner (jest, pytest)
  • Entwicklungsserver
  • Lang laufende Prozesse (docker, terraform)

Bash-Modus mit !-PrÀfix:

# Bash-Befehle direkt ohne Claude-Interpretation ausfĂŒhren
! npm test
! git status
! ls -la

Hintergrundaufgaben deaktivieren:

export CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1

Remote-Sitzungen

[!Note] FĂŒr Abonnenten: --remote verwenden, um Aufgaben auf claude.ai zu starten, und --teleport, um sie lokal fortzusetzen.

Remote-Sitzung starten:

# Neue Web-Sitzung auf claude.ai mit Aufgabenbeschreibung erstellen
claude --remote "Fix the login bug"

Remote-Sitzung fortsetzen:

# Web-Sitzung im lokalen Terminal fortsetzen
claude --teleport

# Oder Slash-Befehl verwenden
/teleport

Claude in Chrome

Claude Code kann Google Chrome fĂŒr browserbasierte Aufgaben wie Tests, Web-Scraping und UI-ÜberprĂŒfung steuern.

Einrichtung:

claude --chrome                    # Mit Chrome-Integration starten

Funktionen:

  • Zu URLs navigieren, Elemente anklicken, Formulare ausfĂŒllen
  • Screenshots machen und Seiteninhalt analysieren
  • JavaScript im Browser-Kontext ausfĂŒhren
  • Mit Web-Anwendungen fĂŒr Tests interagieren

[!NOTE] Google Chrome muss installiert sein. Claude verwendet das Chrome DevTools Protocol fĂŒr die Browser-Steuerung.

Sandbox-Modus

Der Sandbox-Modus schrĂ€nkt das BashTool ein, Befehle in einer isolierten Umgebung auszufĂŒhren, und verhindert Änderungen am tatsĂ€chlichen Dateisystem.

/sandbox              # Sandbox-Modus ein/aus schalten

Im Sandbox-Modus:

  • Dateisystem-SchreibvorgĂ€nge sind eingeschrĂ€nkt
  • Netzwerkzugriff kann eingeschrĂ€nkt sein
  • NĂŒtzlich zum sicheren Testen destruktiver Befehle

VerfĂŒgbar auf Linux und macOS. claude --sandbox verwenden, um im Sandbox-Modus zu starten.

LSP-Tool (Language Server Protocol)

Claude Code integriert sich mit Language-Servern fĂŒr IDE-Level-Code-Intelligenz:

  • Zur Definition springen — Zur Definition eines Symbols springen
  • Referenzen finden — Alle Verwendungen eines Symbols in der Codebase finden
  • Hover-Informationen — Typ-Informationen und Dokumentation anzeigen

Das LSP-Tool aktiviert sich automatisch, wenn ein kompatibler Language-Server fĂŒr das aktuelle Projekt verfĂŒgbar ist. Dies ermöglicht Claude, Codebases prĂ€ziser als mit Textsuche allein zu navigieren.

Tool-Ergebnisse, die 50.000 Zeichen ĂŒberschreiten, werden automatisch auf der Festplatte gespeichert, um den Kontext effizient zu verwalten.

Sub-Agenten

Sub-Agenten sind zweckgebundene Helfer mit eigenen Prompts, Tools und isolierten Kontextfenstern. Behandle sie wie ein "Ensemble von Experten", das du pro Repository zusammenstellst.

Eingebaute Subagenten

Claude Code enthÀlt eingebaute Subagenten, die Claude automatisch bei Bedarf verwendet:

SubagentModellToolsZweck
ExploreHaiku (schnell)Nur lesenDatei-Erkundung, Code-Suche, Codebase-Erkundung
PlanKonfigurierbarNur lesenKomplexe Änderungen planen ohne Bearbeitungen
General-purposeStandardGeerbtAllgemeine Aufgabendelegierung

Claude delegiert an Explore, wenn es eine Codebase durchsuchen oder verstehen muss, ohne Änderungen vorzunehmen, und hĂ€lt Erkundungsergebnisse aus dem HauptgesprĂ€ch heraus.

Wann Subagenten verwenden:

  • Du benötigst hochwertige Antworten (PlĂ€ne, Reviews, Diffs) ohne Abschweifungen.
  • Du möchtest versionskontrollierte Prompts und Tool-Richtlinien neben der Codebase.
  • Du arbeitest in PR-gesteuerten Teams und möchtest begrenzte Bearbeitungen nach Rolle.
  • Die Aufgabe erzeugt ausfĂŒhrliche Ausgaben, die du nicht im Hauptkontext benötigst.

Jeder Sub-Agent hat seinen eigenen Kontext

Design-Regeln fĂŒr dein Team

  • Eine klare Verantwortung pro Agent definieren.
  • Minimales Tool-Set fĂŒr diese Rolle behalten.
  • Nur-Lesen-Agenten fĂŒr Analyse-/Review-Aufgaben bevorzugen.
  • Schreibzugriff so wenigen Agenten wie möglich geben.
image

Bildunterschrift: Agentenauswahl-UI im Terminal.

Agenten konfigurieren

Agenten im Projekt behalten, damit sie mit dem Repo versioniert werden und ĂŒber PRs weiterentwickelt werden.

Schnellstart

CLI aktualisieren und das Agenten-Panel öffnen

claude update
/agents

Subagenten-Bereiche

SpeicherortBereichPrioritÀt
--agents CLI-FlagNur aktuelle Sitzung1 (höchste)
.claude/agents/Aktuelles Projekt2
~/.claude/agents/Alle deine Projekte3
agents/-Verzeichnis des PluginsWo Plugin aktiviert4 (niedrigste)

Agenten via CLI definieren

# Benutzerdefinierte Subagenten dynamisch via JSON definieren
claude --agents '{
  "code-reviewer": {
    "description": "Expert code reviewer. Use proactively after code changes.",
    "prompt": "You are a senior code reviewer. Focus on code quality, security, and best practices.",
    "tools": ["Read", "Grep", "Glob", "Bash"],
    "model": "sonnet"
  },
  "debugger": {
    "description": "Debugging specialist for errors and test failures.",
    "prompt": "You are an expert debugger. Analyze errors, identify root causes, and provide fixes."
  },
  "background-impl": {
    "description": "Implements features in an isolated worktree in the background.",
    "prompt": "Implement the requested feature. Commit when done.",
    "isolation": "worktree",
    "background": true
  }
}'

Kern-Agenten erstellen

  • planner (nur lesen): wandelt Features/Issues in kleine, testbare Aufgaben um; gibt eine Aufgabenliste oder plan.md aus.
  • codegen (bearbeitungsfĂ€hig): implementiert Aufgaben; begrenzt auf src/ + tests/.
  • tester (nur lesen oder nur Patch): schreibt einen fehlschlagenden Test oder eine minimale Reproduktion.
  • reviewer (nur lesen): hinterlĂ€sst strukturierte Review-Kommentare; bearbeitet nie.
  • docs (bearbeitungsfĂ€hig): aktualisiert nur README.md/docs/.

*Richtlinien-Tipp: Patch-Ausgabe fĂŒr bearbeitungsfĂ€hige Agenten bevorzugen, damit Änderungen durch den normalen Git-Workflow landen.*

image

Bildunterschrift: Nur die Tools auswÀhlen, die ein Agent wirklich benötigt.

Beispiel-Prompts

Prompts kurz, testbar und repo-spezifisch halten. In agents/ einchecken:

image

Bildunterschrift: Beispiel-Prompt fĂŒr einen test-coverage-analyzer-Agenten.

tester.prompt.md (Beispiel)

Role: Write a single, focused failing test for the specific scenario I describe.
Scope: Only create/modify tests under tests/. Do not change src/.
Output: A brief rationale + a unified diff or patch.
If the scenario is unclear, ask exactly one clarifying question.

Erwartete Ausgabe

Dein Tester-Agent sollte einen kleinen Diff oder Patch plus eine kurze BegrĂŒndung erzeugen:

image

Bildunterschrift: Beispielantwort des test-coverage-analyzer-Agenten.

Subagenten-Frontmatter-Felder

Subagenten-Dateien verwenden YAML-Frontmatter fĂŒr die Konfiguration:

---
name: code-reviewer
description: Reviews code for quality and best practices
tools: Read, Glob, Grep
disallowedTools: Write, Edit
model: sonnet
permissionMode: default
skills:
  - api-conventions
---

You are a code reviewer. Analyze the code and provide feedback.
FeldErforderlichBeschreibung
nameJaEindeutiger Bezeichner (Kleinbuchstaben, Bindestriche)
descriptionJaWann Claude an diesen Subagenten delegieren soll
toolsNeinTools, die der Subagent verwenden kann (erbt alle, wenn weggelassen)
disallowedToolsNeinTools, die verweigert werden sollen
modelNeinModell: sonnet, opus, haiku oder inherit (Standard: sonnet)
permissionModeNeindefault, acceptEdits, dontAsk, bypassPermissions oder plan
skillsNeinSkills, die in den Subagenten-Kontext vorgeladen werden sollen
hooksNeinLifecycle-Hooks fĂŒr diesen Subagenten
memoryNeinPersistenter Speicherbereich: user, project oder local
isolationNeinAuf worktree setzen, um den Agenten in einem isolierten git-Worktree auszufĂŒhren
backgroundNeinAuf true setzen, um den Agenten als Hintergrundaufgabe auszufĂŒhren

Warum dieser Wechsel wichtig ist

Betriebliche Vorteile

  • Weniger Kontextwechsel: Du bleibst in einem mentalen Modus; Agenten erledigen den Rest.
  • Sauberere PRs: Enge Prompts + begrenzte Tools → kleinere, reviewfĂ€hige Diffs.
  • Weniger Regressionen: Tester-/Reviewer-Agenten fangen LĂŒcken vor dem Merge ab.
  • Wiederholbarkeit: Prompts + Richtlinien leben im Repo und wandern mit Branches.

Sicherheit & Governance

  • Schreibzugriff nach Pfad begrenzen (z.B. src/, tests/, docs/).
  • Nur-Lesen-Analyse fĂŒr risikoreiche Bereiche bevorzugen.
  • Assistent-Ausgaben als Patches fĂŒr Nachvollziehbarkeit protokollieren/committen.

Ein Denkweise-Wandel

Tue

  • Agenten als Teammitglieder mit Stellenbeschreibungen behandeln.
  • Mit nur-lesen anfangen; Schreibzugriff zuletzt gewĂ€hren.
  • Prompts in Versionskontrolle halten und via PR iterieren.

Tue nicht

  • Einen Agenten bitten, in einer einzigen Runde zu planen, zu programmieren und zu testen.
  • Pauschalen Schreibzugriff geben.
  • Mehrdatei-Diffs akzeptieren, wenn du nach einem Test gefragt hast.

Agenten-Teams (Forschungsvorschau)

[!Note] Agenten-Teams ist eine experimentelle Funktion, die es mehreren Claude-Instanzen ermöglicht, parallel autonom an einer gemeinsamen Codebase zu arbeiten.

Agenten-Teams aktivieren:

export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

Kernkonzepte:

  • Mehrere Claude-Instanzen laufen parallel auf derselben Codebase
  • Jeder Agent kann sich auf verschiedene Aufgaben spezialisieren (Debugging, Dokumentation, Tests usw.)
  • Agenten kommunizieren ĂŒber git-basierte Synchronisation
  • Ermöglicht autonome, langfristige Entwicklungsworkflows

Fallstudie: C-Compiler gebaut von Agenten-Teams

Anthropics Forschungsteam demonstrierte Agenten-Teams, indem es 16 parallele Claude-Instanzen beauftragte, einen C-Compiler von Grund auf zu bauen. Ergebnisse:

KennzahlWert
Claude-Sitzungen~2.000
API-Kosten~20.000 $
Codezeilen100.000
FĂ€higkeitKompilierte Linux 6.9 auf x86, ARM, RISC-V
Test-Bestehensrate99% auf GCC-Torture-Test-Suite

Erkenntnisse fĂŒr Agenten-Teams:

  1. Hochwertige Tests schreiben — Der Task-Verifizierer muss nahezu perfekt sein
  2. FĂŒr ParallelitĂ€t entwerfen — Agenten sollten unabhĂ€ngig arbeiten können
  3. Agenten spezialisieren — Agenten fĂŒr spezifische Rollen dedizieren
  4. Kontextdateien pflegen — READMEs und Fortschrittsdateien aktuell halten

VollstÀndige Fallstudie lesen: Building a C Compiler with Parallel Claudes

Skills (Benutzerdefinierte Slash-Befehle)

[!Note] Skills erweitern was Claude tun kann. Eine SKILL.md-Datei mit Anweisungen erstellen, und Claude fĂŒgt sie seinem Toolkit hinzu. Claude verwendet Skills, wenn relevant, oder du kannst einen direkt mit /skill-name aufrufen.

Skill-Speicherorte

SpeicherortBereichBeschreibung
~/.claude/skills/<skill-name>/SKILL.mdPersönlichAlle deine Projekte
.claude/skills/<skill-name>/SKILL.mdProjektNur dieses Projekt (in Versionskontrolle)
<plugin>/skills/<skill-name>/SKILL.mdPluginWo Plugin aktiviert ist

Projekt-Skills ĂŒberschreiben persönliche Skills mit demselben Namen. Dateien in .claude/commands/ funktionieren weiterhin und unterstĂŒtzen dasselbe Frontmatter.

Einen Skill erstellen

# Skill-Verzeichnis erstellen
mkdir -p ~/.claude/skills/explain-code

~/.claude/skills/explain-code/SKILL.md erstellen:

---
name: explain-code
description: Explains code with visual diagrams and analogies. Use when explaining how code works.
---

When explaining code, always include:

1. **Start with an analogy**: Compare the code to something from everyday life
2. **Draw a diagram**: Use ASCII art to show the flow, structure, or relationships
3. **Walk through the code**: Explain step-by-step what happens
4. **Highlight a gotcha**: What's a common mistake or misconception?

Skill verwenden:

# Claude automatisch aufrufen lassen
How does this code work?

# Oder direkt aufrufen
/explain-code src/auth/login.ts

Skill-Frontmatter-Felder

FeldErforderlichBeschreibung
nameNeinAnzeigename fĂŒr den Skill (verwendet Verzeichnisname, wenn weggelassen)
descriptionEmpfohlenWas der Skill tut und wann er verwendet werden soll
argument-hintNeinHinweis bei der AutovervollstÀndigung (z.B. [filename])
disable-model-invocationNeinAuf true setzen, um automatischen Aufruf durch Claude zu verhindern
user-invocableNeinAuf false setzen, um aus dem /-MenĂŒ auszublenden
allowed-toolsNeinTools, die Claude ohne Berechtigungsanfrage verwenden kann
modelNeinZu verwendendes Modell, wenn dieser Skill aktiv ist
contextNeinAuf fork setzen, um in einem geforkten Subagenten-Kontext zu laufen
agentNeinWelcher Subagent verwendet werden soll, wenn context: fork gesetzt ist
hooksNeinHooks fĂŒr den Lifecycle dieses Skills

Argumente an Skills ĂŒbergeben

$ARGUMENTS-Platzhalter verwenden, um Argumente zu empfangen:

---
name: fix-issue
description: Fix a GitHub issue
disable-model-invocation: true
---

Fix GitHub issue $ARGUMENTS following our coding standards.

1. Read the issue description
2. Implement the fix
3. Write tests
4. Create a commit

Verwendung: /fix-issue 123

Dynamischen Kontext einfĂŒgen

!`command`-Syntax verwenden, um Shell-Befehle vor dem Skill-Inhalt auszufĂŒhren:

---
name: pr-summary
description: Summarize changes in a pull request
context: fork
agent: Explore
---

## Pull request context

- PR diff: !`gh pr diff`
- PR comments: !`gh pr view --comments`
- Changed files: !`gh pr diff --name-only`

## Your task

Summarize this pull request...

Skills in einem Subagenten ausfĂŒhren

context: fork hinzufĂŒgen, um einen Skill isoliert auszufĂŒhren:

---
name: deep-research
description: Research a topic thoroughly
context: fork
agent: Explore
---

Research $ARGUMENTS thoroughly:

1. Find relevant files using Glob and Grep
2. Read and analyze the code
3. Summarize findings with specific file references

Das agent-Feld kann Explore, Plan, general-purpose oder ein beliebiger benutzerdefinierter Subagent aus .claude/agents/ sein.

Plugin-System

[!Note] Plugins erweitern Claude Code mit benutzerdefinierten Befehlen, Skills, Agenten, Hooks und MCP-Servern. Plugins können aus lokalen Verzeichnissen, Git-Repos oder der npm-Registry geladen werden.

Hauptbefehle:

# Plugin aus Git-Repository installieren
/plugins install https://github.com/org/claude-plugin-example

# Aus npm-Registry installieren
/plugins install @org/claude-code-plugin

# Installierte Plugins auflisten
/plugins list

# Plugin aktivieren / deaktivieren
/plugins enable <plugin-name>
/plugins disable <plugin-name>

# Struktur eines Plugins validieren
/plugins validate ./my-plugin

# Plugin-Marktplatz durchsuchen (Community-Plugins)
/plugins marketplace

Plugin-Struktur:

my-plugin/
├── plugin.json          # Plugin-Manifest (Name, Version, Beschreibung)
├── agents/              # Benutzerdefinierte Agenten (*.md-Frontmatter-Dateien)
├── skills/              # Benutzerdefinierte Skills (SKILL.md-Dateien)
├── hooks/               # Hook-Skripte
├── commands/            # Benutzerdefinierte Slash-Befehle
└── mcp-servers/         # MCP-Server-Konfigurationen

Plugin-Bereiche:

SpeicherortBereichHinweise
--plugin-dir ./pathNur SitzungCLI-Flag, nicht persistent
.claude/plugins/ProjektMit dem Repo committet
~/.claude/plugins/Nutzer-globalVerfĂŒgbar in allen Projekten

Plugin-Manifest (plugin.json):

{
  "name": "my-plugin",
  "version": "1.0.0",
  "description": "A Claude Code plugin",
  "agents": ["agents/"],
  "skills": ["skills/"],
  "hooks": "hooks/hooks.json",
  "mcpServers": "mcp-servers/servers.json"
}

Plugins werden standardmĂ€ĂŸig automatisch aktualisiert. FORCE_AUTOUPDATE_PLUGINS=1 setzen, um Updates auch bei deaktiviertem Haupt-Updater zu erzwingen.

Worktree-Isolation (v2.1.49+)

[!Note] Das Flag --worktree (-w) startet Claude in einem isolierten git-Worktree, sodass Änderungen in einem separaten Branch vorgenommen werden können, ohne das Arbeitsverzeichnis zu beeinflussen.

Verwendung:

# Claude in einem isolierten Worktree starten
claude -w "implement the new feature"

# Claude wird:
# 1. Einen temporÀren git-Worktree aus dem aktuellen Branch erstellen
# 2. In diesem isolierten Worktree laufen
# 3. Änderungen committen und optional einen PR erstellen
# 4. Den Worktree nach Abschluss bereinigen

Worktree-Isolation auf Agenten-Ebene:

---
name: background-coder
description: Implements features in isolation
isolation: worktree
background: true
---

Implement the requested feature in this isolated worktree.

Worktree-Isolation ist besonders leistungsstark in Kombination mit background: true fĂŒr Agenten, was parallele Entwicklungsworkflows ermöglicht.

Nativer Installer (v2.1.15+)

[!Note] Claude Code bietet jetzt einen nativen BinÀr-Installer als Alternative zur globalen npm-Installation. Der native Installer bietet schnelleren Start, automatische Updates und erfordert kein Node.js im PATH.

# Nativen Installer starten (interaktiv)
claude install

# Von npm-globalinstallation zum nativen Installer migrieren
claude migrate-installer

# Windows ARM64 wird seit v2.1.41 nativ unterstĂŒtzt

Die npm-Installationsmethode (npm install -g @anthropic-ai/claude-code) funktioniert weiterhin. In v2.1.15 wurde ein Veraltungshinweis fĂŒr npm-basierte Installationen eingefĂŒhrt, aber beide Methoden werden unterstĂŒtzt.

Authentifizierungs-CLI (v2.1.41+)

[!Note] Authentifizierung direkt ĂŒber die CLI verwalten, ohne das REPL zu betreten.

# Beim Anthropic-Konto anmelden
claude auth login

# Aktuellen Authentifizierungsstatus prĂŒfen
claude auth status

# Abmelden
claude auth logout

Agentenverwaltungs-CLI (v2.1.50+)

[!Note] Alle konfigurierten Agenten ĂŒber die Befehlszeile auflisten und inspizieren.

# Alle Agenten auflisten (Projekt, Nutzer, Plugin, CLI-definiert)
claude agents

Fernsteuerung (v2.1.51+)

[!Note] Der Unterbefehl claude remote-control ermöglicht es externen Tools und Build-Systemen, Claude Code programmatisch zu steuern.

# Claude im Fernsteuerungsmodus starten
claude remote-control

NĂŒtzlich fĂŒr IDE-Erweiterungen, CI/CD-Pipelines oder benutzerdefinierte Orchestrierungs-Tools, die ĂŒber die SDK-Schnittstelle mit Claude Code interagieren möchten.

Verwaltete Einstellungen (v2.1.51+)

[!Note] Enterprise-Administratoren können verwaltete Einstellungen ĂŒber macOS-plist oder Windows-Registry pushen und so organisationsweite Konfigurationskontrolle bereitstellen.

macOS (plist):

Einstellungen können ĂŒber MDM-Profile nach /Library/Managed Preferences/com.anthropic.claude-code.plist verteilt werden.

Windows (Registry):

Einstellungen können ĂŒber Gruppenrichtlinien nach HKLM\SOFTWARE\Policies\Anthropic\ClaudeCode verteilt werden.

Verwaltete Einstellungen haben Vorrang vor Nutzer-/Projekteinstellungen und können von einzelnen Nutzern nicht ĂŒberschrieben werden.

Modell-Updates

Claude Sonnet 4.6 (17. Februar 2026)​

[!Note] Claude Sonnet 4.6 liefert Frontier-Level-Performance zu Sonnet-Preisen (3 /15/15 pro Million Tokens) mit einem 1-M-Token-Kontextfenster.

Highlights:

  • NĂ€hert sich Opus-Level-Performance bei Coding-, Reasoning- und Agenten-Planungsaufgaben
  • 1-M-Token-Kontextfenster (zuvor nur im Max-Plan fĂŒr Sonnet 4.5 verfĂŒgbar)
  • Verbesserte Coding-Benchmarks: deutliche Gewinne bei SWE-bench, agentischem Coding und Mehrdatei-Refactoring
  • Besseres Langkontext-Reasoning: verbesserte Genauigkeit bei Nadel-im-Heuhaufen- und Langdokument-Aufgaben
  • Verbesserte Computernutzung: zuverlĂ€ssigere Browser-Automatisierung und GUI-Interaktion
  • Gleiche Preise wie Sonnet 4.5: 3 Eingabe/15Eingabe / 15 Ausgabe pro Million Tokens

In Claude Code verwenden:

# Als Standard-Modell setzen
claude --model sonnet

# Oder spezifische Version festlegen
claude --model claude-sonnet-4-6-20260217

# In Einstellungen konfigurieren
claude config set model "claude-sonnet-4-6-20260217"

Sonnet 4.5 mit 1-M-Kontext wurde aus dem Max-Plan zugunsten von Sonnet 4.6 entfernt. Claude Opus 4.6 (veröffentlicht in v2.1.32) bleibt fĂŒr die anspruchsvollsten Aufgaben verfĂŒgbar.

Claude Code Insights

[!Note] Der /insights-Befehl generiert einen interaktiven HTML-Bericht, der deine Coding-Gewohnheiten der letzten 30 Tage analysiert.

Insights ausfĂŒhren:

# Im Claude Code-Terminal
/insights

# Generierten Bericht öffnen
start ~/.claude/usage-data/report.html     # Windows
open ~/.claude/usage-data/report.html      # Mac
xdg-open ~/.claude/usage-data/report.html  # Linux

Funktionsweise:

  1. Sitzungssammlung — Sitzungsprotokolle aus ~/.claude/projects/ abrufen, Subagenten-Sitzungen und kurze Sitzungen filtern
  2. Metadaten-Extraktion — Dauer, Token-Nutzung, verwendete Tools, erkannte Sprachen, git-AktivitĂ€t extrahieren
  3. Facetten-Extraktion — Haiku-Modell zur Analyse von Transkripten und Identifikation von Zielen, Zufriedenheitssignalen, Reibungspunkten verwenden
  4. Berichtsgenerierung — Interaktiven HTML-Bericht mit personalisierten VorschlĂ€gen erstellen

Berichtsabschnitte:

AbschnittBeschreibung
Was funktioniertDeine StÀrken und erfolgreichen Muster
Was hindertWo Claude Schwierigkeiten hatte oder wo du Reibung verursacht hast
ReibungsanalyseAufschlĂŒsselung von Problembereichen mit spezifischen Beispielen
Stats-DashboardTool-Nutzung, SprachaufschlĂŒsselung, Coding-Zeitverteilung
Schnelle GewinneKopier-einfĂŒg-VorschlĂ€ge fĂŒr CLAUDE.md-Verbesserungen
Funktionen ausprobierenPersonalisierte Empfehlungen (Skills, Hooks, Headless-Modus)

Alles lÀuft lokal mit der Anthropic-API. Sitzungsdaten bleiben auf deinem GerÀt.

MCP-Integration

MCP (Model Context Protocol) verstehen

Was ist MCP?​

MCP erweitert Claudes FĂ€higkeiten durch Verbindung mit externen Diensten, Datenbanken, APIs und Tools (Dateisystem, Puppeteer, GitHub, Context7 usw.)

MCP-Architektur:​
Claude Code ←→ MCP-Protokoll ←→ MCP-Server ←→ Externe Dienste

claude.ai MCP-Konnektoren

Claude Code kann MCP-Server verwenden, die in deinem claude.ai-Konto konfiguriert sind, und bringt Cloud-gehostete Tools in deinen CLI-Workflow.

# StandardmĂ€ĂŸig aktiviert — zum Deaktivieren:
export ENABLE_CLAUDEAI_MCP_SERVERS=false

So kannst du dieselben MCP-Tool-Integrationen, die in claude.ai verfĂŒgbar sind, direkt ĂŒber die Befehlszeile nutzen, ohne lokale MCP-Server-Konfiguration.

MCP-Einrichtung & Konfiguration

Grundlegende MCP-Befehle​
claude mcp                   # Interaktive MCP-Konfiguration
claude mcp list              # Konfigurierte Server auflisten
claude mcp add <name> <cmd>  # Neuen Server hinzufĂŒgen
claude mcp remove <name>     # Server entfernen
MCP-Konfigurationsdatei-Speicherort​
~/.claude.json      # Globale Datei
`.mcp.json`         # Projektbezogene Server werden in einer Datei im Projektstammverzeichnis gespeichert

Schnellstart​

Der schnellste Weg zum HinzufĂŒgen:

# Dateisystemzugriff hinzufĂŒgen (am hĂ€ufigsten verwendet)
claude mcp add filesystem -s user -- npx -y @modelcontextprotocol/server-filesystem ~/Documents ~/Desktop

# ÜberprĂŒfen ob erfolgreich
claude mcp list

Antwort bei Erfolg:

image

Weitere Methoden:​

1. Befehlszeilen-HinzufĂŒgung​

Claude Code bietet einfache Befehlszeilen-Tools zum HinzufĂŒgen von MCP-Servern:

# Grundlegende Syntax
claude mcp add <name> <command> [parameters...]

# Konkretes Beispiel: Lokalen Dateisystemzugriff hinzufĂŒgen
claude mcp add my-filesystem -- npx -y @modelcontextprotocol/server-filesystem ~/Documents

# Beispiel mit Umgebungsvariablen
claude mcp add api-server -e API_KEY=your-key-here -- /path/to/server

OAuth fĂŒr MCP-Server:

# MCP-Server mit vorkonfigurierten OAuth-Anmeldedaten hinzufĂŒgen
claude mcp add <name> --client-id <id> --client-secret <secret> -- <cmd>

Einige MCP-Server (z.B. Slack) unterstĂŒtzen keine Dynamic Client Registration und erfordern vorkonfigurierte OAuth-Anmeldedaten.

2. Direkte Konfigurationsdatei-Bearbeitung​

Viele Entwickler finden CLI-Assistenten zu umstÀndlich, besonders wenn bei einem Fehler neu gestartet werden muss.

Direkte Konfigurationsdatei-Bearbeitung ist effizienter:

1. Konfigurationsdatei-Speicherort finden:

  • macOS/Linux: ~/.claude.json
  • Windows: %USERPROFILE%\.claude.json

2. Konfigurationsdatei bearbeiten:

{
  "mcpServers": {
    "filesystem": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/username/Documents"
      ],
      "env": {}
    },
    "github": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "your-github-token"
      }
    }
  }
}

3. Claude Code neu starten, damit Änderungen wirksam werden

3. Projektkonfiguration (empfohlen fĂŒr Teamzusammenarbeit)​

Wenn alle Teammitglieder dieselbe MCP-Konfiguration verwenden sollen:

# MCP-Server auf Projektebene hinzufĂŒgen
claude mcp add shared-tools -s project -- npx -y @your-team/mcp-tools

Dadurch wird eine .mcp.json-Datei im Projektstammverzeichnis erstellt:

{
  "mcpServers": {
    "shared-tools": {
      "command": "npx",
      "args": ["-y", "@your-team/mcp-tools"],
      "env": {}
    }
  }
}

Detaillierte MCP-Server-Bereiche​

Das VerstÀndnis der Bereiche ist entscheidend, um "Server nicht gefunden"-Fehler zu vermeiden:

1. Lokaler Bereich (Standard)​

  • Nur im aktuellen Verzeichnis verfĂŒgbar
  • Konfiguration im Projektsabschnitt von ~/.claude.json gespeichert
  • Geeignet fĂŒr: persönliche projektspezifische Tools

2. Nutzer-Bereich (Global)​

  • In allen Projekten verfĂŒgbar
  • Mit -s user-Flag hinzugefĂŒgt
  • Geeignet fĂŒr: gĂ€ngige Tools wie Dateisysteme, Datenbankclients

3. Projekt-Bereich (Team-geteilt)​

  • Über .mcp.json-Datei geteilt
  • Mit -s project-Flag hinzugefĂŒgt
  • Geeignet fĂŒr: team-geteilte projektspezifische Tools

Praktische MCP-Server-Empfehlungen​

Die lohnenswertesten MCP-Server zum Installieren:

1. Dateisystemzugriff​

claude mcp add filesystem -s user -- npx -y @modelcontextprotocol/server-filesystem ~/Documents ~/Projects ~/Desktop

Verwendung: Claude direkt Dateien lesen und schreiben, Code Àndern lassen

2. GitHub-Integration​

claude mcp add github -s user -e GITHUB_TOKEN=your-token -- npx -y @modelcontextprotocol/server-github

Verwendung: Issues, PRs, Code-Reviews verwalten

3. Web-Browser-Steuerung​

claude mcp add puppeteer -s user -- npx -y @modelcontextprotocol/server-puppeteer

Verwendung: Automatisierte Web-Operationen, Crawling, Tests

4. Datenbankverbindung (PostgreSQL)​

claude mcp add postgres -s user -e DATABASE_URL=your-db-url -- npx -y @modelcontextprotocol/server-postgres

Verwendung: Datenbanken direkt abfragen und manipulieren

5. Fetch-Tool (API-Aufrufe)​

claude mcp add fetch -s user -- npx -y @kazuph/mcp-fetch

Verwendung: Verschiedene REST-APIs aufrufen

6. Suchmaschine​

claude mcp add search -s user -e BRAVE_API_KEY=your-key -- npx -y @modelcontextprotocol/server-brave-search

Verwendung: Nach aktuellen Informationen suchen

7. Slack-Integration​

claude mcp add slack -s user -e SLACK_TOKEN=your-token -- npx -y @modelcontextprotocol/server-slack

Verwendung: Nachrichten senden, KanÀle verwalten

8. Zeitverwaltung​

claude mcp add time -s user -- npx -y @modelcontextprotocol/server-time

Verwendung: Zeitzonenkonvertierung, Datumsberechnung

9. Speicherung​

claude mcp add memory -s user -- npx -y @modelcontextprotocol/server-memory

Verwendung: Informationen ĂŒber GesprĂ€che hinweg speichern

10. Sequenzielles Denken (Gedankenkette)​

claude mcp add thinking -s user -- npx -y @modelcontextprotocol/server-sequential-thinking

Verwendung: Schrittweises Denken fĂŒr komplexe Probleme

HĂ€ufige Fehler und Lösungen​

Fehler 1: Tool-Name-Validierung fehlgeschlagen​

API Error 400: "tools.11.custom.name: String should match pattern '^[a-zA-Z0-9_-]{1,64}$'"

Lösung:

  • Servername darf nur Buchstaben, Zahlen, Unterstriche und Bindestriche enthalten
  • NamenslĂ€nge darf 64 Zeichen nicht ĂŒberschreiten
  • Keine Sonderzeichen oder Leerzeichen verwenden

Fehler 2: MCP-Server nicht gefunden​

MCP server 'my-server' not found

Lösung:

  1. PrĂŒfen ob Bereichseinstellungen korrekt sind
  2. claude mcp list ausfĂŒhren um zu bestĂ€tigen, dass Server hinzugefĂŒgt wurde
  3. Sicherstellen, dass man im richtigen Verzeichnis ist (fĂŒr lokalen Bereich)
  4. Claude Code neu starten

Fehler 3: Protokollversionsfehler​

"protocolVersion": "Required"

Lösung: Dies ist ein bekannter Bug in Claude Code, vorĂŒbergehende Lösungen:

  1. Wrapper-Skripte verwenden
  2. Sicherstellen, dass MCP-Server die korrekte Protokollversion zurĂŒckgibt
  3. Auf die neueste Version von Claude Code aktualisieren

Fehler 4: Windows-Pfadprobleme​

Error: Cannot find module 'C:UsersusernameDocuments'

Lösung: Windows-Pfade mĂŒssen SchrĂ€gstriche oder doppelte Backslashes verwenden:

# Falsch
claude mcp add fs -- npx -y @modelcontextprotocol/server-filesystem C:\Users\username\Documents

# Richtig
claude mcp add fs -- npx -y @modelcontextprotocol/server-filesystem C:/Users/username/Documents
# oder
claude mcp add fs -- npx -y @modelcontextprotocol/server-filesystem C:\\Users\\username\\Documents

Fehler 5: Berechtigungsprobleme​

Permission denied

Lösung:

  1. macOS/Linux: sudo verwenden (nicht empfohlen) oder Dateiberechtigungen Àndern
  2. Windows: Als Administrator ausfĂŒhren
  3. Beste Methode: MCP-Server im Benutzerverzeichnis installieren

Debugging-Techniken​

1. Debug-Modus aktivieren​

claude --debug

2. MCP-Status anzeigen​

In Claude Code eingeben:

/mcp

3. Log-Dateien anzeigen​

macOS/Linux:

tail -f ~/Library/Logs/Claude/mcp*.log

Windows:

type "%APPDATA%\Claude\logs\mcp*.log"

4. Server manuell testen​

# Server-Befehl direkt ausfĂŒhren, um Ausgabe zu prĂŒfen
npx -y @modelcontextprotocol/server-filesystem ~/Documents

Best-Practice-Empfehlungen​

  1. Bei Bedarf hinzufĂŒgen: Nicht zu viele MCP-Server auf einmal hinzufĂŒgen, das beeintrĂ€chtigt die Performance
  2. RegelmĂ€ĂŸig bereinigen: claude mcp remove <name> zum Löschen ungenutzter Server verwenden
  3. Sicherheit zuerst: Nur vertrauenswĂŒrdige MCP-Server hinzufĂŒgen, besonders solche mit Netzwerkzugriff
  4. Konfiguration sichern: ~/.claude.json-Datei regelmĂ€ĂŸig sichern
  5. Teamzusammenarbeit: Projektbereich fĂŒr gemeinsame Konfigurationen verwenden

Erweiterte Techniken​

1. Benutzerdefinierten MCP-Server erstellen​

Wenn vorhandene MCP-Server deine Anforderungen nicht erfĂŒllen:

// my-mcp-server.js
import { Server } from "@modelcontextprotocol/sdk";

const server = new Server({
  name: "my-custom-server",
  version: "1.0.0",
});

server.setRequestHandler("tools/list", async () => {
  return {
    tools: [
      {
        name: "my_custom_tool",
        description: "Custom tool",
        inputSchema: {
          type: "object",
          properties: {
            input: { type: "string" },
          },
        },
      },
    ],
  };
});

server.start();

2. Batch-Konfigurationsskript​

Skript zur Konfiguration aller gÀngigen MCP-Server auf einmal erstellen:

#!/bin/bash
# setup-mcp.sh

echo "Konfiguriere gÀngige MCP-Server..."

# Dateisystem
claude mcp add filesystem -s user -- npx -y @modelcontextprotocol/server-filesystem ~/Documents ~/Projects

# GitHub
read -p "GitHub-Token eingeben: " github_token
claude mcp add github -s user -e GITHUB_TOKEN=$github_token -- npx -y @modelcontextprotocol/server-github

# Weitere Server...

echo "MCP-Server erfolgreich konfiguriert!"

Entwicklungs-Tools​

# npm install -g git-mcp-server

# claude mcp add git "git-mcp-server"
# claude mcp add github "github-mcp-server --token $GITHUB_TOKEN"

Datenbankintegration​

npm install -g postgres-mcp-server
npm install -g mysql-mcp-server
npm install -g sqlite-mcp-server

# Einrichtungsbeispiele können so aussehen:
# export POSTGRES_URL="postgresql://user:password@localhost:5432/mydb"
# claude mcp add postgres "postgres-mcp-server --url $POSTGRES_URL"

MCP-Tool-Berechtigungen​

# Bestimmte MCP-Tools erlauben
claude --allowedTools "mcp__git__commit,mcp__git__push"

# Alle Tools von einem bestimmten Server erlauben
claude --allowedTools "mcp__postgres__*"

# Kombiniert mit eingebauten Tools
claude --allowedTools "Edit,View,mcp__git__*"

Hooks-System

Diese Seite bietet Referenzdokumentation zur Implementierung von Hooks in Claude Code.

[!TIP] FĂŒr einen Schnellstart-Leitfaden mit Beispielen siehe Einstieg mit Claude Code Hooks.

Konfiguration

Claude Code Hooks werden in deinen Einstellungsdateien konfiguriert:

  • ~/.claude/settings.json — Nutzereinstellungen
  • .claude/settings.json — Projekteinstellungen
  • .claude/settings.local.json — Lokale Projekteinstellungen (nicht committet)
  • Enterprise-verwaltete Richtlinieneinstellungen

Struktur​

Hooks sind nach Matchern organisiert, wobei jeder Matcher mehrere Hooks haben kann:

{
  "hooks": {
    "EventName": [
      {
        "matcher": "ToolPattern",
        "hooks": [
          {
            "type": "command",
            "command": "your-command-here"
          }
        ]
      }
    ]
  }
}

HTTP-Hooks (v2.1.63+)​

ZusÀtzlich zu Shell-Befehlen können Hooks JSON an eine URL POSTen und eine JSON-Antwort empfangen:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "http",
            "url": "https://hooks.example.com/validate",
            "timeout": 10
          }
        ]
      }
    ]
  }
}

HTTP-Hooks senden denselben JSON-Payload, den command-Hooks ĂŒber stdin empfangen, als POST-Body. Das Antwort-JSON folgt demselben Ausgabe-Schema. NĂŒtzlich fĂŒr zentrale Richtliniendurchsetzung oder Remote-Hook-AusfĂŒhrung ohne lokale Skripte.

  • matcher: Muster zum Abgleichen von Tool-Namen, Groß-/Kleinschreibung beachten (nur fĂŒr PreToolUse und PostToolUse)
    • Einfache Strings stimmen genau ĂŒberein: Write stimmt nur mit dem Write-Tool ĂŒberein
    • UnterstĂŒtzt Regex: Edit|Write oder Notebook.*
    • * zum Abgleichen aller Tools verwenden.
  • hooks: Array von Befehlen, die ausgefĂŒhrt werden, wenn das Muster ĂŒbereinstimmt
    • type: "command" (Shell-Befehl) oder "http" (JSON an URL POSTen, v2.1.63+)
    • command: AuszufĂŒhrender Bash-Befehl (kann $CLAUDE_PROJECT_DIR-Umgebungsvariable verwenden)
    • timeout: (Optional) Wie lange ein Befehl laufen soll (in Sekunden) bevor er abgebrochen wird.

FĂŒr Ereignisse wie UserPromptSubmit, Notification, Stop und SubagentStop, die keine Matcher verwenden, kann das Matcher-Feld weggelassen werden:

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "/path/to/prompt-validator.py"
          }
        ]
      }
    ]
  }
}

Projektspezifische Hook-Skripte​

Die Umgebungsvariable CLAUDE_PROJECT_DIR (nur verfĂŒgbar, wenn Claude Code den Hook-Befehl startet) kann verwendet werden, um auf Skripte im Projekt zu verweisen:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/check-style.sh"
          }
        ]
      }
    ]
  }
}

Hook-Ereignisse

PreToolUse​

LĂ€uft nachdem Claude Tool-Parameter erstellt hat und bevor der Tool-Aufruf verarbeitet wird.

HĂ€ufige Matcher:

  • Task — Subagenten-Aufgaben
  • Bash — Shell-Befehle
  • Glob — Datei-Muster-Abgleich
  • Grep — Inhaltssuche
  • Read — Datei-Lesen
  • Edit, MultiEdit — Datei-Bearbeitung
  • Write — Datei-Schreiben
  • WebFetch, WebSearch — Web-Operationen

PostToolUse​

LĂ€uft unmittelbar nachdem ein Tool erfolgreich abgeschlossen wurde.

Erkennt dieselben Matcher-Werte wie PreToolUse.

Notification​

LĂ€uft wenn Claude Code Benachrichtigungen sendet. Benachrichtigungen werden gesendet, wenn:

  1. Claude deine Genehmigung zur Tool-Nutzung benötigt. Beispiel: "Claude benötigt deine Erlaubnis, Bash zu verwenden"
  2. Die Prompt-Eingabe mindestens 60 Sekunden inaktiv war. "Claude wartet auf deine Eingabe"

UserPromptSubmit​

LĂ€uft wenn der Nutzer einen Prompt einreicht, bevor Claude ihn verarbeitet. Ermöglicht das HinzufĂŒgen von zusĂ€tzlichem Kontext, die Validierung von Prompts oder das Blockieren bestimmter Prompt-Typen.

Stop​

LÀuft wenn der Haupt-Claude-Code-Agent aufgehört hat zu antworten. LÀuft nicht, wenn der Stopp durch einen Nutzer-Interrupt verursacht wurde.

SubagentStop​

LÀuft wenn ein Claude Code-Subagent (Task-Tool-Aufruf) aufgehört hat zu antworten.

TeammateIdle​

Wird ausgelöst, wenn ein Agenten-Teamkollege in einem Multi-Agenten-Workflow inaktiv wird.

TaskCompleted​

Wird ausgelöst, wenn eine Hintergrundaufgabe abgeschlossen wird (Multi-Agenten-Workflows).

ConfigChange​

Wird ausgelöst, wenn Claude Code-Konfigurationsdateien sich Ă€ndern (z.B. Einstellungen, CLAUDE.md, .mcp.json). NĂŒtzlich zum Neuladen von externem Zustand oder zum Auslösen von Nebeneffekten bei KonfigurationsĂ€nderungen.

WorktreeCreate​

Wird ausgelöst, wenn Claude einen neuen git-Worktree erstellt. NĂŒtzlich zum Einrichten worktree-spezifischer Ressourcen.

WorktreeRemove​

Wird ausgelöst, wenn ein git-Worktree nach der Verwendung bereinigt wird. NĂŒtzlich zum Abbau worktree-spezifischer Ressourcen.

Setup​

Ausgelöst durch --init, --init-only oder --maintenance CLI-Flags. NĂŒtzlich fĂŒr einmalige Projekteinrichtungsaufgaben, Plugin-Installation oder Wartungsskripte.

PermissionRequest​

Wird ausgelöst, wenn Claude dem Nutzer eine Berechtigungsaufforderung anzeigt. NĂŒtzlich fĂŒr die Protokollierung oder Automatisierung von Berechtigungsentscheidungen.

PreCompact​

LĂ€uft bevor Claude Code eine Komprimierungsoperation durchfĂŒhrt.

Matcher:

  • manual — Aufgerufen von /compact
  • auto — Aufgerufen von Auto-Compact (wegen vollem Kontextfenster)

SessionStart​

LĂ€uft wenn Claude Code eine neue Sitzung startet oder eine vorhandene Sitzung fortsetzt. NĂŒtzlich fĂŒr das Laden von Entwicklungskontext wie vorhandenen Issues oder aktuellen Änderungen.

Matcher:

  • startup — Aufgerufen beim Start
  • resume — Aufgerufen von --resume, --continue oder /resume
  • clear — Aufgerufen von /clear

Hook-Eingabe

Hooks empfangen JSON-Daten ĂŒber stdin mit Sitzungsinformationen und ereignisspezifischen Daten:

{
  // Gemeinsame Felder
  session_id: string
  transcript_path: string  // Pfad zur GesprÀchs-JSON
  cwd: string              // Aktuelles Arbeitsverzeichnis beim Hook-Aufruf

  // Ereignisspezifische Felder
  hook_event_name: string
  ...
}

PreToolUse-Eingabe​

{
  "session_id": "abc123",
  "transcript_path": "/Users/.../.claude/projects/.../00893aaf-19fa-41d2-8238-13269b9b3ca0.jsonl",
  "cwd": "/Users/...",
  "hook_event_name": "PreToolUse",
  "tool_name": "Write",
  "tool_input": {
    "file_path": "/path/to/file.txt",
    "content": "file content"
  }
}

PostToolUse-Eingabe​

{
  "session_id": "abc123",
  "transcript_path": "/Users/.../.claude/projects/.../00893aaf-19fa-41d2-8238-13269b9b3ca0.jsonl",
  "cwd": "/Users/...",
  "hook_event_name": "PostToolUse",
  "tool_name": "Write",
  "tool_input": {
    "file_path": "/path/to/file.txt",
    "content": "file content"
  },
  "tool_response": {
    "filePath": "/path/to/file.txt",
    "success": true
  }
}

Notification-Eingabe​

{
  "session_id": "abc123",
  "transcript_path": "/Users/.../.claude/projects/.../00893aaf-19fa-41d2-8238-13269b9b3ca0.jsonl",
  "cwd": "/Users/...",
  "hook_event_name": "Notification",
  "message": "Task completed successfully"
}

UserPromptSubmit-Eingabe​

{
  "session_id": "abc123",
  "transcript_path": "/Users/.../.claude/projects/.../00893aaf-19fa-41d2-8238-13269b9b3ca0.jsonl",
  "cwd": "/Users/...",
  "hook_event_name": "UserPromptSubmit",
  "prompt": "Write a function to calculate the factorial of a number"
}

Stop- und SubagentStop-Eingabe​

stop_hook_active ist true, wenn Claude Code bereits als Ergebnis eines Stop-Hooks fortgesetzt wird. Diesen Wert prĂŒfen oder das Transkript verarbeiten, um eine unbegrenzte AusfĂŒhrung zu verhindern.

{
  "session_id": "abc123",
  "transcript_path": "~/.claude/projects/.../00893aaf-19fa-41d2-8238-13269b9b3ca0.jsonl",
  "hook_event_name": "Stop",
  "stop_hook_active": true,
  "last_assistant_message": "I've completed all the requested changes."
}

Das Feld last_assistant_message (v2.1.47+) enthĂ€lt den letzten Text, den Claude vor dem Stopp erzeugt hat. NĂŒtzlich zur VollstĂ€ndigkeitsvalidierung oder Ergebnisprotokollierung.

PreCompact-Eingabe​

{
  "session_id": "abc123",
  "transcript_path": "~/.claude/projects/.../00893aaf-19fa-41d2-8238-13269b9b3ca0.jsonl",
  "hook_event_name": "PreCompact",
  "trigger": "manual",
  "custom_instructions": ""
}

SessionStart-Eingabe​

{
  "session_id": "abc123",
  "transcript_path": "~/.claude/projects/.../00893aaf-19fa-41d2-8238-13269b9b3ca0.jsonl",
  "hook_event_name": "SessionStart",
  "source": "startup"
}

Hook-Ausgabe

Es gibt zwei Wege fĂŒr Hooks, Ausgaben an Claude Code zurĂŒckzugeben. Die Ausgabe teilt mit, ob blockiert werden soll und welches Feedback Claude und dem Nutzer gezeigt werden soll.

Einfach: Exit-Code​

Hooks kommunizieren den Status ĂŒber Exit-Codes, stdout und stderr:

  • Exit-Code 0: Erfolg. stdout wird dem Nutzer im Transkript-Modus (CTRL-R) angezeigt, außer fĂŒr UserPromptSubmit und SessionStart, wo stdout zum Kontext hinzugefĂŒgt wird.
  • Exit-Code 2: Blockierender Fehler. stderr wird zur automatischen Verarbeitung an Claude zurĂŒckgegeben.
  • Andere Exit-Codes: Nicht blockierender Fehler. stderr wird dem Nutzer angezeigt und die AusfĂŒhrung wird fortgesetzt.

[!WARNING] Hinweis: Claude Code sieht stdout nicht, wenn der Exit-Code 0 ist, außer beim UserPromptSubmit-Hook, wo stdout als Kontext eingefĂŒgt wird.

Exit-Code-2-Verhalten​
Hook-EreignisVerhalten
PreToolUseBlockiert den Tool-Aufruf, zeigt stderr an Claude
PostToolUseZeigt stderr an Claude (Tool wurde bereits ausgefĂŒhrt)
NotificationN/V, zeigt stderr nur dem Nutzer
UserPromptSubmitBlockiert Prompt-Verarbeitung, löscht Prompt, zeigt stderr nur dem Nutzer
StopBlockiert das Stoppen, zeigt stderr an Claude
SubagentStopBlockiert das Stoppen, zeigt stderr an Claude-Subagenten
PreCompactN/V, zeigt stderr nur dem Nutzer
SessionStartN/V, zeigt stderr nur dem Nutzer

Erweitert: JSON-Ausgabe​

Hooks können strukturiertes JSON in stdout zurĂŒckgeben fĂŒr ausgefeiltere Kontrolle:

Gemeinsame JSON-Felder​
{
  "continue": true, // Ob Claude nach der Hook-AusfĂŒhrung fortfahren soll (Standard: true)
  "stopReason": "string", // Meldung wenn continue false ist
  "suppressOutput": true // stdout aus dem Transkript-Modus ausblenden (Standard: false)
}
PreToolUse-Entscheidungssteuerung​
  • "allow" umgeht das Berechtigungssystem.
  • "deny" verhindert die AusfĂŒhrung des Tool-Aufrufs.
  • "ask" fordert den Nutzer auf, den Tool-Aufruf in der UI zu bestĂ€tigen.
{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "allow" | "deny" | "ask",
    "permissionDecisionReason": "Mein Grund hier (dem Nutzer angezeigt)"
  }
}
PostToolUse-Entscheidungssteuerung​
  • "block" fordert Claude automatisch mit reason auf.
  • undefined tut nichts.
{
  "decision": "block" | undefined,
  "reason": "BegrĂŒndung fĂŒr Entscheidung"
}
UserPromptSubmit-Entscheidungssteuerung​
  • "block" verhindert die Verarbeitung des Prompts.
  • undefined lĂ€sst den Prompt normal fortfahren.
  • "hookSpecificOutput.additionalContext" fĂŒgt den String zum Kontext hinzu.
{
  "decision": "block" | undefined,
  "reason": "BegrĂŒndung fĂŒr Entscheidung",
  "hookSpecificOutput": {
    "hookEventName": "UserPromptSubmit",
    "additionalContext": "Mein zusÀtzlicher Kontext hier"
  }
}
Stop/SubagentStop-Entscheidungssteuerung​
  • "block" verhindert, dass Claude stoppt. reason muss angegeben werden.
  • undefined lĂ€sst Claude stoppen.
{
  "decision": "block" | undefined,
  "reason": "Muss angegeben werden, wenn Claude am Stoppen gehindert wird"
}
SessionStart-Entscheidungssteuerung​
  • "hookSpecificOutput.additionalContext" fĂŒgt den String zum Kontext hinzu.
{
  "hookSpecificOutput": {
    "hookEventName": "SessionStart",
    "additionalContext": "Mein zusÀtzlicher Kontext hier"
  }
}
Exit-Code-Beispiel: Bash-Befehl-Validierung​
#!/usr/bin/env python3
import json
import re
import sys

VALIDATION_RULES = [
    (
        r"\bgrep\b(?!.*\|)",
        "Use 'rg' (ripgrep) instead of 'grep' for better performance and features",
    ),
    (
        r"\bfind\s+\S+\s+-name\b",
        "Use 'rg --files | rg pattern' or 'rg --files -g pattern' instead of 'find -name' for better performance",
    ),
]


def validate_command(command: str) -> list[str]:
    issues = []
    for pattern, message in VALIDATION_RULES:
        if re.search(pattern, command):
            issues.append(message)
    return issues


try:
    input_data = json.load(sys.stdin)
except json.JSONDecodeError as e:
    print(f"Error: Invalid JSON input: {e}", file=sys.stderr)
    sys.exit(1)

tool_name = input_data.get("tool_name", "")
tool_input = input_data.get("tool_input", {})
command = tool_input.get("command", "")

if tool_name != "Bash" or not command:
    sys.exit(1)

issues = validate_command(command)

if issues:
    for message in issues:
        print(f"‱ {message}", file=sys.stderr)
    sys.exit(2)
JSON-Ausgabe-Beispiel: UserPromptSubmit zum HinzufĂŒgen von Kontext und Validierung​
#!/usr/bin/env python3
import json
import sys
import re
import datetime

try:
    input_data = json.load(sys.stdin)
except json.JSONDecodeError as e:
    print(f"Error: Invalid JSON input: {e}", file=sys.stderr)
    sys.exit(1)

prompt = input_data.get("prompt", "")

sensitive_patterns = [
    (r"(?i)\b(password|secret|key|token)\s*[:=]", "Prompt enthÀlt potenzielle Geheimnisse"),
]

for pattern, message in sensitive_patterns:
    if re.search(pattern, prompt):
        output = {
            "decision": "block",
            "reason": f"Sicherheitsrichtlinienverstoß: {message}. Bitte Anfrage ohne sensible Informationen neu formulieren."
        }
        print(json.dumps(output))
        sys.exit(0)

context = f"Aktuelle Uhrzeit: {datetime.datetime.now()}"
print(context)
sys.exit(0)
JSON-Ausgabe-Beispiel: PreToolUse mit Genehmigung​
#!/usr/bin/env python3
import json
import sys

try:
    input_data = json.load(sys.stdin)
except json.JSONDecodeError as e:
    print(f"Error: Invalid JSON input: {e}", file=sys.stderr)
    sys.exit(1)

tool_name = input_data.get("tool_name", "")
tool_input = input_data.get("tool_input", {})

if tool_name == "Read":
    file_path = tool_input.get("file_path", "")
    if file_path.endswith((".md", ".mdx", ".txt", ".json")):
        output = {
            "decision": "approve",
            "reason": "Dokumentationsdatei automatisch genehmigt",
            "suppressOutput": True
        }
        print(json.dumps(output))
        sys.exit(0)

sys.exit(0)

Arbeiten mit MCP-Tools

Claude Code Hooks funktionieren nahtlos mit Model Context Protocol (MCP)-Tools. Wenn MCP-Server Tools bereitstellen, erscheinen sie mit einem speziellen Benennungsmuster.

MCP-Tool-Benennung​

MCP-Tools folgen dem Muster mcp__<server>__<tool>, zum Beispiel:

  • mcp__memory__create_entities — Create-entities-Tool des Memory-Servers
  • mcp__filesystem__read_file — Read-file-Tool des Filesystem-Servers
  • mcp__github__search_repositories — Such-Tool des GitHub-Servers

Hooks fĂŒr MCP-Tools konfigurieren​

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "mcp__memory__.*",
        "hooks": [
          {
            "type": "command",
            "command": "echo 'Memory operation initiated' >> ~/mcp-operations.log"
          }
        ]
      }
    ]
  }
}

Beispiele

[!TIP] FĂŒr praktische Beispiele einschließlich Code-Formatierung, Benachrichtigungen und Dateischutz siehe Weitere Beispiele im Schnellstart-Leitfaden.

SicherheitsĂŒberlegungen

Haftungsausschluss​

AUF EIGENE GEFAHR: Claude Code Hooks fĂŒhren automatisch beliebige Shell-Befehle auf deinem System aus. Durch die Verwendung von Hooks bestĂ€tigst du:

  • Du bist allein verantwortlich fĂŒr die von dir konfigurierten Befehle
  • Hooks können beliebige Dateien Ă€ndern, löschen oder auf die dein Benutzerkonto Zugriff hat
  • Bösartige oder schlecht geschriebene Hooks können Datenverlust oder SystemschĂ€den verursachen
  • Anthropic ĂŒbernimmt keine Garantie und keine Haftung fĂŒr SchĂ€den aus der Hook-Nutzung
  • Hooks sollten in einer sicheren Umgebung grĂŒndlich getestet werden, bevor sie produktiv eingesetzt werden

Hook-Befehle immer ĂŒberprĂŒfen und verstehen, bevor sie zur Konfiguration hinzugefĂŒgt werden.

Hook-SicherheitsĂŒberlegungen

Wichtige Praktiken fĂŒr sicherere Hooks:

  1. Eingaben validieren und bereinigen — Eingabedaten niemals blind vertrauen
  2. Shell-Variablen immer in AnfĂŒhrungszeichen setzen — "$VAR" statt $VAR verwenden
  3. Pfad-Traversierung blockieren — .. in Dateipfaden prĂŒfen
  4. Absolute Pfade verwenden — VollstĂ€ndige Pfade fĂŒr Skripte angeben
  5. Sensible Dateien ĂŒberspringen — .env, .git/, SchlĂŒssel usw. vermeiden

Konfigurationssicherheit​

Direkte Bearbeitungen von Hooks in Einstellungsdateien werden nicht sofort wirksam. Claude Code:

  1. Erstellt beim Start einen Snapshot der Hooks
  2. Verwendet diesen Snapshot wÀhrend der gesamten Sitzung
  3. Warnt, wenn Hooks extern geÀndert werden
  4. Erfordert ÜberprĂŒfung im /hooks-MenĂŒ, damit Änderungen wirksam werden

Dies verhindert, dass bösartige Hook-Modifikationen die aktuelle Sitzung beeinflussen.

Hook-AusfĂŒhrungsdetails

  • Timeout: StandardmĂ€ĂŸig 60-Sekunden-AusfĂŒhrungslimit, konfigurierbar pro Befehl.
  • Parallelisierung: Alle ĂŒbereinstimmenden Hooks laufen parallel
  • Umgebung: LĂ€uft im aktuellen Verzeichnis mit Claude Codes Umgebung
    • Die CLAUDE_PROJECT_DIR-Umgebungsvariable ist verfĂŒgbar
  • Eingabe: JSON ĂŒber stdin
  • Ausgabe:
    • PreToolUse/PostToolUse/Stop: Fortschritt im Transkript-Modus angezeigt (Ctrl-R)
    • Notification: Nur in Debug protokolliert (--debug)

Debugging

Grundlegende Fehlerbehebung​

Wenn Hooks nicht funktionieren:

  1. Konfiguration prĂŒfen — /hooks ausfĂŒhren, um zu sehen ob der Hook registriert ist
  2. Syntax prĂŒfen — JSON-Einstellungen auf GĂŒltigkeit prĂŒfen
  3. Befehle testen — Hook-Befehle zuerst manuell ausfĂŒhren
  4. Berechtigungen prĂŒfen — Skripte mĂŒssen ausfĂŒhrbar sein
  5. Logs ĂŒberprĂŒfen — claude --debug fĂŒr Hook-AusfĂŒhrungsdetails

HĂ€ufige Probleme:

  • AnfĂŒhrungszeichen nicht maskiert — \" innerhalb von JSON-Strings verwenden
  • Falscher Matcher — Tool-Namen mĂŒssen exakt ĂŒbereinstimmen (Groß-/Kleinschreibung)
  • Befehl nicht gefunden — VollstĂ€ndige Pfade fĂŒr Skripte verwenden

Debug-Ausgabe-Beispiel​

claude --debug fĂŒr Hook-AusfĂŒhrungsdetails verwenden:

[DEBUG] Executing hooks for PostToolUse:Write
[DEBUG] Getting matching hook commands for PostToolUse with query: Write
[DEBUG] Found 1 hook matchers in settings
[DEBUG] Matched 1 hooks for query "Write"
[DEBUG] Found 1 hook commands to execute
[DEBUG] Executing hook command: <Your command> with timeout 60000ms
[DEBUG] Hook command completed with status 0: <Your stdout>

Sicherheit & Berechtigungen

Tool-Berechtigungsmuster​

# Bestimmte Tools erlauben (Dateien lesen/bearbeiten)
claude --allowedTools "Edit,Read"

# Tool-Kategorien einschließlich Bash erlauben (aber noch eingegrenzt)
claude --allowedTools "Edit,Read,Bash"

# Eingegrenzte Berechtigungen (alle git-Befehle)
claude --allowedTools "Bash(git:*)"

# Mehrere Bereiche (git + npm)
claude --allowedTools "Bash(git:*),Bash(npm:*)"

GefÀhrlicher Modus

[!Warning] NIE in Produktionssystemen, gemeinsamen Computern oder Systemen mit wichtigen Daten verwenden! Nur in isolierten Umgebungen wie einem Docker-Container einsetzen — dieser Modus kann Datenverlust verursachen und das System kompromittieren!

claude --dangerously-skip-permissions

Automatisierung & Integration

Automatisierung & Skripting mit Claude Code

GitHub Actions zum Kopieren und EinfĂŒgen :p

  1. Die Claude GitHub App installieren auf deiner Org/dem Repo (erforderlich, damit Actions auf PRs/Issues kommentieren können).
  2. Im Repo ein Secret ANTHROPIC_API_KEY hinzufĂŒgen: Einstellungen → Secrets and variables → Actions → New repository secret
  3. Die folgenden Workflows in .github/workflows/ kopieren.
  4. Einen Test-PR (oder ein neues Issue) öffnen, um sie laufen zu sehen.

[!TIP] Actions bei der LangzeitĂŒbernahme an einen Release-Tag pinnen (z.B. @v1). Die folgenden Snippets verwenden Branch-Tags zur Lesbarkeit.

Automatisches PR-Review (Inline-Kommentare)

Erstellt ein strukturiertes Review (mit Inline-Kommentaren), sobald ein PR geöffnet oder aktualisiert wird.

Datei: .github/workflows/claude-pr-auto-review.yml

name: Auto review PRs
on:
  pull_request:
    types: [opened, synchronize, reopened, ready_for_review]

permissions:
  contents: read
  pull-requests: write

jobs:
  auto-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 1

      - name: Claude PR review
        uses: anthropics/claude-code-action@main
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          direct_prompt: |
            Review this pull request's diff for correctness, readability, testing, performance, and DX.
            Prefer specific, actionable suggestions. Use inline comments where relevant.
          allowed_tools: >-
            mcp__github__get_pull_request_diff,
            mcp__github__create_pending_pull_request_review,
            mcp__github__add_comment_to_pending_review,
            mcp__github__submit_pending_pull_request_review

Sicherheits-Review bei jedem PR

FĂŒhrt einen fokussierten Sicherheitsscan durch und kommentiert Ergebnisse direkt auf dem PR.

Datei: .github/workflows/claude-security-review.yml

name: Security Review
on:
  pull_request:

permissions:
  contents: read
  pull-requests: write

jobs:
  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.pull_request.head.sha || github.sha }}
          fetch-depth: 2

      - name: Claude Code Security Review
        uses: anthropics/claude-code-security-review@main
        with:
          claude-api-key: ${{ secrets.ANTHROPIC_API_KEY }}
          comment-pr: true

Issue-Triage (Labels & Schweregrad vorschlagen)

Wenn ein neues Issue geöffnet wird, schlĂ€gt Claude Labels/Schweregrad vor und postet einen ĂŒbersichtlichen Triage-Kommentar. Auto-Label-Anwendung durch Umschalten eines einzigen Flags aktivieren.

Datei: .github/workflows/claude-issue-triage.yml

name: Claude Issue Triage
on:
  issues:
    types: [opened, edited, reopened]

permissions:
  contents: read
  issues: write

jobs:
  triage:
    runs-on: ubuntu-latest
    env:
      CLAUDE_MODEL: claude-sonnet-4-6-20260217
    steps:
      - name: Collect context & similar issues
        id: gather
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          TITLE="${{ github.event.issue.title }}"
          BODY="${{ github.event.issue.body }}"
          Q=$(echo "$TITLE" | tr -dc '[:alnum:] ' | awk '{print $1" "$2" "$3" "$4}')
          gh api -X GET search/issues -f q="repo:${{ github.repository }} is:issue $Q" -f per_page=5 > similars.json
          echo "$TITLE" > title.txt
          echo "$BODY" > body.txt

      - name: Claude nach Triage-JSON fragen
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          cat > payload.json << 'JSON'
          {
            "model": "${{ env.CLAUDE_MODEL }}",
            "max_tokens": 1500,
            "system": "You are a pragmatic triage engineer. Be specific, cautious with duplicates.",
            "messages": [{"role": "user", "content": [{"type":"text","text":"Given the issue and similar candidates, produce STRICT JSON with keys: labels (array of strings), severity (one of: low, medium, high, critical), duplicate_url (string or empty), comment_markdown (string brief). Do not include any extra keys."}]}]
          }
          JSON
          curl -s https://api.anthropic.com/v1/messages \
            -H "x-api-key: $ANTHROPIC_API_KEY" \
            -H "anthropic-version: 2023-06-01" \
            -H "content-type: application/json" \
            -d @payload.json > out.json
          jq -r '.content[0].text' out.json > triage.json || echo '{}' > triage.json

      - name: Labels anwenden (optional)
        if: ${{ false }} # auf `true` setzen fĂŒr Auto-Labels
        uses: actions/github-script@v7
        with:
          script: |
            const triage = JSON.parse(require('fs').readFileSync('triage.json','utf8'))
            if (triage.labels?.length) {
              await github.rest.issues.addLabels({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: context.issue.number,
                labels: triage.labels
              })
            }

      - name: Triage-Kommentar posten
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs')
            const triage = JSON.parse(fs.readFileSync('triage.json','utf8'))
            const md = `### đŸ€– Triage
            - **Vorgeschlagene Labels:** ${triage.labels?.join(', ') || '—'}
            - **Schweregrad:** ${triage.severity || '—'}
            ${triage.duplicate_url ? `- **Mögliches Duplikat:** ${triage.duplicate_url}\n` : ''}
            ---
            ${triage.comment_markdown || ''}`
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: md
            })

[!NOTE] Der Triage-Workflow postet standardmĂ€ĂŸig einen Vorschlagskommentar. Den Schritt Labels anwenden auf true umschalten, wenn Labels automatisch angewendet werden sollen.

Konfiguration & Anpassung​

  • Modellauswahl: CLAUDE_MODEL setzen (z.B. claude-sonnet-4-6-20260217) wie angegeben.
  • Secrets: ANTHROPIC_API_KEY ist erforderlich. Das integrierte GITHUB_TOKEN reicht fĂŒr das Posten von Kommentaren und Anwenden von Labels aus.
  • Berechtigungen: Jeder Workflow deklariert die mindestens erforderlichen Berechtigungen. Nur anpassen, wenn die Org strengere Richtlinien erfordert.
  • Bereich: paths:-Filter bei Triggern verwenden, um einzuschrĂ€nken, wann Workflows laufen.

Fehlerbehebung​

Zuerst die Actions-Logs prĂŒfen — die meisten Probleme sind fehlende Secrets/Berechtigungen oder falsch eingerĂŒckter YAML-Block.

  • Keine Kommentare auf PRs: PrĂŒfen ob die Claude GitHub App installiert ist und der Workflow die Berechtigung pull-requests: write hat.
  • 403 beim Anwenden von Labels: Sicherstellen, dass der Job/Schritt issues: write hat.
  • Anthropic-API-Fehler: ANTHROPIC_API_KEY auf Repository- (oder Org-)Ebene prĂŒfen.
  • "YAML not well-formed": AbstĂ€nde prĂŒfen — zwei Leerzeichen pro EinrĂŒckungsebene; keine Tabs.

Hilfe & Fehlerbehebung

[!TIP] F: claude nicht gefunden, aber npx claude funktioniert?

A: Dein PATH enthĂ€lt nicht das globale npm-Bin. Siehe den PATH-Abschnitt fĂŒr Windows oder Linux

F: Welche Node.js-Version benötige ich?

A: Node.js 18+ (idealerweise 20+). Mit node --version prĂŒfen.

F: Wo finde ich Logs?

A: claude doctor und claude --verbose ausfĂŒhren — das Diagnosefenster zeigt Log-Speicherorte.

F: Muss ich nach der PATH-Bearbeitung neu starten?

A: Kein Neustart erforderlich, aber du musst ein neues Terminalfenster öffnen.

Debug-Schnellbefehle

Ausgabe von claude doctor fĂŒr Log-Speicherorte und UmgebungsprĂŒfungen ansehen.

[!Note]

claude                  # Claude-UI öffnen (wenn im PATH)
claude --version        # CLI-Version anzeigen (z.B. 1.0.xx)
claude update           # CLI aktualisieren (wenn unterstĂŒtzt)

claude doctor           # Diagnose-/Debug-Fenster öffnen
npx claude /doctor      # Diagnose-/Debug-Fenster öffnen

claude --debug          # Claude mit Diagnose starten
claude --verbose        # Verbose-Protokollierung

where claude            # Windows (cmd)
which claude            # macOS/Linux (bash/zsh)

npm bin -g              # Linux: globalen Bin-Pfad verifizieren
npm prefix -g           # Windows: globalen Bin-Pfad verifizieren

Pfad-Schnellreparatur

Dein PATH enthÀlt wahrscheinlich nicht das globale npm-Bin-Verzeichnis.

[!Note]

Windows (CMD):​

set PATH=%USERPROFILE%\AppData\Roaming\npm;C:\Program Files\nodejs;%PATH%
where claude
claude --debug

Windows (PowerShell):​

$env:Path = "$env:USERPROFILE\AppData\Roaming\npm;C:\Program Files\nodejs;$env:Path"
where claude
claude --debug

Linux/MacOS (bash/zsh)​

export PATH="$(npm config get prefix)/bin:$HOME/.local/bin:$PATH"
which claude
claude doctor

Windows PATH dauerhaft reparieren

<you> durch deinen eigenen Windows-Benutzernamen ersetzen (ohne spitze Klammern)

  • Start → eingeben: Umgebungsvariablen
  • Systemumgebungsvariablen bearbeiten → Umgebungsvariablen öffnen
  • Unter Benutzervariablen fĂŒr <you> Path auswĂ€hlen → Bearbeiten → Neu hinzufĂŒgen:
C:\Users\<you>\AppData\Roaming\npm
C:\Program Files\nodejs

Optionale Speicherorte hinzufĂŒgen:

C:\Users\<you>\.claude\local\bin
C:\Users\<you>\.local\bin
  • Duplikate, EintrĂ€ge mit %PATH% und störende AnfĂŒhrungszeichen (") entfernen. OK klicken.
  • Neues Eingabeaufforderungs-/PowerShell-Fenster öffnen und ĂŒberprĂŒfen:
where claude
claude doctor

[!Tip]

Optional: Direkt ausfĂŒhren (wenn PATH kaputt ist)​

Windows (PowerShell/cmd)

"%USERPROFILE%\AppData\Roaming\npm\claude.cmd" --version
"%USERPROFILE%\AppData\Roaming\npm\claude.cmd" doctor

Oder via npx:

npx claude doctor

Installations- / Node.js-Probleme

Muss Node 18+ sein (20+ empfohlen)

node --version

Saubere Deinstallation

npm uninstall -g @anthropic-ai/claude-code

Neuinstallation

npm install  -g @anthropic-ai/claude-code

Authentifizierungsprobleme

ÜberprĂŒfen ob der Anthropic-API-SchlĂŒssel fĂŒr die CLI verfĂŒgbar ist.

PowerShell (Windows):

echo $env:ANTHROPIC_API_KEY
claude -p "test" --verbose

bash/zsh (macOS/Linux):

echo $ANTHROPIC_API_KEY
claude -p "test" --verbose

Wenn die Variable leer ist, fĂŒr Shell/Profil setzen oder OS-SchlĂŒsselbund/Secrets-Manager verwenden.

Berechtigungs- / Allowed-Tools-Probleme

Berechtigungen prĂŒfen

claude config get allowedTools

Berechtigungen zurĂŒcksetzen

claude config set allowedTools "[]"

Minimales sicheres Set (Beispiel)

claude config set allowedTools '["Edit","View"]'

MCP (Model Context Protocol)-Probleme

MCP-Server debuggen

claude --debug

MCP-Server auflisten & entfernen

claude mcp list
claude mcp remove <server-name>

VollstÀndige saubere Neuinstallation (Windows / PowerShell)

[!Caution] Das Folgende entfernt Claude Code-BinÀrdateien, Caches und Konfiguration unter deinem Benutzerprofil

  1. Globales npm-Paket deinstallieren
npm uninstall -g @anthropic-ai/claude-code
  1. Verbleibende Shim-Dateien entfernen
Remove-Item -LiteralPath "$env:USERPROFILE\AppData\Roaming\npm\claude*" -Force -ErrorAction SilentlyContinue
Remove-Item -LiteralPath "$env:USERPROFILE\AppData\Roaming\npm\node_modules\@anthropic-ai\claude-code" -Recurse -Force -ErrorAction SilentlyContinue
  1. Gecachten Installer & native Dateien löschen
Remove-Item -LiteralPath "$env:USERPROFILE\.claude\downloads\*" -Recurse -Force -ErrorAction SilentlyContinue
Remove-Item -LiteralPath "$env:USERPROFILE\.claude\local\bin\claude.exe" -Force -ErrorAction SilentlyContinue
Remove-Item -LiteralPath "$env:USERPROFILE\.claude\local" -Recurse -Force -ErrorAction SilentlyContinue
  1. Konfig und projektlokale Dateien entfernen
Remove-Item -LiteralPath "$env:USERPROFILE\.claude.json" -Force -ErrorAction SilentlyContinue
Remove-Item -LiteralPath "$env:USERPROFILE\.claude" -Recurse -Force -ErrorAction SilentlyContinue
  1. Neu installieren
npm install -g @anthropic-ai/claude-code

Einmaliger Gesundheitscheck (kopieren/einfĂŒgen)

Windows (PowerShell):

Write-Host "`n=== Node & npm ==="; node --version; npm --version
Write-Host "`n=== Wo ist claude? ==="; where claude
Write-Host "`n=== Doctor ==="; try { claude doctor } catch { Write-Host "claude nicht im PATH" }
Write-Host "`n=== API-SchlĂŒssel gesetzt? ==="; if ($env:ANTHROPIC_API_KEY) { "Ja" } else { "Nein" }

macOS/Linux (bash/zsh):

echo "=== Node & npm ==="; node --version; npm --version
echo "=== Wo ist claude? ==="; which claude || echo "claude nicht im PATH"
echo "=== Doctor ==="; claude doctor || true
echo "=== API-SchlĂŒssel gesetzt? ==="; [ -n "$ANTHROPIC_API_KEY" ] && echo Ja || echo Nein

Anhang: NĂŒtzliche Pfade

  • Windows npm global bin: C:\Users\<you>\AppData\Roaming\npm
  • Windows Node.js: C:\Program Files\nodejs
  • Claude lokale Daten (Win): C:\Users\<you>\.claude\
  • Claude Konfiguration (Win): C:\Users\<you>\.claude.json
  • macOS/Linux npm global bin: $(npm config get prefix)/bin (oft /usr/local/bin oder $HOME/.npm-global/bin)

Best Practices

Kuratierte Anleitungen fĂŒr die sichere, schnelle und korrekte Verwendung der Claude Code CLI und des interaktiven REPL. Alle Befehle und Flags entsprechen den aktuellen Anthropic-Dokumenten vom 28. Feb. 2026.

Effektives Prompting

# Gut: Spezifisch und detailliert
claude "Review UserAuth.js for security vulnerabilities, focusing on JWT handling"

# Schlecht: Vage
claude "check my code"

Tipp: claude "query" startet das interaktive REPL mit dem Prompt vorbelegt; claude -p "query" fĂŒhrt den Print-Modus (nicht-interaktiv) aus und beendet.

Sicherheits-Best-Practices

  1. Mit minimalen Berechtigungen beginnen

    • Explizite Erlaubnisse und Verbote bevorzugen, entweder ĂŒber die CLI oder in Einstellungsdateien.
    # Nur erlauben, was fĂŒr diesen Lauf benötigt wird
    claude --allowedTools "Read" "Grep" "LS" "Bash(npm run test:*)"

    Oder eine Projektrichtlinie in .claude/settings.json committen:

    {
      "permissions": {
        "allow": ["Read", "Grep", "LS", "Bash(npm run test:*)"],
        "deny": [
          "WebFetch",
          "Bash(curl:*)",
          "Read(./.env)",
          "Read(./secrets/**)"
        ]
      }
    }

  2. Secrets korrekt behandeln

    • Umgebungsvariablen fĂŒr SDK/Automatisierungsflows verwenden:
    export ANTHROPIC_API_KEY="your_key"   # fĂŒr SDK/Print-Modus
    • Im interaktiven REPL /login bevorzugen statt Tokens fest zu kodieren.
    • Zugriff auf sensible Dateien in den Einstellungen verweigern:
    {
      "permissions": {
        "deny": ["Read(./.env)", "Read(./.env.*)", "Read(./secrets/**)"]
      }
    }

  3. Berechtigungen regelmĂ€ĂŸig ĂŒberprĂŒfen

    # Projekteinstellungen
    claude config list
    claude config get permissions.allow
    claude config get permissions.deny

    # Globale Einstellungen
    claude config list -g

  4. Bypass-Modi in der Produktion vermeiden

    • --dangerously-skip-permissions NICHT außerhalb isolierter/Dev-Sandboxes verwenden.
    • FĂŒr unbeaufsichtigte LĂ€ufe enges --allowedTools mit --disallowedTools und Projekteinstellungen kombinieren.

Performance-Tipps

  1. Maschinenlesbare Ausgabe in Automatisierungen verwenden

    claude -p "summarize this error log" --output-format json
    # gĂŒltig: text | json | stream-json

  2. Nicht-interaktive Arbeit begrenzen

    claude -p "run type checks and summarize failures" --max-turns 3
    # optional auch Denken begrenzen:
    export MAX_THINKING_TOKENS=20000

  3. Sitzungen ordentlich halten

    # Nur aktuelle Sitzungen behalten (Standard ist 30 Tage)
    claude config set -g cleanupPeriodDays 20

  4. Kontextbereich begrenzen

    # Zugriff nur auf relevante Pfade gewÀhren, um Scanning/Noise zu reduzieren
    claude --add-dir ./services/api ./packages/ui

  5. Das richtige Modell wÀhlen

    • CLI-Aliase: --model sonnet oder --model opus (neueste der Familie).
    • Ab Feb. 2026 ist Sonnet 4.6 das Standard-Sonnet — Frontier-Performance zu Sonnet-Preisen mit 1-M-Token-Kontextfenster.
    • FĂŒr Reproduzierbarkeit in Einstellungen eine vollstĂ€ndige Modell-ID pinnen (z.B. "claude-sonnet-4-6-20260217").

Monitoring & Alerting

1) GesundheitsprĂŒfungen Den integrierten doctor-Befehl verwenden, um Installation und Umgebung zu ĂŒberprĂŒfen.

# Alle 15 Minuten
*/15 * * * * /usr/local/bin/claude doctor >/dev/null 2>&1 || \
mail -s "Claude Code doctor failed" admin@company.com </dev/null

2) Log-Analyse-Batch-Job

# TĂ€gliche Analyse mit nicht-interaktiver JSON-Ausgabe (Print-Modus)
0 6 * * * tail -1000 /var/log/app.log | \
claude -p "Analyze errors, regressions, and suspect patterns; output JSON." \
--output-format json > /tmp/daily-analysis.json

3) Telemetrie (optional) Claude Code gibt OpenTelemetry-Metriken/Ereignisse aus. Exporteure in Einstellungen/Umgebung setzen (z.B. OTLP) und an deinen Observability-Stack senden (Datadog, Honeycomb, Prometheus/Grafana usw.).

Zusammenarbeits-Best-Practices

Team-Workflows

1) Versionierte Konfiguration teilen

// .claude/settings.json (ins Repo eingecheckt)
{
  "permissions": {
    "allow": [
      "Read",
      "Grep",
      "LS",
      "Bash(npm run lint)",
      "Bash(npm run test:*)"
    ],
    "deny": [
      "WebFetch",
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)"
    ]
  },
  // Modell hier fĂŒr Reproduzierbarkeit pinnen mit vollstĂ€ndiger Modell-ID:
  "model": "claude-sonnet-4-6-20260217"
}

2) Dokumentationsautomatisierung

# Docs mit expliziten Aufgaben aktualisieren
claude "Update README.md to reflect the latest API endpoints and examples."
claude "Generate TypeScript types from schema.prisma and write to /types."

3) Code-Review-Standards

# Lokalen Diff mit eingeschrÀnkten Tools reviewen
git fetch origin main
git diff origin/main...HEAD > /tmp/diff.patch
claude --allowedTools "Read" "Grep" "Bash(git:*)" \
  "Review /tmp/diff.patch using team standards:
   - Security best practices
   - Performance considerations
   - Code style compliance
   - Test coverage adequacy"

Wissensaustausch

1) Projekt-Runbooks

claude "Create a deployment runbook for this app: steps, checks, rollback."
claude "Document onboarding for new developers: setup, commands, conventions."

2) Architekturdokumentationen

claude "Update architecture docs to reflect new microservices."
claude "Create sequence diagrams for the authentication flow."

Tipp: Dauerhaften Kontext in CLAUDE.md im Projektstamm halten. Im REPL /memory zum Verwalten und @path zum Importieren von Dateiinhalt in Prompts verwenden.

HĂ€ufige Fallstricke vermeiden

Sicherheit

❌ Nicht tun

  • --dangerously-skip-permissions in Produktionssystemen verwenden
  • Secrets in Befehlen/Konfiguration fest kodieren
  • ÜbermĂ€ĂŸig breite Berechtigungen gewĂ€hren (z.B. Bash(*))
  • Mit erhöhten Rechten ohne Notwendigkeit ausfĂŒhren

✅ Tun

  • Secrets in Umgebungsvariablen und Credential-Helfern speichern
  • Von minimalem permissions.allow starten und schrittweise erweitern
  • Mit claude config list / claude config get prĂŒfen
  • Risikoreiche Operationen in Containern/VMs isolieren

Performance

❌ Nicht tun

  • Einen ganzen Monorepo laden, wenn nur ein Paket benötigt wird
  • Denk-/Runden-Budgets fĂŒr einfache Aufgaben maximieren
  • Sitzungsbereinigung ignorieren

✅ Tun

  • --add-dir fĂŒr fokussierten Kontext verwenden
  • Mit --max-turns und MAX_THINKING_TOKENS richtig dimensionieren
  • cleanupPeriodDays setzen, um alte Sitzungen zu bereinigen

Workflow

❌ Nicht tun

  • Projektkontext (CLAUDE.md) ĂŒberspringen
  • Vage Prompts verwenden
  • Fehler/Logs ignorieren
  • Ohne Tests automatisieren

✅ Tun

  • CLAUDE.md pflegen und aktualisieren
  • Spezifisch und zielorientiert in Prompts sein
  • Über Logs/OTel nach Bedarf ĂŒberwachen
  • Automatisierung zuerst in sicheren Umgebungen testen

Drittanbieter-Integrationen

DeepSeek-Integration

  1. Claude Code installiert haben​
npm install -g @anthropic-ai/claude-code
  1. Umgebungsvariablen konfigurieren​
export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=${YOUR_API_KEY}
export ANTHROPIC_MODEL=deepseek-chat
export ANTHROPIC_SMALL_FAST_MODEL=deepseek-chat
  1. Jetzt einfach claude starten​

Weitere Informationen in der offiziellen DeepSeek-Dokumentation