Claude Code CLI: Der vollständige Leitfaden

TL;DR: Claude Code ist ein agentisches CLI, das Ihre Codebasis liest, Befehle ausführt und Dateien über ein mehrschichtiges System aus Berechtigungen, Hooks, MCP-Integrationen und Subagents modifiziert. Beherrschen Sie fünf Kernsysteme (Konfiguration, Berechtigungen, Hooks, MCP und Subagents) und Sie erschließen sich eine vervielfachte Produktivität. Wählen Sie die Modellstufe, die zur jeweiligen Aufgabe passt — Opus für komplexe Schlussfolgerungen, Sonnet für allgemeine Arbeit, Haiku für schnelle Exploration — oder standardisieren Sie auf Opus, wenn Qualität Ihre einzige Variable ist. Verwenden Sie Hooks (nicht Prompts) für alles, was immer ausgeführt werden muss.

Claude Code arbeitet als agentisches System, nicht als Chat-Oberfläche mit Programmierkenntnissen. Das CLI liest Ihre Codebasis, führt Befehle aus, modifiziert Dateien, verwaltet Git-Workflows, verbindet sich über MCP mit externen Diensten und delegiert komplexe Aufgaben an spezialisierte Subagents. Alles läuft über eine Kommandozeilenschnittstelle, die sich in die tatsächliche Arbeitsweise von Entwicklern einfügt. Stand Februar 2026 werden 4 % der öffentlichen GitHub-Commits (~135.000 pro Tag) von Claude Code erstellt — ein Wachstum um das 42.896-Fache in 13 Monaten seit der Research Preview — und 90 % des eigenen Codes von Anthropic sind KI-geschrieben.¹¹⁰

Der Unterschied zwischen gelegentlicher und effektiver Claude Code-Nutzung kommt auf fünf Kernsysteme an. Beherrschen Sie diese, und Claude Code wird zum Kraftmultiplikator:

1. Konfigurationshierarchie: steuert das Verhalten
2. Berechtigungssystem: kontrolliert Operationen
3. Hook-System: ermöglicht deterministische Automatisierung
4. MCP-Protokoll: erweitert die Fähigkeiten
5. Subagent-System: bewältigt komplexe mehrstufige Aufgaben

Wichtigste Erkenntnisse

• Fünf Systeme bestimmen Ihre Effektivität: Konfigurationshierarchie, Berechtigungen, Hooks, MCP und Subagents steuern alles von Verhalten bis Automatisierung.
• Verlagern Sie Arbeit in die Delegationsschicht: Subagents verhindern Context-Bloat, indem sie Exploration in sauberen Kontextfenstern isolieren und nur Zusammenfassungen zurückgeben.
• Hooks garantieren Ausführung; Prompts nicht: Verwenden Sie Hooks für Linting, Formatierung und Sicherheitsprüfungen, die jedes Mal unabhängig vom Modellverhalten ausgeführt werden müssen.
• Modellstufung spart Kosten ohne Qualitätseinbußen: Leiten Sie Subagent-Exploration an günstigere Modelle weiter und reservieren Sie Opus für echte architektonische Überlegungen — oder standardisieren Sie auf Opus, wenn Qualität Ihre einzige Variable ist.
• MCP verbindet Claude mit Ihrer Toolchain: Datenbanken, GitHub, Sentry und über 3.000 Integrationen erweitern Claude über das Lesen von Dateien und Bash-Befehle hinaus.

Ich habe Monate damit verbracht, Claude Code in Produktions-Codebasen, CI/CD-Pipelines und Enterprise-Deployments an seine Grenzen zu bringen. Dieser Leitfaden destilliert diese Erfahrung in die vollständige Referenz, die ich mir gewünscht hätte, als ich anfing. Jede Funktion enthält tatsächliche Syntax, reale Konfigurationsbeispiele und die Grenzfälle, über die auch erfahrene Benutzer stolpern.

So verwenden Sie diesen Leitfaden

Dies ist eine Referenz mit über 5.000 Zeilen — Sie müssen sie nicht von Anfang bis Ende lesen. Starten Sie dort, wo Ihr Erfahrungsniveau passt:

Verwenden Sie die Suchfunktion Ihres Browsers (Strg+F / Cmd+F), um nach bestimmten Flags, Befehlen oder Konfigurationsschlüsseln zu suchen. Die Kurzreferenzkarte am Ende bietet eine übersichtliche Zusammenfassung aller wichtigen Befehle.

Wie Claude Code funktioniert: Das mentale Modell

Bevor Sie sich in die Funktionen vertiefen, sollten Sie verstehen, wie die Architektur von Claude Code alles beeinflusst, was Sie damit tun. Das System arbeitet in drei Schichten:

┌─────────────────────────────────────────────────────────┐
│                    CLAUDE CODE LAYERS                    │
├─────────────────────────────────────────────────────────┤
│  EXTENSION LAYER                                         │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
│  │   MCP   │  │  Hooks  │  │ Skills  │  │ Plugins │    │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘    │
│  External tools, deterministic automation, domain       │
│  expertise, packaged extensions                          │
├─────────────────────────────────────────────────────────┤
│  DELEGATION LAYER                                        │
│  ┌─────────────────────────────────────────────────┐    │
│  │              Subagents (up to 10 parallel)       │    │
│  │   Explore | Plan | General-purpose | Custom      │    │
│  └─────────────────────────────────────────────────┘    │
│  Isolated contexts for focused work, returns summaries  │
├─────────────────────────────────────────────────────────┤
│  CORE LAYER                                              │
│  ┌─────────────────────────────────────────────────┐    │
│  │         Main Conversation Context                │    │
│  │   Tools: Read, Edit, Bash, Glob, Grep, etc.     │    │
│  └─────────────────────────────────────────────────┘    │
│  Your primary interaction; limited context; costs money │
└─────────────────────────────────────────────────────────┘

Kernschicht: Ihre Hauptkonversation. Jede Nachricht, jedes Lesen einer Datei und jede Tool-Ausgabe verbraucht Kontext aus einem gemeinsamen Fenster (200K Tokens Standard⁹⁸, 1M Tokens mit Opus 4.6 oder Modellen mit erweitertem Kontext). Wenn der Kontext voll ist, verliert Claude den Überblick über frühere Entscheidungen und die Qualität nimmt ab. Diese Schicht kostet Geld pro Token.

Delegationsschicht: Subagents starten mit sauberem Kontext, erledigen fokussierte Aufgaben und liefern Zusammenfassungen zurück. Die Ergebnisse der Exploration blähen Ihre Hauptkonversation nicht auf; nur die Schlussfolgerungen werden zurückgegeben. Leiten Sie Subagents an günstigere Modellstufen für die Exploration weiter, oder verwenden Sie durchgehend Ihr primäres Modell, wenn Qualität wichtiger ist als Kosten.

Erweiterungsschicht: MCP verbindet externe Dienste (Datenbanken, GitHub, Sentry). Hooks garantieren die Ausführung von Shell-Befehlen unabhängig vom Modellverhalten. Skills kodieren Fachwissen, das Claude automatisch anwendet. Plugins bündeln all dies zur Verteilung.

Die zentrale Erkenntnis: Die meisten Benutzer arbeiten ausschließlich in der Kernschicht und beobachten, wie der Kontext aufgebläht wird und die Kosten steigen. Fortgeschrittene Benutzer verlagern Exploration und spezialisierte Arbeit in die Delegationsschicht, halten die Erweiterungsschicht für ihren Workflow konfiguriert und nutzen die Kernschicht nur für Orchestrierung und finale Entscheidungen.

Inhaltsverzeichnis

1. Wie installiere ich Claude Code?
2. Schnellstart: Ihre erste Sitzung
3. Kerninteraktionsmodi
4. Konfigurationssystem im Detail
5. Welches Modell sollte ich wählen?
6. Was kostet Claude Code?
7. Entscheidungsrahmen
8. Wie funktioniert das Berechtigungssystem?
9. Wie funktionieren Hooks?
10. Was ist MCP (Model Context Protocol)?
11. Was sind Subagents?
12. Was ist der erweiterte Denkmodus?
13. Ausgabestile
14. Slash-Befehle
15. Wie funktionieren Skills?
16. Plugin-System
17. Wie funktioniert Memory?
18. Bild- und multimodale Eingabe
19. Sprachmodus
20. Wie funktioniert die Git-Integration?
21. Wie verwende ich Claude Code in meiner IDE?
22. Fortgeschrittene Nutzungsmuster
23. Remote- & Hintergrund-Agents [RESEARCH PREVIEW]
24. Claude in Chrome
25. Claude Code in Slack [RESEARCH PREVIEW]
26. Claude Code im Web [RESEARCH PREVIEW]
27. Leistungsoptimierung
28. Wie debugge ich Probleme?
29. Enterprise-Bereitstellung
30. Tastenkürzel-Referenz
31. Best Practices
32. Workflow-Rezepte
33. Migrationsleitfaden
34. Zielgruppenspezifische Anleitungen
35. Schnellreferenzkarte
36. Änderungsprotokoll
37. Referenzen

Wie installiere ich Claude Code?

Systemanforderungen

Claude Code läuft auf macOS 10.15+, Ubuntu 20.04+/Debian 10+ und Windows 10+ über WSL oder Git Bash. Das System benötigt mindestens 4 GB RAM und eine aktive Internetverbindung.⁹⁹ Die Shell-Kompatibilität funktioniert am besten mit Bash, Zsh oder Fish.

Unter Windows funktionieren sowohl WSL 1 als auch WSL 2. Git Bash funktioniert ebenfalls, wenn Sie natives Windows bevorzugen. Alpine Linux und andere musl-basierte Systeme erfordern zusätzliche Pakete:

apk add libgcc libstdc++ ripgrep
export USE_BUILTIN_RIPGREP=0

Installationsmethoden

Native Installation (empfohlen)

Die native Binärdatei bietet die sauberste Erfahrung ohne Node.js-Abhängigkeit:

# macOS and Linux
curl -fsSL https://claude.ai/install.sh | bash

# Homebrew alternative
brew install --cask claude-code

# Windows PowerShell
irm https://claude.ai/install.ps1 | iex

# Windows CMD
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

Für versionsspezifische Installation:

# Install specific version
curl -fsSL https://claude.ai/install.sh | bash -s 1.0.58

# Install latest explicitly
curl -fsSL https://claude.ai/install.sh | bash -s latest

# Windows PowerShell - specific version
& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) 1.0.58

NPM-Installation (veraltet)

Hinweis: Ab v2.1.15 zeigen npm-Installationen einen Veraltet-Hinweis an. Die native Binärdatei ist nun die empfohlene Installationsmethode. Migrieren Sie mit claude install.

Für ältere Umgebungen, in denen npm noch benötigt wird:

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

Verwenden Sie niemals sudo bei der npm-Installation. Es verursacht Berechtigungsprobleme, die alles Nachfolgende verkomplizieren.

Migration von einer bestehenden Installation

Wenn Sie eine ältere npm-basierte Installation haben, migrieren Sie zur nativen Binärdatei:

claude install

Authentifizierungsoptionen

Claude Code unterstützt drei Authentifizierungswege, jeweils mit unterschiedlichen Kompromissen:

Claude Console (API-Abrechnung)

Verbinden Sie sich direkt über platform.claude.com (zuvor console.anthropic.com) mit der API von Anthropic. Erstellen Sie ein Konto, richten Sie die Abrechnung ein und authentifizieren Sie sich über die CLI. Die Console bietet nutzungsbasierte Abrechnung mit vollem API-Zugang. Ein dedizierter „Claude Code”-Workspace wird automatisch erstellt; Sie können für diesen Workspace keine API-Schlüssel erstellen, aber die Nutzung überwachen.

Claude Pro- oder Max-Abonnement

Verwenden Sie Ihre claude.ai-Kontodaten. Das Abonnement deckt sowohl die Weboberfläche als auch die CLI-Nutzung unter einem einzigen Monatsplan ab. Das Abonnement vereinfacht die Abrechnung für Einzelpersonen, die vorhersehbare Kosten wünschen.

Enterprise-Plattformen

AWS Bedrock, Google Vertex AI und Microsoft Foundry bieten jeweils Enterprise-Zugang mit bestehenden Cloud-Abrechnungsbeziehungen:

# AWS Bedrock
export CLAUDE_CODE_USE_BEDROCK=1
export AWS_REGION=us-east-1
export AWS_PROFILE=your-profile

# Google Vertex AI
export CLAUDE_CODE_USE_VERTEX=1
export CLOUD_ML_REGION=us-east5
export ANTHROPIC_VERTEX_PROJECT_ID=your-project

# Microsoft Foundry
export CLAUDE_CODE_USE_FOUNDRY=1
export ANTHROPIC_FOUNDRY_RESOURCE=your-resource-name
# Optional: API key auth (otherwise uses Entra ID)
export ANTHROPIC_FOUNDRY_API_KEY=your-key

Für Enterprise-Bereitstellungen hinter Proxys oder über LLM-Gateways:

# Corporate proxy
export HTTPS_PROXY='https://proxy.example.com:8080'

# LLM gateway (skip native auth)
export CLAUDE_CODE_USE_BEDROCK=1
export ANTHROPIC_BEDROCK_BASE_URL='https://your-gateway.com/bedrock'
export CLAUDE_CODE_SKIP_BEDROCK_AUTH=1

Überprüfung

claude doctor

Der Befehl meldet den Installationstyp, die Version, die Systemkonfiguration und erkannte Probleme.

Authentifizierungsverwaltung (v2.1.41+)

Verwalten Sie die Authentifizierung, ohne den REPL zu betreten:⁹⁷

claude auth login          # Log in or switch accounts
claude auth status         # Check current auth state (account, plan, expiry)
claude auth logout         # Clear stored credentials

Häufiger Workflow zum Wechseln zwischen Konten oder Organisationen:

claude auth logout && claude auth login

Siehe auch: Wie behebe ich Probleme? zur Fehlerbehebung bei Authentifizierungsproblemen.

Updates

Claude Code aktualisiert sich standardmäßig automatisch und prüft beim Start sowie periodisch während Sitzungen auf Updates. Updates werden im Hintergrund heruntergeladen und beim nächsten Start angewendet.

Automatische Updates deaktivieren:

export DISABLE_AUTOUPDATER=1

Oder in settings.json:

{
  "env": {
    "DISABLE_AUTOUPDATER": "1"
  }
}

Manuelles Update:

claude update

Deinstallation

Native Installation (macOS/Linux/WSL):

rm -f ~/.local/bin/claude
rm -rf ~/.claude-code

Native Installation (Windows PowerShell):

Remove-Item -Path "$env:LOCALAPPDATA\Programs\claude-code" -Recurse -Force
Remove-Item -Path "$env:LOCALAPPDATA\Microsoft\WindowsApps\claude.exe" -Force

Konfiguration bereinigen (entfernt alle Einstellungen):

rm -rf ~/.claude
rm ~/.claude.json
rm -rf .claude
rm -f .mcp.json

Schnellstart: Ihre erste Sitzung

1. Installieren und starten:

claude                           # Launch in current directory

2. Zu einem Projekt navigieren:

cd ~/my-project && claude        # Or launch from any git repo

3. Claude bitten, etwas zu tun:

> "Explain the architecture of this project"
> "Find all TODO comments and create a summary"
> "Add input validation to the signup form"

4. Wichtige Tastenkürzel während Ihrer Sitzung verwenden:

/cost                            # Check token usage and cost
/compact                         # Free up context when it gets large
Alt+T                            # Toggle extended thinking for hard problems
Ctrl+C                           # Cancel current response

5. Später fortfahren:

claude -c                        # Resume your most recent session
claude --resume                  # Pick from session list

Expertentipp: Erstellen Sie eine CLAUDE.md-Datei im Stammverzeichnis Ihres Projekts mit Build-Befehlen, Coding-Konventionen und Architekturhinweisen. Claude liest sie bei jeder Sitzung — es ist die wirkungsvollste Maßnahme, die Sie für die Qualität ergreifen können.

Zentrale Interaktionsmodi

Interaktiver REPL

Starten Sie Claude Code ohne Argumente, um die interaktive Read-Eval-Print-Schleife zu betreten:

cd your-project
claude

Der REPL behält den Gesprächskontext über mehrere Eingaben hinweg bei. Geben Sie Anfragen direkt ein, erhalten Sie Antworten und fahren Sie fort, bis Sie mit /exit oder Ctrl+D beenden.

Beginnen Sie mit einem initialen Prompt, um die Sitzung zu fokussieren:

claude "explain the authentication flow in this project"

Expertentipp: Der REPL behält seinen Zustand auch über Komprimierungsereignisse hinweg bei. Wenn der Kontext zu groß wird, fasst Claude ältere Gesprächsteile automatisch zusammen und bewahrt dabei wichtige Entscheidungen und Code-Ausschnitte. Sie können dies manuell mit /compact auslösen oder benutzerdefinierte Anweisungen hinzufügen, was erhalten bleiben soll.

Nicht-interaktiver Modus

Der Print-Modus (-p) führt eine einzelne Anfrage aus und beendet sich:

# Direct query
claude -p "list all TODO comments in this project"

# Process piped input
cat error.log | claude -p "identify the root cause of these failures"

# Chain with other tools
claude -p "generate a README" > README.md

Für strukturierte Ausgabe, die sich zum Parsen in Skripten eignet:

claude -p "count lines by file type" --output-format json

Die JSON-Ausgabe enthält alles, was Sie für die Automatisierung benötigen:

{
  "type": "result",
  "subtype": "success",
  "total_cost_usd": 0.0034,
  "is_error": false,
  "duration_ms": 2847,
  "duration_api_ms": 1923,
  "num_turns": 4,
  "result": "Response text here...",
  "session_id": "abc-123-def"
}

Für die Echtzeitverarbeitung von Streaming-Ausgaben:

claude -p "build the application" --output-format stream-json | while read line; do
  echo "$line" | jq -r 'select(.result) | .result'
done

Optionen für das Ausgabeformat:

Exit-Codes:

Steuerung des agentischen Verhaltens im -p-Modus:

# Limit autonomous turns (prevents runaway loops)
claude -p "refactor the auth module" --max-turns 10

# Allow specific tools without prompting
claude -p "fix lint errors" --allowedTools "Edit,Bash(npm run lint)"

# Use with a specific model
claude -p "explain this code" --model claude-sonnet-4-5-20250929

CI/CD-Integrationsmuster:

# In a GitHub Action or CI pipeline
result=$(claude -p "review this diff for security issues" --output-format json 2>/dev/null)
is_error=$(echo "$result" | jq -r '.is_error')
if [ "$is_error" = "true" ]; then
  echo "Review failed"
  exit 1
fi
echo "$result" | jq -r '.result'

Sitzungsverwaltung

Sitzungen speichern den Gesprächsverlauf zur späteren Fortsetzung. Die Sitzungspersistenz ist für komplexe, sitzungsübergreifende Arbeit unerlässlich:

# Continue most recent session
claude -c

# Continue with additional prompt
claude -c -p "now add error handling"

# Resume specific session by ID
claude -r "abc123" "implement the remaining tests"

# Fork a session for parallel exploration
claude -r "base-session" --fork-session "try a different approach"

PR-verknüpfte Sitzungen (v2.1.27+): Starten Sie eine Sitzung, die mit einem bestimmten Pull Request verknüpft ist:⁸¹

claude --from-pr 123                                    # By PR number
claude --from-pr https://github.com/org/repo/pull/123   # By URL

Sitzungen werden auch automatisch mit PRs verknüpft, wenn Sie diese während einer Sitzung über gh pr create erstellen. So können Sie die Arbeit an einem bestimmten PR später leicht wieder aufnehmen.

Benannte Sitzungen: Benennen Sie Sitzungen beim Start oder während einer Sitzung:

# Name session at startup (v2.1.76+)
claude -n "auth-refactor"                  # --name flag sets display name[^125]

# Name current session
> /rename auth-refactor

# Resume by name or number
> /resume 1                    # Resume first session
> /resume auth-refactor        # Resume by name
claude --resume auth-refactor  # Resume from terminal
claude -r 3                    # Resume by number from terminal

# Fork for parallel exploration
claude --resume auth-refactor --fork-session

Hinweis: --session-id erfordert eine gültige UUID (z. B. 550e8400-e29b-41d4-a716-446655440000). Für menschenlesbare Sitzungsnamen verwenden Sie stattdessen /rename und --resume.

Claude Code speichert Sitzungen als JSONL-Transkripte. Bei der Ausführung von Agenten werden eindeutige agentId-Werte vergeben, wobei Transkripte als agent-{agentId}.jsonl gespeichert werden. Die Wiederaufnahme bewahrt den vollständigen Kontext aus vorherigen Gesprächen.

Plan-Modus

Der Plan-Modus beschränkt Claude auf schreibgeschützte Exploration – keine Dateibearbeitungen, keine Bash-Ausführung, keine destruktiven Aktionen. Claude entwirft einen Implementierungsansatz, schreibt ihn in eine Plan-Datei und wartet auf Ihre Genehmigung, bevor irgendetwas ausgeführt wird.

Plan-Modus aktivieren:

# Cycle through modes during a session
Shift+Tab           # Cycles: normal → plan → auto-accept

# Or use the /plan command with an optional description (v2.1.72+)
/plan                                     # Enter plan mode
/plan refactor the auth module            # Enter plan mode with a description

# Or ask Claude directly
"Plan how to refactor the auth module"   # Claude may enter plan mode automatically

Funktionsweise:

1. Claude wechselt in den Plan-Modus (automatisch bei komplexen Aufgaben oder über Shift+Tab)
2. Erkundet die Codebasis mit schreibgeschützten Tools: Read, Glob, Grep, WebSearch, WebFetch
3. Schreibt einen Plan nach .claude/plans/{session-slug}.md
4. Verlässt den Plan-Modus mit ExitPlanMode und präsentiert den Plan zur Überprüfung
5. Sie genehmigen, fordern Änderungen an oder lehnen ab

Verfügbare Tools im Plan-Modus: Read, Glob, Grep, LS, WebSearch, WebFetch, AskUserQuestion. Bearbeitungstools (Edit, Write, Bash, NotebookEdit) sind gesperrt.

Nach der Plan-Genehmigung (v2.1.32+): Claude bietet drei Optionen: - „Ja, Kontext leeren und Bearbeitungen automatisch akzeptieren” (Shift+Tab) – startet frisch mit vollem Kontext für den Plan - „Ja, und Bearbeitungen manuell genehmigen” – behält den Kontext bei, Sie genehmigen jede Änderung - „Ja, Bearbeitungen automatisch akzeptieren” – behält den Kontext bei, Claude führt ohne Einzelgenehmigung aus

Automatisches Leeren des Kontexts bei Genehmigung ist der empfohlene Workflow. Es gibt dem Plan ein frisches Kontextfenster, was die Plantreue erheblich verbessert – Claude bleibt länger auf Kurs, ohne dass alte Gesprächsteile stören.

Wann Sie den Plan-Modus verwenden sollten: - Implementierung neuer Funktionen mit Architekturentscheidungen - Refactoring über mehrere Dateien, bei dem Sie den Ansatz vorab prüfen möchten - Unbekannte Codebasen, bei denen Exploration vor Modifikation stehen sollte - Jede Aufgabe, bei der mehrere gültige Ansätze existieren und Sie Input wünschen

Expertentipp: Je mehr Zeit Sie im Plan-Modus verbringen, desto wahrscheinlicher wird Claude bei der Implementierung erfolgreich sein. Der Plan-Modus ist im Grunde kostenlose Exploration – keine riskanten Tool-Aufrufe, keine verschwendeten Bearbeitungen. Nutzen Sie ihn großzügig.

Konfigurationssystem im Detail

Claude Code verwendet ein mehrschichtiges Konfigurationssystem. Das Verständnis der Hierarchie ist essenziell, da höhere Ebenen niedrigere überschreiben und Unternehmenseinstellungen überhaupt nicht umgangen werden können.

Konfigurationshierarchie

Expertentipp: Verwenden Sie .claude/settings.local.json für persönliche Einstellungen in gemeinsam genutzten Projekten (fügen Sie die Datei zu .gitignore hinzu). Verwenden Sie .claude/settings.json für teamweite Konfiguration, die in die Versionskontrolle eingecheckt wird.

Vollständige settings.json-Referenz

Eine vollständige Konfiguration, die alle wichtigen Optionen demonstriert:

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "model": "claude-sonnet-4-5-20250929",
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Bash(npm run:*)",
      "Bash(git:*)",
      "Bash(make:*)",
      "Edit(src/**)",
      "Write(src/**)",
      "mcp__github"
    ],
    "deny": [
      "Read(.env*)",
      "Read(secrets/**)",
      "Bash(rm -rf:*)",
      "Bash(sudo:*)",
      "Edit(package-lock.json)",
      "Edit(.git/**)"
    ],
    "ask": [
      "WebFetch",
      "Bash(curl:*)",
      "Bash(docker:*)"
    ],
    "additionalDirectories": [
      "../shared-lib",
      "../docs"
    ],
    "defaultMode": "acceptEdits"
  },
  "env": {
    "NODE_ENV": "development",
    "DEBUG": "app:*"
  },
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$FILE_PATH\""
          }
        ]
      }
    ]
  },
  "sandbox": {
    "enabled": false,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["git", "docker"]
  },
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh"
  },
  "includeCoAuthoredBy": true,
  "cleanupPeriodDays": 30,
  "outputStyle": "Explanatory",
  "language": "en",
  "respectGitignore": true,
  "showTurnDuration": true,
  "plansDirectory": ".claude/plans",
  "spinnerVerbs": ["Thinking", "Processing", "Analyzing"],
  "spinnerTipsOverride": {
    "tips": ["Custom tip 1", "Custom tip 2"],
    "excludeDefault": true
  },
  "includeGitInstructions": false,
  "modelOverrides": {
    "bedrock": "us.anthropic.claude-opus-4-6-20260312-v1:0",
    "vertex": "claude-opus-4-6@20260312",
    "foundry": "anthropic.claude-opus-4-6"
  },
  "autoMemoryDirectory": ".claude/memory",
  "sandbox": {
    "enableWeakerNetworkIsolation": true
  }
}

Referenz der Umgebungsvariablen

Authentifizierung und API:

ANTHROPIC_API_KEY=sk-ant-...                    # Direct API authentication
ANTHROPIC_AUTH_TOKEN=token                      # Custom authorization header
ANTHROPIC_CUSTOM_HEADERS="X-Key: val"           # Additional request headers

Modellkonfiguration:

ANTHROPIC_MODEL=claude-opus-4-6                 # Override default model
ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-6    # Opus 4.6 (Feb 2026)
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-5-20250929
ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5-20251001
CLAUDE_CODE_SUBAGENT_MODEL=sonnet               # Model for subagents
MAX_THINKING_TOKENS=10000                       # Enable extended thinking
CLAUDE_CODE_MAX_OUTPUT_TOKENS=4000              # Limit output length
CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1          # Enable agent teams (v2.1.32+)

Cloud-Anbieter-Konfiguration:

CLAUDE_CODE_USE_BEDROCK=1                       # Use AWS Bedrock
CLAUDE_CODE_USE_VERTEX=1                        # Use Google Vertex AI
CLAUDE_CODE_USE_FOUNDRY=1                       # Use Microsoft Foundry
ANTHROPIC_BEDROCK_BASE_URL=https://...          # Custom Bedrock endpoint
CLAUDE_CODE_SKIP_BEDROCK_AUTH=1                 # Skip Bedrock auth (for gateways)
CLAUDE_CODE_SKIP_VERTEX_AUTH=1                  # Skip Vertex auth
AWS_BEARER_TOKEN_BEDROCK=token                  # Bedrock bearer token
VERTEX_REGION_CLAUDE_3_7_SONNET=us-west1        # Override Vertex region

Verhaltenssteuerung:

DISABLE_AUTOUPDATER=1                           # Prevent automatic updates
DISABLE_TELEMETRY=1                             # Opt out of usage telemetry
DISABLE_ERROR_REPORTING=1                       # Disable Sentry
DISABLE_BUG_COMMAND=1                           # Disable /bug command
DISABLE_COST_WARNINGS=1                         # Hide cost warnings
DISABLE_PROMPT_CACHING=1                        # Disable prompt caching globally
DISABLE_PROMPT_CACHING_SONNET=1                 # Disable for Sonnet only
DISABLE_PROMPT_CACHING_OPUS=1                   # Disable for Opus only
DISABLE_NON_ESSENTIAL_MODEL_CALLS=1             # Skip non-critical API calls

Tool-Konfiguration:

BASH_DEFAULT_TIMEOUT_MS=30000                   # Bash command timeout (30s)
BASH_MAX_TIMEOUT_MS=600000                      # Maximum bash timeout (10min)
BASH_MAX_OUTPUT_LENGTH=50000                    # Bash output limit
CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1     # Reset CWD after each bash
MCP_TIMEOUT=5000                                # MCP server startup timeout
MCP_TOOL_TIMEOUT=30000                          # MCP tool execution timeout
MAX_MCP_OUTPUT_TOKENS=25000                     # MCP output limit
SLASH_COMMAND_TOOL_CHAR_BUDGET=15000            # Slash command context limit

Netzwerk und Proxy:

HTTP_PROXY=http://proxy:8080                    # HTTP proxy
HTTPS_PROXY=https://proxy:8080                  # HTTPS proxy
NO_PROXY=localhost,example.com                  # Bypass proxy for domains
CLAUDE_CODE_CLIENT_CERT=/path/to/cert           # mTLS certificate
CLAUDE_CODE_CLIENT_KEY=/path/to/key             # mTLS private key
CLAUDE_CODE_CLIENT_KEY_PASSPHRASE=pass          # mTLS passphrase

UI und Terminal:

CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1            # Don't update terminal title
CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL=1             # Skip IDE extension install
CLAUDE_CODE_SHELL=/bin/zsh                      # Override shell detection
USE_BUILTIN_RIPGREP=1                           # Use included ripgrep (default)
CLAUDE_CONFIG_DIR=~/.myconfig                   # Custom config directory
IS_DEMO=1                                       # Hide sensitive UI elements[^37]
CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1          # Disable background tasks and Ctrl+B[^46]
CLAUDE_CODE_TMPDIR=/path/to/tmp                 # Override temp directory[^50]
CLAUDE_CODE_DISABLE_1M_CONTEXT=1               # Disable 1M context window (use standard 200K)[^103]
CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS=120000       # Plugin marketplace git timeout (default 120s, was 30s)[^105]
CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS=1        # Remove built-in commit/PR instructions[^117]
CLAUDE_CODE_DISABLE_CRON=1                    # Stop scheduled cron jobs mid-session[^121]
CLAUDE_CODE_SESSIONEND_HOOKS_TIMEOUT_MS=30000 # SessionEnd hooks timeout (default varies)[^123]

Skill-Variablen (v2.1.69+):

${CLAUDE_SKILL_DIR}                            # Self-reference for skills to locate their own directory[^117]

SDK-Aufruferidentität (v2.1.51+):

CLAUDE_CODE_ACCOUNT_UUID=uuid                  # Provide account UUID synchronously for SDK callers
CLAUDE_CODE_USER_EMAIL=[email protected]        # Provide user email for SDK callers
CLAUDE_CODE_ORGANIZATION_UUID=uuid             # Provide organization UUID for SDK callers

Debugging:

ANTHROPIC_LOG=debug                             # Enable API request logging

Welches Modell sollte ich wählen?

Die Wahl des richtigen Modells für jede Aufgabe hat erhebliche Auswirkungen auf Kosten und Qualität. Claude Code bietet flexiblen Modellwechsel auf mehreren Ebenen.

Verfügbare Modelle

Opus 4.6 (5. Februar 2026): Das neueste Flaggschiff-Modell mit 1M-Token-Kontextfenster, 128K maximaler Ausgabe, adaptivem Thinking und Agent Teams.⁸⁶ Gleiche Preise wie Opus 4.5 ($5/$25 pro MTok). Ab v2.1.75 (13. März 2026) ist das 1M-Kontextfenster standardmäßig für Max-, Team- und Enterprise-Pläne aktiviert — das Suffix [1m] ist für diese Stufen nicht mehr erforderlich.¹²⁴ Ab v2.1.77 (17. März 2026) wurde das Standard-Output-Token-Limit für Opus 4.6 auf 64K Token erhöht, mit einer Obergrenze von 128K Token.¹²⁶ Langer Kontext (>200K Input) bei reiner API-Nutzung kostet weiterhin $10/$37,50 pro MTok. Model ID: claude-opus-4-6.¹

Sonnet 4.6 (17. Februar 2026): Das neue ausgewogene Modell, das Sonnet 4.5 als Standard auf claude.ai und Claude Cowork ablöst.¹⁰⁰ Gleiche Preise wie Sonnet 4.5 ($3/$15 pro MTok). Verbesserte agentische Suchleistung bei geringerem Token-Verbrauch. Unterstützt Extended Thinking, adaptives Thinking und ein 1M-Token-Kontextfenster (Beta). 64K maximale Ausgabe (Obergrenze in v2.1.77 auf 128K erhöht).¹²⁶ Wissensstichtag: August 2025 (zuverlässig), Januar 2026 (Trainingsdaten). Model ID: claude-sonnet-4-6. Sonnet 4.5 ist jetzt ein Legacy-Modell.¹⁰⁰

Warum diese Preisunterschiede wichtig sind: Eine typische Programmiersitzung verbraucht 50K–200K Input-Token und 10K–50K Output-Token. Mit Haiku kostet das $0,10–$0,45 pro Sitzung. Mit Opus hingegen $0,50–$2,25 für dieselbe Sitzung — das Fünffache. Reservieren Sie Opus für wirklich schwierige Probleme.¹

Wann welches Modell verwenden

Haiku: Verwenden Sie es für Subagents bei der Exploration, einfache Dateisuchen und kurze Fragen. Es ist ca. 5x günstiger als Opus und antwortet schneller — perfekt für Hintergrundaufgaben, die kein tiefes Reasoning erfordern.

Sonnet: Das Arbeitstier für den täglichen Entwicklungsalltag. Bewältigt die meisten Programmieraufgaben gut: Features implementieren, Bugs beheben, Tests schreiben, Code Review. Verwenden Sie es als Ihren Standard. Sonnet 4.6 (Februar 2026) bietet verbesserte agentische Suche und bessere Token-Effizienz im Vergleich zu Sonnet 4.5, mit Unterstützung für adaptives Thinking und dem 1M-Kontextfenster in der Beta.¹⁰⁰

Opus: Reservieren Sie es für wirklich komplexes Reasoning: Architekturentscheidungen, kniffliges Debugging, das Verstehen komplexer Systeme und Sicherheitsanalysen. Opus 4.6 (Februar 2026) stellt einen bedeutenden Fortschritt dar: Es plant sorgfältiger, hält agentische Aufgaben länger durch, arbeitet zuverlässiger in großen Codebasen und erkennt eigene Fehler beim Code Review besser.⁸⁶ Es bietet ein 1M-Token-Kontextfenster in der Beta und führt adaptives Thinking ein, das die Reasoning-Tiefe automatisch bestimmt. Laut Anthropic erreicht Opus 4.6 auf Terminal-Bench 2.0 den höchsten agentischen Coding-Score der Branche. Auf GDPval-AA (ökonomisch wertvolle Wissensarbeit) übertrifft es laut Anthropic GPT-5.2 um ~144 Elo-Punkte.⁸⁶ Hinweis: Pro-Abonnenten haben im Rahmen ihres Abonnements Zugang zu Opus.²⁰

Opusplan: Ein Hybridmodus, der Opus für die Planung (wo Reasoning-Qualität am wichtigsten ist) und Sonnet für die Ausführung (wo Geschwindigkeit zählt) einsetzt. Hervorragend geeignet für komplexes Refactoring, bei dem Sie den besten Plan möchten, aber nicht für jede einzelne Bearbeitung Opus-Niveau benötigen.

Modelle wechseln

Während einer Sitzung:

> /model opus
> /model sonnet
> /model haiku

Beim Start:

claude --model opus

Über Umgebungsvariablen:

export ANTHROPIC_MODEL=opus

In settings.json:

{
  "model": "claude-sonnet-4-5-20250929"
}

Speziell für Subagents:

export CLAUDE_CODE_SUBAGENT_MODEL=haiku

Erweiterter Kontext

Für große Codebasen oder lange Sitzungen können Sie den 1M-Token-Kontext aktivieren:

claude --model sonnet[1m]
claude --model opus[1m]           # Opus 4.6 with 1M context

Oder innerhalb einer Sitzung:

> /model sonnet[1m]
> /model opus[1m]

Ab v2.1.75 (13. März 2026) verwendet Opus 4.6 standardmäßig 1M Kontext für Max-, Team- und Enterprise-Pläne — das Suffix [1m] ist nicht erforderlich.¹²⁴ Für Sonnet und reine API-Nutzer bleibt das Suffix [1m] weiterhin notwendig.

Opus 4.6 ist das erste Opus-Klasse-Modell mit nativem 1M-Kontext-Support. Es erreicht 76 % Genauigkeit auf der 8-Needle-1M-Variante von MRCR v2 (Konkurrenten erzielen ~18,5 %), womit es das leistungsstärkste Modell für Long-Context-Retrieval ist.⁸⁶

Erweiterter Kontext kostet mehr pro Token (2x Input, 1,5x Output bei >200K Input-Token). Verwenden Sie [1m] bei Sonnet nur dann, wenn Sie es tatsächlich brauchen — nicht als Standard.

Aktuelles Modell überprüfen

> /status

Dieser Befehl zeigt das aktuelle Modell, Kontoinformationen, angewandte Einstellungen und weitere Sitzungsinformationen an.

Labels in der Modellauswahl (v2.1.51+): Die /model-Auswahl zeigt jetzt lesbare Bezeichnungen (z. B. „Sonnet 4.6”) statt roher Model-IDs für gepinnte Versionen an, mit Hinweisen auf verfügbare Upgrades.¹⁰⁵

Fast Mode (v2.1.36+)

Der Fast Mode liefert deutlich schnellere Ausgabe vom selben Modell — er wechselt nicht zu einem günstigeren Modell. Schalten Sie ihn während einer Sitzung mit /fast um.⁹³

> /fast            # Toggle fast mode on/off

Preise (Opus 4.6 Fast Mode):

Die Fast-Mode-Preise gelten für das gesamte Kontextfenster, einschließlich Anfragen mit über 200K Input-Token — im Fast Mode gibt es keinen zusätzlichen Aufschlag für langen Kontext.¹ Die Fast-Mode-Preise kumulieren sich mit Prompt Caching und Datenresidenz-Multiplikatoren, jedoch NICHT mit Long-Context-Preisen. Der Fast Mode ist mit der Batch-API nicht verfügbar.

Wann Sie den Fast Mode verwenden sollten: - Beim schnellen Iterieren über kleine Änderungen, wenn die Latenz der Engpass ist - Beim Generieren von Tests, Boilerplate oder repetitivem Code, wo Geschwindigkeit wichtiger als Kosten ist - Beim sequenziellen Abarbeiten einer Liste ähnlicher Aufgaben

Wann Sie den Fast Mode NICHT verwenden sollten: - Bei lang laufenden agentischen Aufgaben (die Kosten summieren sich schnell bei 6-fachen Preisen) - Bei Subagent-Arbeit im Hintergrund (niemand wartet auf die Ausgabe) - Bei budgetbewussten Sitzungen

Opus 4.6 Fast Mode umfasst jetzt das vollständige 1M-Kontextfenster (v2.1.50+). Zuvor war der Fast Mode auf den Standardkontext beschränkt; jetzt steht Ihnen dieselbe 1M-Token-Kapazität bei Fast-Mode-Geschwindigkeit zur Verfügung.¹⁰³

Expertentipp: Der Fast Mode lässt sich gut mit dem Opusplan-Hybridmodus kombinieren: Nutzen Sie den Fast Mode während der Sonnet-Ausführungsphase für schnelle Iterationen, während die Opus-Planungsphase zu Standardpreisen läuft. Beachten Sie, dass /fast voraussetzt, dass /extra-usage zuerst aktiviert ist (Fix in v2.1.37).⁹³

Was kostet Claude Code?

Das Verständnis und die Kontrolle der Kosten ist für eine nachhaltige Nutzung von Claude Code unerlässlich. Siehe auch Modellauswahl für Modellfähigkeiten und Entscheidungsrahmen für die Wahl des richtigen Modells pro Aufgabe.

Kosten anzeigen

> /cost

Ausgabe:

Total cost:            $0.55
Total duration (API):  6m 19.7s
Total duration (wall): 6h 33m 10.2s
Total code changes:    247 lines added, 89 lines removed

Abonnementpläne

Ratenlimits (August 2025): Anthropic hat wöchentliche Ratenlimits für zahlende Abonnenten eingeführt. Max-Abonnenten können zusätzliche Nutzung über das Ratenlimit hinaus zu den standardmäßigen API-Tarifen erwerben.²¹

API Token-Preise (Februar 2026)¹⁸⁶

Für API-abgerechnete Benutzer, Preise pro Million Token:

Preise für langen Kontext (>200K Eingabe-Token):

Der 200K-Schwellenwert basiert auf der Gesamtzahl der Eingabe-Token (einschließlich Cache-Lese-/Schreibvorgänge). Bei Überschreitung berechnet Anthropic alle Token zum Tarif für langen Kontext.¹

Preise für Datenresidenz: Die Angabe von ausschließlich US-basierter Inferenz über inference_geo fügt einen 1,1×-Multiplikator auf alle Token-Preise hinzu (nur Opus 4.6+ Modelle).¹

Prompt Caching reduziert die Kosten für wiederholte Eingaben erheblich: Cache-Schreibvorgänge kosten 1,25× des Basispreises (5-Minuten-Cache) oder 2× (1-Stunden-Cache), aber Cache-Lesevorgänge kosten nur 0,1× – eine Ersparnis von 90%. Für RAG-Systeme und Code-Assistenten mit wiederholtem Kontext kann Caching die Kosten um 88–95% senken.

Batch-API bietet 50% Rabatt bei 24-Stunden-Bearbeitungszeit für nicht dringende Aufgaben wie nächtliche Testsuiten.

Richtlinie für mehrere Konten⁵⁹

Können Sie mehrere Claude-Konten haben? Ja, für legitime Anwendungsfälle. Anthropic erlaubt ausdrücklich mehrere Konten, wenn sie unterschiedlichen Zwecken dienen.

Was erlaubt ist:

Technische Einschränkungen: - Bis zu 3 Konten können mit derselben Telefonnummer verifiziert werden - Mehrere kostenpflichtige Abonnements von derselben IP/demselben Netzwerk werden ausdrücklich unterstützt - Konten sind vollständig getrennt; kein Chat- oder Projekttransfer zwischen ihnen

Was verboten ist (gemäß der Nutzungsrichtlinie): - Erstellen von Konten zur Umgehung von Sperren nach einer Sperrung - Koordination böswilliger Aktivitäten über mehrere Konten zur Vermeidung der Erkennung - Verwendung mehrerer Konten zur Umgehung von Ratenlimits oder Free-Tier-Guthaben

Hinweis aus der Praxis: Im Januar 2026 wurden dem Power-User Jeffrey Emanuel (@doodlestein) 22 Max-Konten automatisch markiert und vorübergehend gesperrt. Anthropic-Mitarbeiter Thariq (@trq212) löste das Problem innerhalb von 4 Stunden nach Bestätigung der legitimen Nutzung. Wenn Sie Claude Code intensiv für berufliche und private Projekte über mehrere Konten hinweg nutzen, ist das genau der vorgesehene Anwendungsfall – versuchen Sie jedoch nicht, das System auszutricksen.

Im Zweifelsfall: Kontaktieren Sie den Anthropic-Support, um Ihr spezifisches Setup schriftlich bestätigen zu lassen.

Kostenfaktoren

Praxisbeispiele für Kosten

Tipp zur Kosteneinsparung: Die Verwendung von Haiku für Erkundungs-Subagents und Sonnet für die Implementierung reduziert die Kosten typischerweise um 40–50% im Vergleich zur ausschließlichen Verwendung von Sonnet.

Team-Kostenmanagement

Empfohlene TPM/RPM nach Teamgröße:

Versteckte Tool-Gebühren

Über die Token-Preise hinaus fallen für einige Tools separate Gebühren an:¹⁶

Diese summieren sich in Agent-Schleifen. Ein Debug-Zyklus mit 100 Iterationen und Bash kostet allein ~24.500 zusätzliche Eingabe-Token an Overhead.

Strategien zur Kosteneinsparung

1. Haiku für Subagents verwenden: Die meiste Erkundung benötigt kein Sonnet
2. Prompt Caching aktivieren: Standardmäßig aktiv, aber prüfen Sie, ob es nicht deaktiviert wurde
3. Maximale Durchläufe festlegen: claude --max-turns 5 verhindert ausufernde Konversationen
4. Plan-Modus für Erkundung nutzen: Keine Ausführung = keine versehentlich teuren Operationen
5. Proaktiv komprimieren: Kleinerer Kontext = weniger Token
6. Ausgabe begrenzen: export CLAUDE_CODE_MAX_OUTPUT_TOKENS=2000
7. Batch-API für nicht dringende Arbeiten: 50% Rabatt auf Eingabe- und Ausgabe-Token

Nutzung überwachen

• Claude-Konsole: platform.claude.com (erfordert die Rolle Admin oder Billing)
• Workspace-Limits: Ausgabenlimits pro Workspace festlegen
• Bedrock/Vertex: Native Cloud-Kostenüberwachung verwenden
• LiteLLM: Für detailliertes benutzerbezogenes Tracking mit Drittanbietern

Token-Verbrauch im Hintergrund

Einige Operationen verbrauchen Token im Hintergrund: - Konversationszusammenfassung für /resume - /cost- und /status-Befehle - Auto-Komprimierung

Typischerweise unter $0,04 pro Sitzung.

Claude Code Analytics API (Team/Enterprise)⁵³

Greifen Sie programmatisch auf die Claude Code-Nutzungsanalysen und Produktivitätskennzahlen Ihrer Organisation über die Admin-API zu.

Endpunkt: GET /v1/organizations/usage_report/claude_code

Voraussetzungen: - Admin-API-Schlüssel (sk-ant-admin...) - Team- oder Enterprise-Plan - Rolle: Admin, Billing oder Developer

Verfügbare Metriken:

Beispielanfrage:

curl "https://api.anthropic.com/v1/organizations/usage_report/claude_code?starting_at=2026-01-15" \
  -H "x-api-key: sk-ant-admin..." \
  -H "anthropic-version: 2023-06-01"

Anwendungsfälle: - Analyse der Entwicklerproduktivität (Sitzungen, Commits, PRs) - Tool-Nutzungsmetriken (Akzeptanz-/Ablehnungsraten für Edit, Write, etc.) - Kostenverfolgung und -zuordnung über Teams hinweg - ROI-Begründung für KI-Codierungstools

Hinweis: Daten erscheinen innerhalb von 1 Stunde nach Abschluss der Aktivität. Aus Konsistenzgründen werden nur Daten berücksichtigt, die älter als 1 Stunde sind.

Entscheidungsrahmen

Das Wissen um vorhandene Funktionen allein reicht nicht aus. Sie müssen wissen, wann Sie welche einsetzen. Diese Entscheidungsbäume verwandeln Wissen in Handlung.

Welches Modell sollte ich verwenden?

START → Ist die Aufgabe einfach? (Dateisuche, kurze Frage, Formatierung)
         │
         ├── JA → Verwenden Sie Haiku
         │         Kosten: ~$0,03/Aufgabe
         │         Geschwindigkeit: Am schnellsten
         │
         └── NEIN → Erfordert sie tiefgehendes Reasoning?
                  (Architektur, komplexes Debugging, Sicherheitsanalyse)
                  │
                  ├── JA → Verwenden Sie Opus 4.6
                  │         Kosten: ~$2,00/Aufgabe
                  │         Qualität: Höchste (1M Kontext, adaptives Thinking)
                  │
                  └── NEIN → Verwenden Sie Sonnet (Standard)
                           Kosten: ~$0,75/Aufgabe
                           Balance: Bestes Gesamtpaket

Faustregel: Beginnen Sie mit Sonnet. Wechseln Sie zu Haiku für Subagents. Eskalieren Sie nur dann zu Opus 4.6, wenn die Antwort von Sonnet oberflächlich wirkt. Mit Agent Teams (v2.1.32+) kann Opus mehrere Agents koordinieren, die parallel an verschiedenen Teilaufgaben arbeiten.⁸⁶

Command vs Skill vs Subagent vs Agent Team?

Möchten Sie explizite Kontrolle darüber, wann es ausgeführt wird?
│
├── JA → Verwenden Sie Slash Command
│         Beispiel: /deploy, /test, /security-review
│         Sie rufen es auf. Sie kontrollieren den Zeitpunkt.
│
└── NEIN → Soll die Expertise automatisch kontextbasiert angewendet werden?
         │
         ├── JA → Verwenden Sie Skill
         │         Beispiel: Sicherheits-Patterns, Domänenregeln, Code-Standards
         │         Claude erkennt den Kontext und wendet die Expertise an.
         │
         └── NEIN → Benötigt die Arbeit einen isolierten Kontext?
                  │
                  ├── JA → Gibt es eine Teilaufgabe oder mehrere parallele Teilaufgaben?
                  │         │
                  │         ├── EINE → Verwenden Sie Subagent (Task tool)
                  │         │         Beispiel: Tiefgehende Exploration, parallele Analyse
                  │         │         Verhindert Kontext-Aufblähung in der Hauptkonversation.
                  │         │
                  │         └── MEHRERE → Verwenden Sie Agent Team (v2.1.32+)
                  │                   Beispiel: 5 Agents überprüfen gleichzeitig verschiedene Module
                  │                   Opus koordiniert; jeder Agent arbeitet unabhängig.
                  │
                  └── NEIN → Prompten Sie einfach direkt
                           Nicht alles braucht eine Abstraktion.

Hook vs Prompt?

Muss die Aktion IMMER ausgeführt werden, unabhängig von der Einschätzung von Claude?
│
├── JA → Verwenden Sie Hook (deterministisch)
│         Beispiele:
│         - Code nach jeder Bearbeitung formatieren
│         - Alle Bash-Befehle protokollieren
│         - Zugriff auf .env-Dateien blockieren
│         Claude kann es nicht überspringen, vergessen oder anders entscheiden.
│
└── NEIN → Verwenden Sie Prompt (probabilistisch)
         Beispiele:
         - „Erwägen Sie, Tests hinzuzufügen"
         - „Denken Sie über Grenzfälle nach"
         - „Prüfen Sie bei Bedarf auf Sicherheit"
         Claude entscheidet kontextbasiert.

Wann sollte Extended Thinking verwendet werden?

Ist dies ein wirklich schwieriges Problem?
│
├── Architekturentscheidung mit vielen Abwägungen → JA, Thinking verwenden
├── Komplexes Debugging mit unklarer Ursache → JA, Thinking verwenden
├── Sicherheitsanalyse mit sorgfältigem Reasoning → JA, Thinking verwenden
├── Unbekannte Codebasis verstehen → JA, Thinking verwenden
│
├── Routine-Bugfix → NEIN, Thinking überspringen
├── Einfaches Refactoring → NEIN, Thinking überspringen
├── Code-Formatierung → NEIN, Thinking überspringen
└── Schnelle Fragen → NEIN, Thinking überspringen

Umschalten mit Alt+T während der Sitzung. Höhere Thinking-Budgets kosten mehr; beginnen Sie mit dem Minimum und erhöhen Sie nur, wenn sich Antworten gehetzt anfühlen.

Opus 4.6 adaptives Thinking: Opus 4.6 passt die Denktiefe automatisch an die Problemkomplexität an. Für die meisten Aufgaben ist eine explizite Steuerung des Thinking-Budgets nicht nötig – Opus skaliert bei schwierigen Problemen hoch und bleibt bei einfachen schnell. Manuelles Thinking-Umschalten ist am nützlichsten mit Sonnet, wenn Sie eine tiefere Analyse erzwingen möchten.

Welche Ausführungsumgebung?

Wo soll die Arbeit stattfinden?
│
├── Erfordert IHRE lokalen Dateien und Tools
│   │
│   ├── Interaktive, iterative Arbeit → Haupt-REPL-Sitzung
│   ├── Einmalige skriptgesteuerte Aufgabe → claude -p "prompt" (Print-Modus)
│   ├── CI/CD-Automatisierung → claude -p --json (nicht-interaktiv + strukturierte Ausgabe)
│   └── Parallele isolierte Aufgaben → Subagents via Task tool
│
├── Erfordert die Umgebung EINER ANDEREN PERSON
│   │
│   └── Remote-Codebasis oder Server → Background Agent (Cloud)
│
└── Erfordert keine Umgebung
    │
    ├── Recherche oder Analyse → Subagent mit Explore-Typ
    └── Web-Inhaltsextraktion → WebFetch / WebSearch tools

Agent Teams vs Subagents vs parallele Sitzungen

Benötigen Sie mehrere Agents, die an verwandten Teilaufgaben arbeiten?
│
├── JA → Sind die Teilaufgaben unabhängig (kein gemeinsamer State)?
│         │
│         ├── JA → Können sie dieselbe Codebasis teilen?
│         │         │
│         │         ├── JA → Verwenden Sie Agent Team (v2.1.32+)
│         │         │         Opus koordiniert. Agents teilen den Repo-Zugriff.
│         │         │         Beispiel: „Auth-, API- und DB-Module parallel reviewen"
│         │         │
│         │         └── NEIN → Verwenden Sie parallele Sitzungen (separate Terminals)
│         │                  Jede hat ihr eigenes Arbeitsverzeichnis.
│         │                  Beispiel: „Repo-A und Repo-B gleichzeitig fixen"
│         │
│         └── NEIN → Verwenden Sie sequentielle Subagents
│                  Ergebnisse eines fließen in den nächsten ein.
│                  Beispiel: „Explore → Plan → Implement"
│
└── NEIN → Verwenden Sie einzelnen Subagent oder Haupt-REPL

Welcher Hook-Typ?

Welche Art von Automatisierung benötigen Sie?
│
├── Einen Shell-Befehl bei einem bestimmten Ereignis ausführen?
│   │
│   └── Verwenden Sie Command Hook
│       Trigger: PreToolUse, PostToolUse, Notification, Stop, SubagentStop
│       Beispiel: „Prettier nach jeder Dateibearbeitung ausführen"
│       Config: hooks.PostToolUse[].command = "prettier --write $FILE"
│
├── Den System-Prompt von Claude kontextbasiert anpassen?
│   │
│   └── Verwenden Sie Prompt Hook (v2.1.35+)
│       Trigger: Dieselben Ereignisse
│       Beispiel: „Projektregeln injizieren, wenn in /src/auth/ gearbeitet wird"
│       Config: hooks.PreToolUse[].prompt = "When editing auth files..."
│
└── Soll Claude vor dem Fortfahren eine Einschätzung vornehmen?
    │
    └── Verwenden Sie Agent Hook (v2.1.35+)
        Trigger: Dieselben Ereignisse
        Beispiel: „Bewerten, ob dieser Bash-Befehl sicher ist, bevor er ausgeführt wird"
        Config: hooks.PreToolUse[].agent = { prompt: "Is this safe?" }

Wann sollte /fast verwendet werden?

Ist die Antwortgeschwindigkeit gerade wichtiger als die Tiefe?
│
├── JA → Verwenden Sie /fast
│         Dasselbe Opus 4.6 Modell, schnellere Ausgabe
│         Gut für: schnelle Fragen, einfache Bearbeitungen, Code-Erklärungen,
│                   Dateisuchen, Formatierungsaufgaben
│
└── NEIN → Bleiben Sie im normalen Modus
         Gut für: Architekturentscheidungen, komplexes Debugging,
                   Sicherheits-Reviews, Multi-Datei-Refactoring,
                   alles, was tiefgehendes Reasoning erfordert

/fast schaltet den Fast-Modus für die aktuelle Sitzung um. Es verwendet dasselbe Modell (Opus 4.6) mit optimierter Ausgabegeschwindigkeit – es wechselt NICHT zu einem günstigeren Modell.

Wie funktioniert das Berechtigungssystem?

Das Berechtigungssystem von Claude Code bietet eine feingranulare Kontrolle darüber, welche Operationen ausgeführt werden dürfen. Ein genaues Verständnis dieses Systems ist sowohl für die Sicherheit als auch für die Effizienz Ihres Arbeitsablaufs unerlässlich. Siehe auch Enterprise Deployment für verwaltete Einstellungen, die Berechtigungen organisationsweit durchsetzen.

Berechtigungsstufen

Schreibgeschützte Tools (automatisch genehmigt): - Read – Dateiinhalte lesen - Glob – Dateien nach Muster suchen - Grep – Dateiinhalte durchsuchen - WebSearch – Im Web suchen - LSP – Code-Intelligenz (Zur-Definition-springen, Referenzen finden, Hover-Dokumentation)²⁵

LSP-Tool-Funktionen (v2.0.74+): Das LSP-Tool bietet IDE-ähnliche Code-Intelligenz: - Zur Definition springen: Direkt zur Stelle navigieren, an der ein Symbol definiert ist - Referenzen finden: Alle Verwendungen eines Symbols in der gesamten Codebasis auflisten - Hover-Dokumentation: Typinformationen und Dokumentation für beliebige Symbole abrufen - Funktioniert mit TypeScript, Python, Go, Rust und anderen Sprachen mit LSP-Unterstützung - Erfordert einen verfügbaren Language Server (in der Regel mit Ihrer Toolchain installiert)

Modifikations-Tools (Genehmigung erforderlich): - Edit – Bestehende Dateien ändern - Write – Neue Dateien erstellen - Bash – Shell-Befehle ausführen - WebFetch – URL-Inhalte abrufen - NotebookEdit – Jupyter-Notebooks bearbeiten

Beim ersten Aufruf eines Modifikations-Tools fordert Claude Code eine Genehmigung an. Erteilte Genehmigungen gelten für die gesamte Sitzung, sofern nicht explizit anders konfiguriert.

Berechtigungsmodi

YOLO-Modus (v2.0.68+): Für vollständig autonomen Betrieb verwenden Sie das Flag --dangerously-skip-permissions. Dieses Flag stimmt allem zu: Dateiänderungen, Bash-Befehle, sämtliche Tool-Aufrufe. Das Wort „dangerous” ist bewusst gewählt. Verwenden Sie diesen Modus ausschließlich in isolierten Umgebungen oder wenn Sie der Codebasis vollständig vertrauen.⁶¹

claude --dangerously-skip-permissions

Modus per CLI festlegen:

claude --permission-mode acceptEdits

Während einer Sitzung umschalten:

Shift+Tab  # Cycles through modes

In settings.json:

{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}

Syntax für Berechtigungsregeln

Feingranulare Regeln steuern bestimmte Operationen. Regeln werden der Reihe nach ausgewertet: der erste Treffer gewinnt.

Bash-Befehlsmuster:

{
  "allow": [
    "Bash(npm run build)",
    "Bash(npm run test:*)",
    "Bash(git commit:*)",
    "Bash(make:*)"
  ],
  "deny": [
    "Bash(rm -rf:*)",
    "Bash(sudo:*)",
    "Bash(curl|wget:*)"
  ]
}

Das Sternchen ermöglicht Präfix-Abgleich: Bash(npm run test:*) erlaubt npm run test, npm run test:unit und npm run test:integration.

Wichtige Einschränkung: Bash-Muster gleichen nur Präfixe ab, keine regulären Ausdrücke. Ein Muster wie Bash(curl http:*) stimmt nicht mit curl -X GET http://... überein, da die Optionen vor der URL stehen. Für zuverlässiges Blockieren verbieten Sie den Befehl vollständig: Bash(curl:*).

Dateioperationsmuster:

{
  "allow": [
    "Edit(src/**)",
    "Write(src/**)",
    "Read(docs/**)"
  ],
  "deny": [
    "Read(.env*)",
    "Read(secrets/**)",
    "Edit(.git/**)",
    "Edit(node_modules/**)"
  ]
}

Pfad-Syntax: - Relative Pfade: Edit(src/**) – relativ zum Arbeitsverzeichnis - Absolut ab Einstellungsdatei: Edit(/build/**) – relativ zum Speicherort der Einstellungsdatei - Echt absolut: Edit(//tmp/**) – beginnt mit // - Home-Verzeichnis: Read(~/.zshrc)

MCP-Tool-Muster:

{
  "allow": [
    "mcp__github",
    "mcp__database__query",
    "mcp__myserver__*"
  ],
  "deny": [
    "mcp__dangerous_server",
    "mcp__untrusted__*"
  ]
}

Verwenden Sie die Wildcard-Syntax mcp__server__*, um alle Tools eines bestimmten MCP-Servers zuzulassen oder zu verbieten.³⁹ Die Wildcard-Syntax eignet sich hervorragend, um schnell alle Tools vertrauenswürdiger Server freizugeben oder ganze Server aus nicht vertrauenswürdigen Quellen zu blockieren.

WebFetch-Muster:

{
  "allow": [
    "WebFetch(domain:github.com)",
    "WebFetch(domain:api.example.com)"
  ]
}

Zusätzliche Verzeichnisse

Erweitern Sie den Zugriff von Claude über das aktuelle Projekt hinaus:

{
  "permissions": {
    "additionalDirectories": [
      "../shared-lib",
      "../docs",
      "~/reference-projects/design-system"
    ]
  }
}

Zusätzliche Verzeichnisse sind bei Monorepos oder wenn Claude auf Code in benachbarten Verzeichnissen zugreifen muss unverzichtbar.

Sandbox-Modus

Dateisystem- und Netzwerkisolierung aktivieren:

> /sandbox

Oder in den Einstellungen konfigurieren:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["git", "docker"],
    "network": {
      "allowUnixSockets": ["~/.ssh/agent-socket"],
      "allowLocalBinding": true
    }
  }
}

Im Sandbox-Modus gilt: - Dateisystemzugriff auf das Projektverzeichnis beschränkt - Netzwerkzugriff kontrolliert - Bestimmte Befehle von Sandbox-Beschränkungen ausgenommen - Bash-Befehle automatisch genehmigt, wenn autoAllowBashIfSandboxed aktiviert ist

Expertentipp: Der Sandbox-Modus eignet sich hervorragend, um Claude auf nicht vertrauenswürdigen Codebasen auszuführen. Aktivieren Sie ihn beim Erkunden unbekannter Projekte oder wenn Sie eine zusätzliche Schutzschicht wünschen. Interne Tests von Anthropic haben ergeben, dass Sandboxing die Berechtigungsabfragen um 84 % reduziert.⁴⁵ Die Sandbox nutzt Betriebssystem-Primitive (macOS Seatbelt, Linux Bubblewrap) für Dateisystem- und Netzwerkisolierung, sodass selbst eine erfolgreiche Prompt Injection vollständig eingedämmt wird. Anthropic hat die Sandbox-Laufzeitumgebung als Open Source veröffentlicht für Teams, die eigene Agents entwickeln.⁸⁹

Sicherheitshinweise (v2.1.34+): Befehle, die über sandbox.excludedCommands oder dangerouslyDisableSandbox vom Sandboxing ausgenommen waren, konnten zuvor die Bash-Berechtigungsregel umgehen, wenn autoAllowBashIfSandboxed aktiviert war; dies wurde in v2.1.34 behoben.⁹⁴ Seit v2.1.38 sind Schreibzugriffe auf .claude/skills im Sandbox-Modus blockiert, um zu verhindern, dass Prompt Injection Skill-Definitionen verändert.⁹⁵ v2.1.77 fügt eine allowRead-Sandbox-Dateisystemeinstellung hinzu, die Lesezugriff innerhalb von denyRead-Bereichen wieder erlaubt – nützlich, wenn Sie den Großteil einer Verzeichnisstruktur sperren, aber bestimmte Unterverzeichnisse freigeben möchten.¹²⁶

Wie funktionieren Hooks?

Hooks führen deterministische Shell-Befehle an bestimmten Punkten im Workflow von Claude Code aus. Anders als bei der Aufforderung an Claude, Aktionen durchzuführen, garantieren Hooks die Ausführung unabhängig vom Modellverhalten. Sie sind unverzichtbar, um Teamstandards durchzusetzen und wiederkehrende Aufgaben zu automatisieren. Siehe Entscheidungsframeworks für den Entscheidungsbaum „Welcher Hook-Typ?” zu Command-, Prompt- und Agent-Hooks.

Warum Hooks statt Prompts: Claude anzuweisen, „nach dem Bearbeiten von Dateien immer Prettier auszuführen”, funktioniert manchmal. Allerdings könnte Claude es vergessen, Geschwindigkeit priorisieren oder entscheiden, die Änderung sei „zu klein”. Hooks garantieren die Ausführung: Jedes Edit oder Write löst Ihren Formatter aus, jedes Mal, ohne Ausnahme. Für Compliance, Sicherheit und Teamstandards schlägt Determinismus Wahrscheinlichkeit.⁷

Verfügbare Events

Hook-Konfiguration

Definieren Sie Hooks in settings.json oder einer dedizierten hooks.json:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$FILE_PATH\""
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/validate-bash.sh"
          }
        ]
      }
    ],
    "UserPromptSubmit": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/inject-context.sh"
          }
        ]
      }
    ]
  }
}

Matcher

Das Feld matcher bestimmt, welche Tools einen Hook auslösen:

{"matcher": "*"}              // Match all tools
{"matcher": "Bash"}           // Match Bash only
{"matcher": "Edit|Write"}     // Match Edit or Write
{"matcher": "mcp__github"}    // Match MCP server tools
{"matcher": ""}               // Match for events without tools (like UserPromptSubmit)

Hook-Ein-/Ausgabeprotokoll

Hooks empfangen JSON über stdin:

{
  "tool_name": "Bash",
  "tool_input": {
    "command": "npm test",
    "description": "Run test suite"
  },
  "session_id": "abc-123"
}

Hook-Event-Anreicherung (v2.1.69+): Alle Hook-Events enthalten jetzt die Felder agent_id und agent_type, wenn sie von einem Subagent oder einer --agent-Sitzung ausgelöst werden, sowie ein worktree-Feld in Statuszeilen-Hook-Befehlen.¹¹⁷

Stop/SubagentStop-Hooks (v2.1.47+) erhalten ein zusätzliches Feld last_assistant_message mit dem finalen Antworttext von Claude, sodass Hooks die Ausgabe inspizieren können, ohne Transkript-Dateien parsen zu müssen:

{
  "session_id": "abc-123",
  "last_assistant_message": "I've completed the refactoring. Here's what changed..."
}

Exit-Codes steuern das Verhalten: - 0: Erfolg: Die Operation wird fortgesetzt. Stdout wird im Verbose-Modus angezeigt (Ctrl+O). Bei UserPromptSubmit und SessionStart wird Stdout dem Kontext hinzugefügt. - 2: Blockierender Fehler: Die Operation wird gestoppt. Stderr wird zur Fehlermeldung, die an Claude weitergegeben wird. - 1, 3, etc.: Nicht-blockierender Fehler: Die Operation wird fortgesetzt. Stderr wird als Warnung im Verbose-Modus angezeigt.

Für erweiterte Steuerung können Hooks JSON ausgeben:

{
  "decision": "allow",
  "message": "Command validated and modified",
  "modifications": {
    "tool_input": {
      "command": "npm test -- --coverage"
    }
  }
}

PreToolUse-Entscheidungssteuerung (bevorzugtes Format): PreToolUse-Hooks verwenden hookSpecificOutput für eine detailliertere Steuerung: drei Ergebnisse (allow/deny/ask) sowie die Möglichkeit, Tool-Eingaben zu modifizieren und Kontext zu injizieren:⁹⁶

{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "allow",
    "permissionDecisionReason": "Command validated and modified",
    "updatedInput": {
      "command": "npm test -- --coverage --ci"
    },
    "additionalContext": "Note: This database has a 5-second query timeout."
  }
}

Hinweis: Die Top-Level-Felder decision und reason sind für PreToolUse veraltet. Verwenden Sie stattdessen hookSpecificOutput.permissionDecision und hookSpecificOutput.permissionDecisionReason. Andere Events (PostToolUse, Stop usw.) verwenden weiterhin decision auf Top-Level-Ebene.⁹⁶

Asynchrone Hooks (Januar 2026)

Hooks können jetzt im Hintergrund ausgeführt werden, ohne die Ausführung von Claude Code zu blockieren. Fügen Sie async: true zu Ihrer Hook-Konfiguration hinzu:⁸⁸

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/notify-slack.sh",
            "async": true
          }
        ]
      }
    ]
  }
}

Wann Sie asynchrone Hooks verwenden sollten: - Benachrichtigungen (Slack, E-Mail, Pushover), die die Sitzung nicht verlangsamen sollten - Logging und Telemetrie, die im Hintergrund laufen können - Nicht-kritische Nachbearbeitung (Analysen, Backups)

Wann Sie asynchrone Hooks NICHT verwenden sollten: - Formatierung (muss vor der nächsten Bearbeitung abgeschlossen sein) - Validierung (muss bei Fehlern blockieren) - Jeder Hook, der Tool-Ein-/Ausgabe modifizieren muss

Prompt-basierte und Agent-basierte Hooks (v2.1.32+)

Über Shell-Befehl-Hooks (type: "command") hinaus unterstützt Claude Code zwei LLM-gestützte Hook-Typen, die Bedingungen mittels KI-Reasoning anstelle von Skripten evaluieren.⁹⁶

Prompt-Hooks (type: "prompt") senden einen Single-Turn-Prompt an ein schnelles Claude-Modell. Das Modell gibt { "ok": true } zum Zulassen oder { "ok": false, "reason": "..." } zum Blockieren zurück:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "prompt",
            "prompt": "Evaluate if Claude should stop: $ARGUMENTS. Check if all requested tasks are complete and tests pass.",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

HTTP-Hooks (type: "http") senden die JSON-Eingabe des Events als POST-Request an eine URL und erhalten JSON zurück. Verwenden Sie diese für Webhooks, externe Benachrichtigungsdienste oder API-basierte Validierung (v2.1.63+):¹¹¹

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "http",
            "url": "https://api.example.com/notify",
            "headers": {
              "Authorization": "Bearer $MY_TOKEN"
            },
            "allowedEnvVars": ["MY_TOKEN"]
          }
        ]
      }
    ]
  }
}

HTTP-Hooks verwenden dasselbe Entscheidungsformat wie Command-Hooks (Rückgabe von JSON mit decision und reason). Sie werden über den Sandbox-Netzwerk-Proxy geleitet, wenn Sandboxing aktiviert ist. Nicht unterstützt für SessionStart/Setup-Events.

Agent-Hooks (type: "agent") starten einen Subagent mit Tool-Zugriff (Read, Grep, Glob) für mehrstufige Verifizierung. Verwenden Sie diese, wenn die Prüfung die Inspektion tatsächlicher Dateien oder Testausgaben erfordert:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "agent",
            "prompt": "Verify all unit tests pass. Run the test suite and check results. $ARGUMENTS",
            "timeout": 120
          }
        ]
      }
    ]
  }
}

Verwenden Sie $ARGUMENTS als Platzhalter für die JSON-Eingabe des Hooks. Beide Typen unterstützen die Felder model (Standard: schnelles Modell) und timeout. Unterstützte Events: PreToolUse, PostToolUse, PostToolUseFailure, PermissionRequest, UserPromptSubmit, Stop, SubagentStop, TaskCompleted. TeammateIdle unterstützt keine Prompt-/Agent-Hooks.

Hook-Umgebungsvariablen

Hooks haben Zugriff auf Umgebungsvariablen zur Pfadauflösung:⁹⁶

Umgebungsvariablen aus SessionStart persistieren:

#!/bin/bash
if [ -n "$CLAUDE_ENV_FILE" ]; then
  echo 'export NODE_ENV=production' >> "$CLAUDE_ENV_FILE"
fi
exit 0

HTTP-Hook-Sicherheit (v2.1.51+): HTTP-Hooks, die Umgebungsvariablen in Header interpolieren, erfordern jetzt eine explizite allowedEnvVars-Liste. Dies verhindert die beliebige Exfiltration von Umgebungsvariablen über Header-Werte. HTTP-Hooks werden zudem über den Sandbox-Netzwerk-Proxy geleitet, wenn Sandboxing aktiviert ist, und erzwingen die Domain-Allowlist. HTTP-Hooks werden für SessionStart/Setup-Events nicht unterstützt.¹⁰⁵

{
  "hooks": {
    "PostToolUse": [{
      "hooks": [{
        "type": "command",
        "command": "curl -H 'Authorization: Bearer $MY_TOKEN' https://api.example.com/notify",
        "allowedEnvVars": ["MY_TOKEN"]
      }]
    }]
  }
}

Hook-Workspace-Trust (v2.1.51+): statusLine- und fileSuggestion-Hook-Befehle erfordern jetzt im interaktiven Modus die Annahme des Workspace-Trust, bevor sie ausgeführt werden, und schließen damit einen potenziellen Sicherheitsvektor.¹⁰⁵

Praktische Hook-Beispiele

TypeScript-Dateien nach dem Bearbeiten automatisch formatieren:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c '[[ \"$FILE_PATH\" == *.ts ]] && npx prettier --write \"$FILE_PATH\" || true'"
          }
        ]
      }
    ]
  }
}

Alle Bash-Befehle protokollieren:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.command' >> ~/.claude/bash-history.log"
          }
        ]
      }
    ]
  }
}

Zugriff auf sensible Dateien blockieren:

#!/bin/bash
# .claude/hooks/protect-files.sh
data=$(cat)
path=$(echo "$data" | jq -r '.tool_input.file_path // empty')

if [[ "$path" == *".env"* ]] || [[ "$path" == *"secrets/"* ]] || [[ "$path" == *".pem"* ]]; then
  echo "Blocked: Cannot access sensitive file $path" >&2
  exit 2  # Exit 2 = block the tool call. Exit 1 = non-blocking error (hook failure only).
fi
exit 0

Tests nach Codeänderungen ausführen:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c '[[ \"$FILE_PATH\" == *.test.ts ]] || npm run test:affected'"
          }
        ]
      }
    ]
  }
}

Benutzerdefiniertes Benachrichtigungssystem:

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "notify-send 'Claude Code' 'Waiting for your input'"
          }
        ]
      }
    ]
  }
}

Dynamischen Kontext in Prompts injizieren:

#!/bin/bash
# .claude/hooks/inject-context.sh
# Add current git branch and recent commits to every prompt

branch=$(git branch --show-current 2>/dev/null)
commits=$(git log --oneline -3 2>/dev/null | tr '\n' ' ')

if [ -n "$branch" ]; then
  echo "[Context: Branch '$branch', Recent: $commits]"
fi
exit 0

Hook-Debugging

Aktivieren Sie den Debug-Modus, um Hooks zu analysieren:

claude --debug

Der Debug-Modus protokolliert: - Hook-Ausführungszeiten - Ein-/Ausgabedaten - Fehlermeldungen und Stack-Traces - Entscheidungsergebnisse (allow/reject/ask)

Hook-Quellanzeige (v2.1.75+): Wenn ein Hook eine Benutzerbestätigung erfordert, zeigt der Berechtigungsdialog jetzt die Quelle des Hooks an (Einstellungen, Plugin oder Skill), was die Identifizierung der zugreifenden Komponente erleichtert.¹²⁴

Komponentenbezogene Hooks (v2.1.0+)

Hooks können direkt in Skills, Subagents und Slash-Befehlen über Frontmatter definiert werden. Diese Hooks sind auf den Lebenszyklus der Komponente beschränkt und werden nur ausgeführt, wenn diese Komponente aktiv ist.⁴¹

Skill mit eingebetteten Hooks:

---
name: secure-deployment
description: Deployment skill with security validation
hooks:
  PreToolUse:
    - matcher: Bash
      command: ".claude/hooks/validate-deploy.sh"
  PostToolUse:
    - matcher: Bash
      command: ".claude/hooks/log-deploy.sh"
  Stop:
    - command: ".claude/hooks/cleanup.sh"
      once: true  # Run only once per session
---

Unterstützte Events: PreToolUse, PostToolUse, Stop

Die Option once (nur für Skills und Slash-Befehle) stellt sicher, dass der Hook nur einmal pro Sitzung ausgeführt wird – nützlich für Bereinigungs- oder Abschlussaufgaben.

Strategie für Langzeitsitzungen

Für über Nacht laufende oder unbeaufsichtigte Claude Code-Sitzungen konfigurieren Sie Hooks so, dass Claude ohne manuelles Eingreifen auf Kurs bleibt. Die zentrale Erkenntnis: Nutzen Sie Linting- und Testing-Hooks als Leitplanken, die Claude zwingen, Probleme zu beheben, bevor es weitermacht.⁶⁴

Das „Nicht stoppen, bis Tests bestehen”-Muster:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint && npm run typecheck",
            "timeout": 60000
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "npm test || echo 'Tests failing - Claude should fix before stopping'"
          }
        ]
      }
    ]
  }
}

Strategie für Über-Nacht-Sitzungen:

1. Vorabprüfung: Verwenden Sie einen Setup-Hook, um zu verifizieren, dass die Umgebung bereit ist
2. Kontinuierliche Validierung: PostToolUse-Hooks führen nach jeder Änderung Tests aus
3. Abschluss-Gate: Stop-Hooks verifizieren alle Akzeptanzkriterien, bevor Claude „fertig” meldet
4. Benachrichtigung: Stop-Hooks können Sie über Slack/Pushover benachrichtigen, wenn Claude fertig ist oder feststeckt

Kombinieren Sie dies mit --dangerously-skip-permissions in einem Sandbox-Container für vollständig autonome Über-Nacht-Durchläufe. Claude iteriert weiter, bis die Tests bestehen oder alle Optionen ausgeschöpft sind.

Was ist MCP (Model Context Protocol)?

MCP erweitert Claude Code um den Zugriff auf externe Tools, Datenbanken, APIs und Dienste über ein standardisiertes Protokoll. Das Ökosystem ist rasant gewachsen: MCP verzeichnet mittlerweile 100 Millionen monatliche Downloads und über 3.000 Server, die auf MCP.so indexiert sind (Januar 2026), und hat sich damit als Industriestandard für die Verbindung von KI mit Tools und Daten etabliert.³⁵⁴ Das Verständnis von MCP ist essenziell, um Claude in Ihre bestehende Toolchain zu integrieren.

Warum MCP für Entwickler wichtig ist: Ohne MCP kann Claude Code nur Dateien lesen und Bash-Befehle ausführen. Mit MCP kann Claude Ihre Produktionsdatenbank abfragen, Jira-Tickets erstellen, GitHub-PRs überprüfen, Sentry-Fehler prüfen und mit jeder API interagieren, die Ihr Team nutzt — alles über natürlichsprachliche Anfragen. Das Protokoll standardisiert, wie KI-Tools sich mit externen Diensten verbinden, und verhindert so Herstellerabhängigkeit. Siehe Entscheidungsrahmen für Empfehlungen, wann Sie MCP im Vergleich zu anderen Erweiterungsmechanismen einsetzen sollten.

Remote-MCP-Unterstützung (Juni 2025)

Claude Code unterstützt jetzt Remote-MCP-Server mit nativer OAuth-Authentifizierung.²⁸ Verbinden Sie sich mit Tools und Datenquellen, ohne lokale Server verwalten zu müssen. Authentifizieren Sie sich einmal, und Claude Code übernimmt die Token-Aktualisierung automatisch.

# Connect to remote MCP server with OAuth
claude mcp add --transport http linear https://mcp.linear.app/sse
# Browser opens for OAuth flow, tokens stored securely

claude.ai-MCP-Konnektoren (v2.1.46+)

Claude Code kann jetzt MCP-Konnektoren verwenden, die in Ihrem claude.ai-Konto konfiguriert sind. Dies schließt die Lücke zwischen Web und CLI: MCP-Server, die Sie über die claude.ai-Oberfläche eingerichtet haben, sind automatisch in Claude Code verfügbar, ohne dass Sie sie lokal neu konfigurieren müssen.¹⁰²

Deaktivierung: Setzen Sie ENABLE_CLAUDEAI_MCP_SERVERS=false in Ihrer Umgebung oder im env-Block der settings.json, um das Laden von claude.ai-MCP-Servern zu verhindern.¹¹¹

MCP Tool Search (v2.1.7+)

Da MCP-Server immer leistungsfähiger wurden (manche bieten über 50 Tools an), begannen Tool-Beschreibungen übermäßig viel Kontext zu verbrauchen. MCP Tool Search löst dieses Problem durch dynamisches Laden von Tool-Beschreibungen nur bei Bedarf — eine Form von Lazy Loading für KI-Tools.⁵⁴

Leistungsauswirkungen: Interne Benchmarks zeigen deutliche Genauigkeitsverbesserungen: - Opus 4: 49 % → 74 % bei MCP-Evaluierungen - Opus 4.5: 79,5 % → 88,1 % bei MCP-Evaluierungen - Reduktion des Token-Overheads: 85 %

Funktionsweise: Wenn MCP-Tool-Beschreibungen 10 % des Kontextfensters überschreiten (Standard-Schwellenwert), verzögert Claude Code das Laden der vollständigen Beschreibungen, bis sie tatsächlich benötigt werden. Claude sieht die Tool-Namen, ruft die Beschreibungen aber bei Bedarf ab.

Konfiguration:

{
  "mcpToolSearchAutoEnable": "auto:15"  // Enable when tools exceed 15% of context
}

Werte: - true – Tool Search immer aktivieren - false – Immer deaktivieren (alle Tool-Beschreibungen sofort laden) - auto:N – Aktivieren, wenn Tools N % des Kontexts überschreiten (0–100)

Expertentipp: Mit aktiviertem Tool Search können Sie deutlich mehr MCP-Server verbinden, ohne sich um Kontextlimits sorgen zu müssen. Die 95-prozentige Kontextreduktion bedeutet, dass Server, die zuvor um Kontext konkurrierten, nun problemlos koexistieren.

MCP Elicitation (v2.1.76+)

MCP-Server können jetzt während einer Aufgabe über interaktive Dialoge strukturierte Eingaben vom Benutzer anfordern.¹²⁵ Wenn ein MCP-Server zusätzliche Informationen benötigt (z. B. Auswahl eines Branches, Eingabe eines Projektnamens, Bestätigung einer Aktion), sendet er eine Elicitation-Anfrage, die Claude Code als Formularfelder oder Browser-URL darstellt.

Hook-Integration: Zwei neue Hook-Events — Elicitation (bevor der Dialog erscheint) und ElicitationResult (nachdem der Benutzer geantwortet hat) — ermöglichen es Ihnen, Elicitation-Antworten programmatisch abzufangen, zu validieren oder zu überschreiben. Dies ermöglicht Enterprise-Workflows, bei denen MCP-Server-Eingabeaufforderungen vorausgefüllt oder durch Richtlinien eingeschränkt werden.

Interaktiver MCP-Einrichtungsassistent

Führen Sie claude mcp add ohne Argumente aus, um eine schrittweise Oberfläche zum Hinzufügen von MCP-Servern zu starten. Der Assistent führt Sie durch die Auswahl des Transporttyps, die Authentifizierung und die Konfiguration.¹⁵

Transporttypen

HTTP (empfohlen für Remote-Server):

claude mcp add --transport http github https://api.githubcopilot.com/mcp/

# With authentication
claude mcp add --transport http api https://api.example.com/mcp \
  --header "Authorization: Bearer $API_TOKEN"

SSE (veraltet, aber funktionsfähig):

claude mcp add --transport sse asana https://mcp.asana.com/sse \
  --header "X-API-Key: your-key"

Stdio (lokale Server):

# PostgreSQL
claude mcp add --transport stdio postgres \
  --env "DATABASE_URL=postgresql://user:pass@localhost/db" \
  -- npx -y @anthropic-ai/mcp-server-postgres

# Custom server
claude mcp add --transport stdio custom -- python /path/to/server.py --port 8000

Unter Windows ist ein cmd-Wrapper für Stdio erforderlich:

claude mcp add --transport stdio my-server -- cmd /c npx -y @some/package

Bereichsverwaltung

MCP-Server existieren in drei Bereichen mit klarer Rangfolge (Lokal überschreibt Projekt, Projekt überschreibt Benutzer):

Bereich bei der Installation angeben:

claude mcp add --scope project --transport http github https://...
claude mcp add --scope user --transport stdio personal-tool -- ./my-tool

Format der Konfigurationsdatei

Die Datei .mcp.json definiert Server auf Projektebene:

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "database": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    },
    "sentry": {
      "type": "http",
      "url": "https://mcp.sentry.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${SENTRY_API_KEY}"
      }
    },
    "internal-api": {
      "type": "http",
      "url": "${API_BASE_URL:-https://api.example.com}/mcp",
      "headers": {
        "X-API-Key": "${INTERNAL_API_KEY}"
      }
    }
  }
}

Umgebungsvariablen werden mit der Syntax ${VAR} expandiert, mit optionalen Standardwerten: ${VAR:-default}.

MCP-Verwaltungsbefehle

claude mcp list                      # View all configured servers
claude mcp get github                # Get specific server details
claude mcp remove github             # Remove a server
claude mcp reset-project-choices     # Reset project-scoped approvals
claude mcp add-from-claude-desktop   # Import from Claude Desktop
claude mcp add-json weather '{"type":"http","url":"..."}'  # Add from JSON

# Within Claude Code REPL
> /mcp                               # Interactive MCP management

OAuth-Authentifizierung

Für Server, die OAuth erfordern:

> /mcp
# Follow browser-based OAuth flow
# Tokens stored securely and auto-refreshed
# Use "Clear authentication" to revoke access

Verwendung von MCP-Ressourcen und Prompts

Ressourcen referenzieren:

@github:issue://123
@postgres:schema://users
@docs:file://api/authentication

MCP-Prompts als Slash-Befehle:

/mcp__github__list_prs
/mcp__github__pr_review 456
/mcp__jira__create_issue "Bug title" high

Ausgabelimits

Claude Code begrenzt die MCP-Ausgabe, um einen Kontextüberlauf zu verhindern: - Warnschwelle: 10.000 Token - Standardmaximum: 25.000 Token

Bei Bedarf erhöhen:

export MAX_MCP_OUTPUT_TOKENS=50000

Beliebte MCP-Server

Praktische MCP-Muster

GitHub-Workflow:

> Review PR #456
> List all open issues assigned to me
> Create a bug issue for the authentication failure we found

Datenbankabfragen:

> What's our total revenue this quarter?
> Show the schema for the users table
> Find customers with no purchases in 90 days

Fehlerüberwachung:

> What errors occurred in production today?
> Show the stack trace for error ABC123
> Which deployment introduced these errors?

Enterprise-MCP-Konfiguration

Systemadministratoren können MCP-Richtlinien über managed-mcp.json durchsetzen:

{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverName": "sentry" },
    { "serverCommand": ["npx", "-y", "@approved/server"] }
  ],
  "deniedMcpServers": [
    { "serverName": "dangerous-server" }
  ]
}

Speicherort: - macOS: /Library/Application Support/ClaudeCode/managed-mcp.json - Linux: /etc/claude-code/managed-mcp.json - Windows: C:\ProgramData\ClaudeCode\managed-mcp.json

Die Deny-Liste hat absolute Priorität. Befehle müssen exakt übereinstimmen, einschließlich der Argumentreihenfolge.

MCP Apps (Januar 2026)

Anthropic hat MCP Apps eingeführt, eine Erweiterung des Model Context Protocol, die interaktive Tool-UIs direkt in der Claude-Oberfläche ermöglicht.⁷⁸ MCP Apps erlauben es Benutzern, Inhalte externer Dienste anzuzeigen, zu bearbeiten und damit zu interagieren, ohne Claude zu verlassen — darunter Asana, Box, Canva, Figma, Hex, monday.com und Slack. Jeder MCP-Server kann eine interaktive Benutzeroberfläche bereitstellen, die innerhalb von Claude gerendert wird. Während MCP Apps derzeit in der claude.ai-Weboberfläche erscheinen, sind die zugrunde liegenden MCP-Protokollerweiterungen für das MCP-Ökosystem von Claude Code relevant, da Server die neuen interaktiven Funktionen übernehmen.

API-Plattform: Code Execution Tool v2 (Januar 2026)

Anthropic hat v2 des Code Execution Tool in der öffentlichen Beta eingeführt und ersetzt damit die ursprüngliche Python-only Sandbox durch Bash-Befehlsausführung und direkte Dateimanipulation.⁷⁹ Wichtige Änderungen: - Bash-Befehle (nicht nur Python) in isolierten Containern ausführen - Code in beliebigen Programmiersprachen schreiben und ausführen - Programmatischer Tool-Aufruf (ebenfalls öffentliche Beta): Claude kann Tools innerhalb der Codeausführung aufrufen, was Latenz und Token-Verbrauch in Multi-Tool-Workflows reduziert

Das v2-Tool betrifft hauptsächlich API-Benutzer, zeigt aber die Richtung für die Cloud-Ausführungsfunktionen von Claude Code an.

Was sind Subagents?

Subagents sind spezialisierte Claude-Instanzen, die komplexe Aufgaben eigenständig bearbeiten. Sie gehören zu den leistungsfähigsten Funktionen in Claude Code und gleichzeitig zu den am wenigsten verstandenen. Die Beherrschung von Subagents erweitert Ihre Möglichkeiten erheblich. Siehe Entscheidungsrahmen für Orientierung zu Agent Teams vs. Subagents vs. parallelen Sitzungen.

Warum Subagents existieren: Die Hauptkonversation von Claude Code verfügt über ein einzelnes Kontextfenster. Alles, was Sie besprechen, jede Datei, die Claude liest, jede Tool-Ausgabe: All das verbraucht diesen Kontext. In langen Sitzungen füllt sich der Kontext, Claude verliert den Überblick über frühere Entscheidungen und die Leistung nimmt ab. Subagents lösen dieses Problem durch Isolation: Explorationsergebnisse blähen Ihre Hauptkonversation nicht auf, nur die Zusammenfassung wird zurückgegeben. Claude kann außerdem bis zu 10 Subagents parallel ausführen, was gleichzeitige Arbeit ermöglicht, die sequenziell unmöglich wäre.²

Wie Subagents funktionieren

Wenn Claude auf eine Aufgabe stößt, die von fokussierter Bearbeitung profitiert (tiefgehende Exploration, mehrstufige Analyse, spezialisierte Arbeit), kann ein Subagent gestartet werden. Der Subagent:

1. Startet mit einem sauberen Kontext (keine Verunreinigung durch die Hauptkonversation)
2. Hat Zugriff auf festgelegte Tools
3. Arbeitet mit einem bestimmten Modell (oft günstiger/schneller)
4. Gibt die Ergebnisse an die Hauptkonversation zurück

Die Architektur verhindert Kontextüberlauf und ermöglicht gleichzeitig komplexe Workflows.

Integrierte Subagent-Typen

Explore (schnell, nur lesend): - Modell: Haiku (ultraschnell) - Modus: Strikt nur lesend - Tools: Glob, Grep, Read und sichere Bash-Befehle (ls, git status, git log, git diff, find, cat, head, tail) - Gründlichkeitsstufen: Schnell, Mittel, Sehr gründlich - Verwendung für: Codebase-Exploration, Dateien finden, Strukturen verstehen

General-purpose: - Modell: Wird von der Hauptkonversation übernommen - Modus: Vollständiger Lese-/Schreibzugriff - Tools: Alle verfügbaren Tools - Verwendung für: Komplexe Recherche- und Änderungsaufgaben

Plan: - Modell: Wird von der Hauptkonversation übernommen (oder Opus mit opusplan) - Modus: Nur lesend - Tools: Read, Glob, Grep, Bash - Verwendung für: Planung komplexer Implementierungen vor der Ausführung

Subagents auslösen

Claude delegiert automatisch an Subagents basierend auf dem Aufgabentyp. Sie können diese auch explizit anfordern:

> Use the explore agent to find all authentication-related files

> Have a subagent analyze the database schema thoroughly

> Spawn an agent to research how error handling works in this codebase

Expertentipp: Fordern Sie bei komplexen Aufgaben explizit die Delegation an Subagents an. „Use an explore agent to find…” verhindert das Aufblähen des Kontexts in Ihrer Hauptkonversation.

Benutzerdefinierte Subagents erstellen

Definieren Sie Subagents in .claude/agents/ (Projekt) oder ~/.claude/agents/ (persönlich):

---
name: security-reviewer
description: Expert security code reviewer. Use PROACTIVELY after any code changes to authentication, authorization, or data handling.
tools: Read, Grep, Glob, Bash
model: opus
permissionMode: plan
---

You are a senior security engineer reviewing code for vulnerabilities.

When invoked:
1. Identify the files that were recently changed
2. Analyze for OWASP Top 10 vulnerabilities
3. Check for secrets, hardcoded credentials, SQL injection
4. Report findings with severity levels and remediation steps

Focus on actionable security findings, not style issues.

Konfigurationsfelder:

Startbare Subagents einschränken (v2.1.33+, umbenannt v2.1.63): Das Feld tools unterstützt die Agent(agent_type)-Syntax, um einzuschränken, welche Subagent-Typen ein Agent starten kann. Beispielsweise erlaubt tools: Read, Grep, Agent(Explore) dem Agent, Read und Grep direkt zu verwenden, aber nur an Explore-Subagents zu delegieren. Die Einschränkung verhindert übermäßige Delegation in eingeschränkten Agents. Hinweis: In v2.1.63 wurde das Task-Tool in Agent umbenannt. Bestehende Task(...)-Referenzen in Einstellungen und Agent-Definitionen funktionieren weiterhin als abwärtskompatible Aliase.¹¹³

CLI-definierte Subagents (v2.1.32+)

Definieren Sie Subagents als JSON beim Start für schnelle Tests oder Automatisierung. Diese existieren nur für die Sitzung und werden nicht auf der Festplatte gespeichert:⁹⁶

claude --agents '{
  "code-reviewer": {
    "description": "Expert code reviewer. Use proactively after code changes.",
    "prompt": "You are a senior code reviewer. Focus on code quality and security.",
    "tools": ["Read", "Grep", "Glob", "Bash"],
    "model": "sonnet"
  }
}'

Das Flag --agents akzeptiert JSON mit denselben Frontmatter-Feldern wie dateibasierte Subagents: description, prompt, tools, disallowedTools, model, permissionMode, mcpServers, hooks, maxTurns, skills und memory.

Subagents verwalten

> /agents                    # Interaktive Verwaltung
> /agents create             # Neuen Subagent erstellen
> /agents edit               # Bestehenden bearbeiten
> /agents delete             # Subagent entfernen
> /agents list               # Alle anzeigen

CLI-Auflistung (v2.1.50+): Listen Sie alle konfigurierten Agents über die Befehlszeile auf, ohne eine interaktive Sitzung zu starten:

claude agents                # Zeigt Agents gruppiert nach Quelle (integriert, Benutzer, Projekt, Plugin)

Fernsteuerung (v2.1.51+): Der Unterbefehl claude remote-control stellt Ihre lokale Umgebung für externe Builds bereit und ermöglicht allen Benutzern den Fernzugriff auf lokale Umgebungsfähigkeiten:¹⁰⁵

claude remote-control                      # Lokale Umgebung bereitstellen
claude remote-control --name "My Project"  # Benutzerdefinierter Sitzungstitel, sichtbar in claude.ai/code (v2.1.69+)[^117]

Agents im Hintergrund ausführen

Für lang laufende Aufgaben:

> Run a thorough security review in the background

> /agents  # Check status of running agents

Ergebnisse können später mit der Agent-ID abgerufen werden.

Fortgeschrittene Muster

Verkettete Subagents:

> First use the code-analyzer subagent to find performance issues, then use the optimizer subagent to fix them

Parallele Exploration:

> Have three explore agents search in parallel:
> 1. Authentication code
> 2. Database models
> 3. API routes

Fortsetzbare Agents: Agents können mit ihrer ID fortgesetzt werden, um vorherige Arbeit weiterzuführen:

> Resume agent abc123 and continue the analysis

Asynchrone Subagents (Dezember 2025)

Asynchrone Subagents ermöglichen Multitasking und parallele Ausführung für großangelegte Projekte:

> Run security review in the background while I continue frontend work
> /tasks                    # Check status of running agents

Asynchrone Agents geben Ergebnisse über das vereinheitlichte TaskOutputTool zurück und ermöglichen effiziente Pipeline-artige Workflows.

Resilienz bei Berechtigungsverweigerung (v2.1.0+)

Ab v2.1.0 arbeiten Subagents nach Berechtigungsverweigerungen weiter, anstatt komplett zu stoppen. Wenn ein Subagent auf eine Berechtigungsgrenze stößt, versucht er automatisch alternative Ansätze. Diese Änderung macht autonome Workflows robuster und reduziert die Notwendigkeit menschlicher Intervention.⁴⁷

Agent Teams (Februar 2026, Research Preview)

Agent Teams koordinieren mehrere Claude Code-Instanzen, die zusammenarbeiten. Eine Sitzung fungiert als Team Lead, der Teammates startet, die eigenständig in ihren eigenen Kontextfenstern arbeiten und direkt über eine gemeinsame Mailbox und Aufgabenliste miteinander kommunizieren.⁸⁶⁹¹

Im Gegensatz zu Subagents (die innerhalb einer einzelnen Sitzung laufen und nur an den Aufrufer berichten) sind Teammates vollständig unabhängige Sitzungen, die sich gegenseitig Nachrichten senden, Ergebnisse hinterfragen und sich selbst koordinieren können.

Aktivieren:

// settings.json
{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

Oder über die Umgebung: export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

Architektur:

Anzeigemodi:

Konfiguration in den Einstellungen: "teammateMode": "in-process" oder "tmux". Oder pro Sitzung: claude --teammate-mode in-process.

Tastenkombinationen: - Shift+Down: Durch Teammates wechseln (In-Process-Modus; springt nach dem letzten Teammate zum Lead zurück) - Shift+Tab: Delegate-Modus aktivieren (beschränkt den Lead auf reine Koordination, keine Codeänderungen) - Ctrl+T: Gemeinsame Aufgabenliste ein-/ausblenden - Enter auf einem Teammate: Dessen Sitzung anzeigen; Escape um dessen Durchlauf zu unterbrechen

Wann Agent Teams vs. Subagents verwenden:

Beste Anwendungsfälle: - Recherche und Review (mehrere Perspektiven gleichzeitig) - Neue Module/Funktionen (Teammates verantworten jeweils separate Teile) - Debugging mit konkurrierenden Hypothesen (verschiedene Theorien parallel testen) - Schichtübergreifende Koordination (Frontend, Backend, Tests jeweils von verschiedenen Teammates verantwortet)

Planfreigabe für Teammates: Für komplexe oder riskante Aufgaben können Sie verlangen, dass Teammates vor der Implementierung planen. Der Teammate arbeitet im schreibgeschützten Planmodus, bis der Lead seinen Ansatz überprüft und genehmigt hat:

Spawn an architect teammate to refactor the authentication module.
Require plan approval before they make any changes.

Der Lead trifft Genehmigungsentscheidungen autonom. Beeinflussen Sie sein Urteil mit Kriterien: „only approve plans that include test coverage” oder „reject plans that modify the database schema.”

Beispiel-Prompts:

Create an agent team to review PR #142. Spawn three reviewers:
- One focused on security implications
- One checking performance impact
- One validating test coverage

Spawn a team with 4 teammates to refactor these modules in parallel.
Use Sonnet for each teammate.

Speicherung: Team-Konfigurationen befinden sich unter ~/.claude/teams/{team-name}/config.json (Members-Array mit Name, Agent-ID, Agent-Typ). Aufgabenlisten unter ~/.claude/tasks/{team-name}/. Aufgaben unterstützen Abhängigkeiten: Blockierte Aufgaben werden automatisch freigegeben, wenn ihre Abhängigkeiten abgeschlossen sind.⁹¹

Hook-Integration: Verwenden Sie TeammateIdle (Exit-Code 2, um Feedback zu senden und den Teammate weiterarbeiten zu lassen) und TaskCompleted (Exit-Code 2, um den Abschluss zu verhindern) Hooks, um Qualitätsstandards bei Teammates durchzusetzen.

Einschränkungen (experimentell): - Keine Sitzungswiederaufnahme für In-Process-Teammates (/resume stellt sie nicht wieder her) - Ein Team pro Sitzung; keine verschachtelten Teams - Teammates können keine eigenen Teams starten - Split-Panes erfordern tmux oder iTerm2 (nicht unterstützt in VS Code Terminal, Windows Terminal oder Ghostty) - Alle Teammates starten mit dem Berechtigungsmodus des Leads - Token-intensiv: Jeder Teammate ist eine separate Claude-Instanz

Agent Skills (Dezember 2025)

Agent Skills sind organisierte Ordner mit Anweisungen, Skripten und Ressourcen, die Agents dynamisch entdecken und laden.³¹ Sie bieten zusammensetzbare, portable Domänenexpertise:

.claude/skills/
├── security-review/
│   ├── skill.md           # Instructions and prompts
│   ├── checklist.md       # Security checklist
│   └── common-vulns.sh    # Detection scripts
└── performance-audit/
    ├── skill.md
    └── profiling-guide.md

Skills unterscheiden sich von Befehlen: Befehle werden explizit aufgerufen, während Skills sich basierend auf dem Aufgabenkontext automatisch aktivieren. Das Claude Agent SDK (umbenannt von Claude Code SDK) bietet das Framework zum Erstellen benutzerdefinierter Agents mit Skill-Unterstützung.³²

Was ist der erweiterte Denkmodus?

Der erweiterte Denkmodus gibt Claude mehr Zeit, komplexe Probleme durchzudenken, bevor eine Antwort generiert wird. Er ist besonders wertvoll für Architekturentscheidungen, das Debugging schwieriger Probleme und Aufgaben, die eine sorgfältige Analyse erfordern.

Aktueller Stand (März 2026)

Der erweiterte Denkmodus ist jetzt standardmäßig aktiviert mit einem Budget von 31.999 Token.⁷⁰ Anthropic hat diese Änderung vorgenommen, weil der erweiterte Denkmodus die Leistung bei komplexen Planungs- und Denkaufgaben erheblich verbessert.

Aufwandsstufen (v2.1.68+, vereinfacht in v2.1.72): Opus 4.6 verwendet standardmäßig mittleren Aufwand für Max- und Team-Abonnenten – der optimale Kompromiss zwischen Geschwindigkeit und Gründlichkeit. Die Aufwandsstufe wird im Logo und Spinner mit vereinfachten Symbolen angezeigt: ○ (niedrig), ◐ (mittel), ● (hoch).¹²¹ Das Schlüsselwort „ultrathink” wurde wieder eingeführt, um den Modus mit hohem Aufwand auszulösen. Andere natürlichsprachliche Auslöser („think”, „think hard”, „think harder”) bleiben veraltet – verwenden Sie stattdessen MAX_THINKING_TOKENS oder /config.⁷⁰¹¹⁶

Hinweis: Opus 4 und Opus 4.1 wurden aus Claude Code in der Erstanbieter-API entfernt (v2.1.68). Benutzer, die diese Modelle festgelegt hatten, wurden automatisch auf Opus 4.6 migriert.¹¹⁶

Unterstützte Modelle

• Claude Opus 4.6 (unterstützt auch adaptives Denken, das die Denktiefe automatisch bestimmt)
• Claude Sonnet 4.6 (unterstützt ebenfalls adaptives Denken)
• Claude Opus 4.5
• Claude Sonnet 4.5
• Claude Haiku 4.5

Steuerung des erweiterten Denkmodus

Schnelles Umschalten während einer Sitzung:

Press Alt+T to toggle thinking on/off

Hinweis: Anthropic hat den Denkmodus-Umschalter von Tab auf Alt+T geändert, um versehentliches Auslösen zu vermeiden.³⁹

Über /config: Navigieren Sie zu /config → Extended Thinking, um den Modus zu aktivieren/deaktivieren oder das Budget anzupassen.

Umgebungsvariable (dauerhaft):

# Set custom budget (default is 31,999)
export MAX_THINKING_TOKENS=8000
claude

# Double the default for complex tasks
export MAX_THINKING_TOKENS=63999
claude

Deaktivieren zur Kosteneinsparung: Für einfachere Aufgaben, bei denen tiefgreifendes Denken nicht erforderlich ist, können Sie Kosten sparen, indem Sie den Denkmodus in /config deaktivieren oder das Budget reduzieren:

export MAX_THINKING_TOKENS=8000  # Reduce from default 31,999

Denktoken-Budgets

Kostenüberlegung: Anthropic berechnet Denktoken als Ausgabetoken. Das Standardbudget von 31.999 funktioniert für die meisten Aufgaben gut, aber bei einfachen Operationen können Sie Kosten sparen, indem Sie das Budget reduzieren oder den Denkmodus vollständig deaktivieren.

Funktionsweise

Wenn der Denkmodus aktiviert ist, führt Claude interne Überlegungen durch, die die Antwort beeinflussen, aber nicht in der Ausgabe erscheinen. Claude Code verschlüsselt die Überlegungen und gibt sie in einem signature-Feld zur Verifizierung zurück.

In Mehrfachdurchlauf-Konversationen mit Werkzeugnutzung müssen Denkblöcke an die API zurückgegeben werden, um die Kontinuität der Überlegungen zu bewahren. Claude Code handhabt dies automatisch.

Wann Sie eine Reduzierung/Deaktivierung in Betracht ziehen sollten

Der erweiterte Denkmodus ist jetzt der Standard, aber ziehen Sie eine Reduzierung des Budgets oder eine Deaktivierung in Betracht bei: - Einfachen Dateibearbeitungen - Routinemäßigem Refactoring - Schnellen Fragen - Code-Formatierung - Operationen mit hohem Volumen, bei denen sich die Kosten summieren

Cache-Verhalten

Claude Code bewahrt das Caching des System-Prompts, wenn sich die Denkparameter ändern. Das Ändern des Denkbudgets oder des Aktivierungsstatus zwischen Durchläufen macht das Nachrichten-Caching ungültig.

Ausgabestile

Ausgabestile passen an, wie Claude Informationen präsentiert. Dies ist nützlich für Lernen, Dokumentation oder spezifische Teampräferenzen.¹⁹

Integrierte Stile

Ausgabestil festlegen

> /output-style Explanatory
> /output-style Learning

Oder über die Einstellungen:

{
  "outputStyle": "Explanatory"
}

Benutzerdefinierte Ausgabestile

Erstellen Sie diese in .claude/styles/:

# my-style

## Instructions
- Always explain the WHY behind each decision
- Include relevant documentation links
- Format code examples with comments
- End with a "What to do next" section

## Format
Use markdown headers for organization.
Keep explanations under 200 words per section.

Aufrufen mit /output-style my-style.

Veraltet (v2.1.73+): /output-style ist veraltet. Verwenden Sie stattdessen /config, um Ausgabestile zu verwalten.¹²²

Slash Commands

Slash Commands bieten schnellen Zugriff auf Funktionen von Claude Code und ermöglichen benutzerdefinierte Workflows. Sie sind schneller als das Ausschreiben vollständiger Prompts für häufige Operationen.

Referenz der integrierten Befehle

Eigene Befehle erstellen

Erstellen Sie wiederverwendbare Befehle in .claude/commands/ (Projekt) oder ~/.claude/commands/ (persönlich):

---
description: Security-focused code review
allowed-tools: Read, Grep, Glob
model: claude-sonnet-4-5
---

Review this code for security vulnerabilities:

1. Injection attacks (SQL, command, XSS)
2. Authentication and authorization flaws
3. Sensitive data exposure
4. Insecure dependencies

Focus on actionable findings with specific line references.

Speichern Sie die Datei als .claude/commands/security-review.md und rufen Sie sie mit /security-review auf.

Frontmatter-Optionen für Befehle

---
description: Brief description for /help
allowed-tools: Read, Edit, Bash(npm:*)
model: opus
argument-hint: [arg1] [arg2]
disable-model-invocation: false
---

Argument-Interpolation

Alle Argumente als einzelner String:

---
description: Fix GitHub issue
argument-hint: [issue-number]
---

Fix GitHub issue #$ARGUMENTS following our coding standards.

Verwendung: /fix-issue 123

Nummerierte Argumente:

---
description: Create component
argument-hint: [name] [type]
---

Create a new $2 component named $1 in src/components/.

Verwendung: /create-component Button functional

Inline-Bash-Ausführung

Führen Sie Bash-Befehle innerhalb von Befehlsprompts aus:

---
description: Git status summary
allowed-tools: Bash(git:*)
---

Current branch: !`git branch --show-current`
Recent commits: !`git log --oneline -5`
Changed files: !`git status --short`

Summarize the current state of this repository.

Dateireferenzen

Binden Sie Dateiinhalte in Befehle ein:

---
description: Compare implementations
---

Compare these files:
@src/v1/handler.ts
@src/v2/handler.ts

Which implementation is more maintainable?

Befehlsnamensräume

Organisieren Sie Befehle in Unterverzeichnissen:

.claude/commands/
├── backend/
│   ├── test.md
│   └── deploy.md
├── frontend/
│   ├── test.md
│   └── build.md
└── review.md

Befehle mit gleichem Namen zeigen ihren Namensraum in der Hilfe an: /test (project:backend) vs /test (project:frontend).

Wie funktionieren Skills?

Skills stellen einen grundlegend anderen Ansatz zur Erweiterung von Claude Code dar. Im Gegensatz zu Slash-Befehlen, die Sie explizit aufrufen, werden Skills vom Modell aufgerufen – Claude entdeckt und verwendet sie automatisch basierend auf dem Kontext. Sie betten Domänenexpertise in einen Skill ein, und Claude greift auf diese Expertise zurück, wann immer die Situation es erfordert, ohne dass Sie daran denken müssen, danach zu fragen.

Warum Skills alles verändern: Denken Sie an Domänenexpertise: die Regeln zur Zahlungsabwicklung, die Compliance-Anforderungen, die Architekturmuster, die Ihr Team über Jahre hinweg verfeinert hat. Ohne Skills erklären Sie diesen Kontext entweder in jeder Sitzung neu oder hoffen, dass Claude ihn aus Code-Kommentaren ableitet. Mit Skills codieren Sie ihn einmal. Claude liest die Skill-Definition und wendet diese Expertise automatisch an, wann immer sie relevant ist. Ihre Junior-Entwickler erhalten Anleitung auf Senior-Niveau, ohne danach fragen zu müssen. Ihre Sicherheitsmuster werden durchgesetzt, ohne dass man sich daran erinnern muss, sie aufzurufen.

Der Unterschied ist entscheidend. Ein Slash-Befehl ist eine Abkürzung, an deren Verwendung Sie sich erinnern. Ein Skill ist Wissen, das Claude immer zur Verfügung hat. Wenn Sie einen Skill zur Sicherheitsüberprüfung mit den spezifischen Schwachstellenmustern und Compliance-Anforderungen Ihres Teams erstellen, wendet Claude diese Expertise automatisch an, wann immer relevanter Code auftaucht – ob bei PR-Reviews, Refactoring oder jeder anderen Aufgabe, bei der Sicherheit eine Rolle spielt. Sie rufen nicht /security-review auf; Claude erkennt den Kontext und wendet den Skill automatisch an.

Skills vs. Befehle vs. Subagents

Wenn Sie verstehen, wann Sie welchen Erweiterungsmechanismus verwenden sollten, vermeiden Sie Duplikate und maximieren die Effektivität:

Verwenden Sie Slash-Befehle, wenn Sie explizite Kontrolle wünschen: /deploy, /test, /review PR 456. Sie entscheiden, wann sie ausgeführt werden.

Verwenden Sie Skills, wenn Expertise automatisch aktiviert werden soll: Sicherheitsmuster, Code-Stil-Durchsetzung, domänenspezifisches Wissen. Claude entscheidet, wann sie angewendet werden.

Verwenden Sie Subagents, wenn Aufgaben Isolation benötigen: Hintergrundexploration, parallele Analyse, spezialisiertes Reasoning, das Ihre Hauptkonversation nicht belasten sollte.

Skill-Struktur und Speicherort

Skills befinden sich in dedizierten Verzeichnissen, die eine erforderliche SKILL.md-Datei sowie optionale unterstützende Ressourcen enthalten:

Persönliche Skills (in allen Ihren Projekten verfügbar):

~/.claude/skills/
├── code-reviewer/
│   ├── SKILL.md
│   ├── SECURITY_PATTERNS.md
│   └── PERFORMANCE_CHECKLIST.md
├── sql-analyst/
│   ├── SKILL.md
│   └── QUERY_PATTERNS.md
└── api-designer/
    └── SKILL.md

Projekt-Skills (mit dem Team über Git geteilt):

.claude/skills/
├── domain-expert/
│   ├── SKILL.md
│   ├── BUSINESS_RULES.md
│   └── DATA_MODELS.md
└── deployment/
    ├── SKILL.md
    └── RUNBOOKS.md

Projekt-Skills werden in die Versionskontrolle eingecheckt. Wenn Teammitglieder pullen, erhalten sie Ihre Skills automatisch – keine Installation, keine Konfiguration. Die automatische Verteilung standardisiert die Expertise im gesamten Team.

SKILL.md-Format

Jeder Skill erfordert eine SKILL.md-Datei mit YAML-Frontmatter:

---
name: code-reviewer
description: Review code for security vulnerabilities, performance issues, and best practice violations. Use when examining code changes, reviewing PRs, analyzing code quality, or when asked to review or audit code.
allowed-tools: Read, Grep, Glob
---

# Code Review Expertise

## Security Analysis

When reviewing code, check for:

### Input Validation
- All user input sanitized before use
- Parameterized queries for database operations
- Output encoding for rendered content

### Authentication & Authorization
- Session tokens properly validated
- Permission checks before sensitive operations
- No hardcoded credentials or API keys

### Data Exposure
- Sensitive data not logged
- PII properly masked in error messages
- API responses don't leak internal details

## Performance Patterns

### Database
- N+1 query detection
- Missing indexes on filtered columns
- Unbounded result sets

### Memory
- Large object lifecycle management
- Stream processing for big files
- Connection pool exhaustion risks

## Review Output Format

For each finding:
- **File**: path/to/file.ts:123
- **Severity**: Critical | High | Medium | Low
- **Category**: Security | Performance | Maintainability
- **Issue**: Clear description of the problem
- **Recommendation**: Specific fix with code example
- **Rationale**: Why this matters

See [SECURITY_PATTERNS.md](SECURITY_PATTERNS.md) for detailed vulnerability patterns.
See [PERFORMANCE_CHECKLIST.md](PERFORMANCE_CHECKLIST.md) for optimization guidelines.

Frontmatter-Referenz

String-Substitutionen (v2.1.9+): Skills können auf den Sitzungskontext über die ${CLAUDE_SESSION_ID}-Substitution zugreifen. Nützlich für Logging, Tracking oder die Erzeugung sitzungsspezifischer Ausgaben.⁵¹

Das description-Feld ist entscheidend. Claude entdeckt Skills, indem es Ihre Anfragen mit Skill-Beschreibungen abgleicht. Eine vage Beschreibung bedeutet, dass Claude nicht erkennt, wann der Skill verwendet werden soll. Eine spezifische Beschreibung mit klaren Auslösebedingungen bedeutet zuverlässige Aktivierung.

Schlechte Beschreibung:

description: Helps with code

Effektive Beschreibung:

description: Review code for security vulnerabilities, performance issues, and best practice violations. Use when examining code changes, reviewing PRs, analyzing code quality, or when asked to review, audit, or check code.

Die effektive Beschreibung enthält: - Was der Skill tut (Code auf bestimmte Probleme prüfen) - Wann er verwendet werden soll (Änderungen untersuchen, PRs, Qualitätsanalyse) - Auslösephrasen (review, audit, check)

Tool-Einschränkungen

Das allowed-tools-Feld begrenzt, was Claude tun kann, wenn ein Skill aktiv ist. Tool-Einschränkungen sind essenziell für schreibgeschützte oder im Umfang begrenzte Skills:

---
name: security-auditor
description: Audit code for security vulnerabilities without making changes
allowed-tools: Read, Grep, Glob
---

Mit dieser Konfiguration kann Claude Code analysieren, aber keine Dateien bearbeiten, keine Bash-Befehle ausführen oder Änderungen vornehmen. Der Skill erzwingt schreibgeschütztes Verhalten.

Gängige Einschränkungsmuster:

Unterstützende Dateien

Skills können mehrere Dateien enthalten. Claude liest die Haupt-SKILL.md bei der Aktivierung und greift dann bei Bedarf auf unterstützende Dateien zu – eine progressive Offenlegung, die den Kontext effizient verwaltet.

Strukturmuster:

my-skill/
├── SKILL.md           # Required: overview + quick reference
├── DETAILED_GUIDE.md  # Deep documentation
├── EXAMPLES.md        # Concrete examples
├── PATTERNS.md        # Reference patterns
├── templates/         # Reusable templates
│   └── component.tsx
└── scripts/           # Helper utilities
    └── validate.py

Unterstützende Dateien aus SKILL.md referenzieren:

For detailed security patterns, see [SECURITY_PATTERNS.md](SECURITY_PATTERNS.md).

Use this template for new components:
@templates/component.tsx

Validate configurations with:
```bash
python scripts/validate.py config.json

**Expertentipp:** Platzieren Sie wesentliche Informationen direkt in SKILL.md. Reservieren Sie unterstützende Dateien für tiefergehende Referenzmaterialien. Claude liest SKILL.md sofort, greift aber nur bei Bedarf auf unterstützende Dateien zu. Wenn kritische Informationen in einer unterstützenden Datei verborgen sind, findet Claude sie möglicherweise nicht.

### Vollständiges Beispiel: Domain-Expert-Skill

Hier ist ein produktionsreifer Skill für eine Fintech-Anwendung:

**Verzeichnisstruktur:**

.claude/skills/payments-domain/ ├── SKILL.md ├── BUSINESS_RULES.md ├── COMPLIANCE.md └── DATA_MODELS.md

**SKILL.md:**
```markdown
---
name: payments-domain
description: Expert knowledge of payment processing domain including transaction flows, compliance requirements, and business rules. Use when working with payment code, transaction handling, refunds, disputes, or financial calculations.
---

# Payments Domain Expertise

## Kernkonzepte

### Transaktionszustände

PENDING → AUTHORIZED → CAPTURED → SETTLED ↘ VOIDED AUTHORIZED → DECLINED CAPTURED → REFUNDED (partial or full) SETTLED → CHARGEBACK → REPRESENTED

### Regeln für den Umgang mit Geldbeträgen
- ALLE Geldbeträge werden als Ganzzahlen gespeichert (Cent, nicht Dollar)
- Währung wird immer explizit erfasst (niemals USD annehmen)
- Rundung: HALF_EVEN für Berechnungen, HALF_UP für die Anzeige
- Niemals Gleitkommazahlen für Geldbeträge verwenden

### Idempotenz-Anforderungen
Jede Zahlungsoperation MUSS idempotent sein:
```typescript
// Required pattern
async function processPayment(idempotencyKey: string, amount: number) {
  const existing = await findByIdempotencyKey(idempotencyKey);
  if (existing) return existing; // Return cached result

  const result = await executePayment(amount);
  await storeWithIdempotencyKey(idempotencyKey, result);
  return result;
}