Claude Code CLI Leitfaden: Installation, Konfiguration, Befehle, Umgebungsvariablen

Kurzfassung: Claude Code ist ein agentisches CLI, das Ihre Codebasis liest, Befehle ausführt und Dateien über ein mehrstufiges 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 ein Produktivitäts-Vielfaches. Wählen Sie die Modellstufe, die zur jeweiligen Aufgabe passt — Opus für komplexes Reasoning, 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 Programmierwissen. 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 nahtlos in den tatsächlichen Arbeitsablauf von Entwicklern einfügt. Stand Februar 2026 werden 4 % der öffentlichen GitHub-Commits (~135.000 pro Tag) von Claude Code verfasst — ein Wachstum um den Faktor 42.896 in 13 Monaten seit der Research Preview — und 90 % des eigenen Codes von Anthropic sind KI-generiert.¹¹⁰

Der Unterschied zwischen beiläufiger und effektiver Claude Code-Nutzung liegt in fünf Kernsystemen. Beherrschen Sie diese, wird Claude Code zum Produktivitäts-Multiplikator:

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

Zentrale Erkenntnisse

• Fünf Systeme bestimmen Ihre Effektivität: Konfigurationshierarchie, Berechtigungen, Hooks, MCP und Subagents steuern alles — vom Verhalten bis zur Automatisierung.
• Verlagern Sie Arbeit in die Delegationsschicht: Subagents verhindern Kontext-Aufblähung, 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 bei jedem Durchlauf unabhängig vom Modellverhalten ausgeführt werden müssen.
• Modell-Staffelung spart Kosten ohne Qualitätseinbußen: Leiten Sie Subagent-Exploration an günstigere Modelle weiter und reservieren Sie Opus für echtes architektonisches Reasoning — 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 bloße Lesen von Dateien und Bash-Befehle hinaus.

Ich habe monatelang Claude Code an seine Grenzen gebracht — in Produktions-Codebasen, CI/CD-Pipelines und Enterprise-Deployments. Dieser Leitfaden destilliert diese Erfahrung in die vollständige Referenz, die ich mir zu Beginn gewünscht hätte. Jede Funktion enthält tatsächliche Syntax, echte Konfigurationsbeispiele und die Grenzfälle, an denen selbst erfahrene Benutzer scheitern.

Wählen Sie Ihren Einstieg

So verwenden Sie diesen Leitfaden

Dies ist eine Referenz mit über 5.000 Zeilen — Sie müssen sie nicht von Anfang bis Ende lesen. Steigen Sie dort ein, wo es zu Ihrem Erfahrungsstand passt:

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

Weiterführende Vertiefungen

Diese Blogbeiträge beleuchten einzelne Aspekte von Claude Code im Detail:

60-Sekunden-Schnellstart

Wenn Sie einfach nur Claude Code ausführen und die Ausgabe sehen möchten, gehen Sie in dieser Reihenfolge vor:

# 1. Install (pick one)
npm install -g @anthropic-ai/claude-code          # npm users
brew install anthropic/claude/claude              # macOS + Homebrew
curl -sL claude.ai/install.sh | sh                # native installer

# 2. Launch in any project directory
cd ~/your-project && claude

# 3. Authenticate (browser opens automatically on first run)
/login

# 4. Ask your first question
> What does this repo do? Read the key files and summarize.

Das war’s. Alles unterhalb dieses Abschnitts erläutert die Installationsoptionen im Detail, konfiguriert Berechtigungen und Hooks, bindet MCP-Server an und behandelt die Enterprise-Bereitstellung – aber nichts davon ist für den Einstieg erforderlich.

Voraussetzungen: Node 18+ (für den npm-Pfad), macOS / Linux / Windows 10+. Ein Claude Pro-, Max-, Team- oder Enterprise-Abonnement oder ein nutzungsabhängiger Anthropic API-Key deckt die Nutzung ab. Siehe Wie installiere ich Claude Code? für Plattform-Details, Fehlerbehebung und den nativen Binary-Pfad (Standard seit v2.1.113).

Wie Claude Code funktioniert: Das mentale Modell

Bevor Sie in die Funktionen eintauchen, sollten Sie verstehen, wie die Architektur von Claude Code alles prägt, 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 │
└─────────────────────────────────────────────────────────┘

Core Layer: Ihre Hauptkonversation. Jede Nachricht, jeder Dateizugriff und jede Tool-Ausgabe verbraucht Kontext aus einem gemeinsamen Fenster (200K Tokens im Standard⁹⁸, 1M Tokens mit Opus 4.6 oder Modellen mit erweitertem Kontext). Wenn der Kontext sich füllt, verliert Claude frühere Entscheidungen aus den Augen und die Qualität lässt nach. Diese Schicht kostet Geld pro Token.

Delegation Layer: Subagents starten mit sauberen Kontexten, erledigen fokussierte Arbeit und liefern Zusammenfassungen zurück. Die Ergebnisse der Erkundung blähen Ihre Hauptkonversation nicht auf; nur die Schlussfolgerungen kommen zurück. Leiten Sie Subagents zur Erkundung an günstigere Modellstufen weiter, oder nutzen Sie durchgehend Ihr primäres Modell, wenn Qualität wichtiger ist als Kosten.

Extension Layer: 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 für die Verteilung.

Die zentrale Erkenntnis: Die meisten Benutzer arbeiten ausschließlich im Core Layer und sehen dabei zu, wie Kontext und Kosten steigen. Power-User verlagern Erkundung und Spezialarbeit in den Delegation Layer, halten den Extension Layer für ihren Workflow konfiguriert und nutzen den Core Layer nur für Orchestrierung und finale Entscheidungen.

Inhaltsverzeichnis

1. Wie installiere ich Claude Code?
2. Schnellstart: Ihre erste Sitzung
3. Kern-Interaktionsmodi
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 Extended-Thinking-Modus?
13. Ausgabestile
14. Slash-Befehle
15. Wie funktionieren Skills?
16. Plugin-System
17. Wie funktioniert der Speicher?
18. Bild- und multimodale Eingabe
19. Sprachmodus
20. Wie funktioniert die Git-Integration?
21. Wie nutze ich Claude Code in meiner IDE?
22. Fortgeschrittene Nutzungsmuster
23. Remote- & Background-Agents [RESEARCH PREVIEW]
24. Claude in Chrome
25. Claude Code in Slack [RESEARCH PREVIEW]
26. Claude Code im Web [RESEARCH PREVIEW]
27. Performance-Optimierung
28. Wie debugge ich Probleme?
29. Enterprise-Bereitstellung
30. Tastenkürzel-Referenz
31. Best Practices
32. Workflow-Rezepte
33. Migrationsleitfaden
34. Zielgruppenspezifische Hinweise
35. Schnellreferenz-Karte
36. Changelog
37. Referenzen

Wie installiere ich Claude Code?

Systemanforderungen

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

Für Windows funktionieren sowohl WSL 1 als auch WSL 2. Git Bash funktioniert ebenfalls, falls 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

Plattform-Support-Matrix

Installation, Update, Deinstallation auf einen Blick

Scanbare Übersicht — jede Methode, jeder Befehl, Versionsprüfung auf einem Bildschirm. Die folgenden Unterabschnitte behandeln methodenspezifische Details und Fehlerbehebung.

Seit v2.1.113 spawnt das kanonische CLI ein natives Claude Code-Binary über eine plattformspezifische optionale Abhängigkeit anstelle des gebündelten JavaScript — verwenden Sie den nativen Installer für die getestete Distribution. Der npm-Pfad funktioniert weiterhin, erhält jedoch zuerst den Veraltungshinweis, der ursprünglich in v2.1.15 hinzugefügt wurde.

Installationsmethoden

Native Installation (empfohlen)

Das native Binary 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 Veraltungshinweis an. Das native Binary ist nun die empfohlene Installationsmethode. Migrieren Sie mit claude install.

Für Legacy-Umgebungen, in denen npm noch benötigt wird:

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

Verwenden Sie niemals sudo mit der npm-Installation. Dies erzeugt Berechtigungsprobleme, die alles Nachgelagerte verkomplizieren.

Migration von einer bestehenden Installation

Falls Sie eine ältere npm-basierte Installation haben, migrieren Sie zum nativen Binary:

claude install

Authentifizierungsoptionen

Claude Code unterstützt drei Authentifizierungspfade, jeder mit unterschiedlichen Kompromissen:

Claude Console (API-Abrechnung)

Verbinden Sie sich direkt mit Anthropics API über platform.claude.com (zuvor console.anthropic.com). Erstellen Sie ein Konto, richten Sie die Abrechnung ein und authentifizieren Sie sich über das CLI. Die Console bietet nutzungsbasierte Abrechnung mit vollständigem API-Zugriff. Ein dediziertes „Claude Code”-Workspace wird automatisch erstellt; Sie können keine API-Schlüssel für dieses Workspace erstellen, aber Sie können die Nutzung überwachen.

Claude Pro- oder Max-Abonnement

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

Enterprise-Plattformen

AWS Bedrock, Google Vertex AI und Microsoft Foundry bieten jeweils Enterprise-Zugriff mit bestehenden Cloud-Abrechnungsbeziehungen. Bedrock-Setup-Assistent (v2.1.92+): Ein interaktiver Assistent auf dem Anmeldebildschirm führt Sie durch die AWS-Authentifizierung, Regionsauswahl, Anmeldedatenüberprüfung und Modellfixierung.¹⁴⁴ Vertex AI-Setup-Assistent (v2.1.98+): Ein passender Assistent für Google Cloud, der durch GCP-Authentifizierung, Projekt- und Regionskonfiguration, Anmeldedatenüberprüfung und Modellfixierung führt.¹⁴⁹ Vertex AI mTLS Workload Identity Federation (v2.1.121+): Vertex AI akzeptiert nun X.509-zertifikatbasierte Workload Identity Federation (mTLS Application Default Credentials) — kurzlebige GCP-Tokens, die aus einem Client-Zertifikat erzeugt werden, ohne dass ein Dienstkonto-JSON erforderlich ist.¹⁶¹ OS-CA-Zertifikatsvertrauen (v2.1.101+): Enterprise-TLS-Proxys funktionieren nun standardmäßig — Claude Code vertraut dem Zertifikatspeicher des Betriebssystems. Setzen Sie CLAUDE_CODE_CERT_STORE=bundled, um nur gebündelte CAs zu verwenden.¹⁵⁰

# 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

# Amazon Bedrock via Mantle (v2.1.94+)
export CLAUDE_CODE_USE_MANTLE=1

Für Enterprise-Deployments 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 alle erkannten 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

Üblicher Workflow zum Wechseln zwischen Konten oder Organisationen:

claude auth logout && claude auth login

Siehe auch: Wie debugge ich Probleme? zur Fehlerbehebung bei Authentifizierungsfehlern.

Updates

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

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

Saubere Konfiguration (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 um etwas bitten:

> "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 fortsetzen:

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

Experten-Tipp: Erstellen Sie eine CLAUDE.md-Datei im Stammverzeichnis Ihres Projekts mit Build-Befehlen, Coding-Konventionen und Architekturhinweisen. Claude liest sie in jeder Sitzung – das ist die wirkungsvollste einzelne Maßnahme für Qualität.

Kerninteraktionsmodi

Interaktiver REPL

Starten Sie Claude Code ohne Argumente, um in den interaktiven Read-Eval-Print-Loop zu wechseln:

cd your-project
claude

Der REPL behält den Konversationskontext über mehrere Runden 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"

Experten-Tipp: Der REPL behält den Zustand über Compaction-Ereignisse hinweg bei. Wenn der Kontext zu groß wird, fasst Claude ältere Konversationen automatisch zusammen und bewahrt dabei wichtige Entscheidungen und Code-Snippets. 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 Ausgabeformate:

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

# Bare mode: skip hooks, LSP, plugin sync, skill walks (v2.1.81+)
claude -p "count files" --bare

# Channel permission relay: send approval prompts to Telegram/Discord (v2.1.81+)
claude --channels

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 Konversationsverlauf zur Fortsetzung. Die Sitzungspersistenz ist für komplexe sitzungsübergreifende Arbeiten 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+, erweitert in v2.1.119+): Starten Sie eine Sitzung, die mit einem bestimmten Pull- oder Merge-Request verknüpft ist. Ab v2.1.119 akzeptiert --from-pr zusätzlich zu github.com auch GitLab-MR-, Bitbucket-PR- und GitHub Enterprise-PR-URLs:⁸¹¹⁵⁹

claude --from-pr 123                                                # GitHub PR number (assumes current repo's remote)
claude --from-pr https://github.com/org/repo/pull/123               # GitHub URL
claude --from-pr https://gitlab.com/org/repo/-/merge_requests/45    # GitLab MR (v2.1.119+)
claude --from-pr https://bitbucket.org/org/repo/pull-requests/67    # Bitbucket PR (v2.1.119+)
claude --from-pr https://ghe.example.com/org/repo/pull/89           # GitHub Enterprise (v2.1.119+)

Sitzungen werden außerdem automatisch mit PRs verknüpft, wenn Sie diese während einer Sitzung über gh pr create erstellen. Dadurch lässt sich die Arbeit an einem bestimmten PR später leicht fortsetzen. Das Footer-PR-Badge kann über die Einstellung prUrlTemplate (v2.1.119+) auf eine benutzerdefinierte Code-Review-URL verweisen – nützlich, wenn Ihr Team von PRs auf ein separates Review-Tool verlinkt.¹⁵⁹

/resume akzeptiert PR-URLs (v2.1.122+). Wenn Sie eine PR-URL in das Suchfeld von /resume einfügen, wird nun die Sitzung gefunden, die diesen PR ursprünglich erstellt hat – funktioniert mit github.com, GitHub Enterprise, gitlab.com (auch selbst gehostetes GitLab) und bitbucket.org.¹⁶¹

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. Die Agent-Ausführung weist eindeutige agentId-Werte zu, wobei die Transkripte als agent-{agentId}.jsonl gespeichert werden. Beim Fortsetzen bleibt der vollständige Kontext aus früheren Konversationen erhalten.

Plan-Modus

Der Plan-Modus beschränkt Claude auf eine reine Lese-Erkundung – keine Dateibearbeitungen, keine Bash-Ausführung, keine destruktiven Aktionen. Claude entwirft einen Implementierungsansatz, schreibt ihn in eine Plandatei und wartet auf Ihre Freigabe, 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

So funktioniert es:

1. Claude wechselt in den Plan-Modus (automatisch bei komplexen Aufgaben oder über Shift+Tab)
2. Erkundet die Codebasis mit reinen Lese-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 legt Ihnen den Plan zur Überprüfung vor
5. Sie genehmigen, fordern Änderungen an oder lehnen ab

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

Nach Plan-Genehmigung (v2.1.32+): Claude bietet drei Optionen: - „Ja, Kontext leeren und Bearbeitungen automatisch akzeptieren” (Shift+Tab) – startet mit frischem, vollständigem 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 einzelne Bearbeitungsfreigabe aus

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

Wann der Plan-Modus zu verwenden ist: - Neue Feature-Implementierungen mit architektonischen Entscheidungen - Refaktorierungen über mehrere Dateien hinweg, bei denen Sie den Ansatz zuerst überprüfen möchten - Unbekannte Codebasen, in denen die Erkundung der Modifikation vorausgehen sollte - Jede Aufgabe, bei der mehrere gültige Ansätze existieren und Sie Mitsprache wünschen

Experten-Tipp: Je mehr Zeit Sie im Plan-Modus verbringen, desto wahrscheinlicher gelingt Claude die Implementierung. Der Plan-Modus ist faktisch kostenfreie Erkundung – 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 entscheidend, da höhere Ebenen die niedrigeren überschreiben und Enterprise-Einstellungen überhaupt nicht umgangen werden können.

Konfigurationshierarchie

Experten-Tipp: Verwenden Sie .claude/settings.local.json für persönliche Einstellungen in geteilten Projekten (fügen Sie es zu .gitignore hinzu). Nutzen Sie .claude/settings.json für teamweite Konfigurationen, die in die Versionskontrolle eingecheckt werden.

Vollständige settings.json-Referenz

Eine umfassende 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-...                    # Direkte API-Authentifizierung
ANTHROPIC_AUTH_TOKEN=token                      # Benutzerdefinierter Authorization-Header
ANTHROPIC_CUSTOM_HEADERS="X-Key: val"           # Zusätzliche Anfrage-Header

Modell-Konfiguration:

ANTHROPIC_MODEL=claude-opus-4-7                 # Standardmodell überschreiben (16. Apr. 2026)
ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-7    # Opus 4.7 (Standard für Max/Team Premium)
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-6
ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5-20251001
CLAUDE_CODE_SUBAGENT_MODEL=sonnet               # Modell für subagents
MAX_THINKING_TOKENS=10000                       # (Nur Opus 4.6 und Sonnet 4.6 — entfernt in Opus 4.7)
CLAUDE_CODE_MAX_OUTPUT_TOKENS=4000              # Ausgabelänge begrenzen
CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1          # Agent-Teams aktivieren (v2.1.32+)

Cloud-Provider-Konfiguration:

CLAUDE_CODE_USE_BEDROCK=1                       # AWS Bedrock verwenden
CLAUDE_CODE_USE_VERTEX=1                        # Google Vertex AI verwenden
CLAUDE_CODE_USE_FOUNDRY=1                       # Microsoft Foundry verwenden
ANTHROPIC_BEDROCK_BASE_URL=https://...          # Benutzerdefinierter Bedrock-Endpunkt
ANTHROPIC_BEDROCK_SERVICE_TIER=priority         # Bedrock-Service-Tier (v2.1.122+): 'default', 'flex' oder 'priority'; wird als X-Amzn-Bedrock-Service-Tier-Header gesendet[^162]
CLAUDE_CODE_SKIP_BEDROCK_AUTH=1                 # Bedrock-Auth überspringen (für Gateways)
CLAUDE_CODE_SKIP_VERTEX_AUTH=1                  # Vertex-Auth überspringen
AWS_BEARER_TOKEN_BEDROCK=token                  # Bedrock-Bearer-Token
VERTEX_REGION_CLAUDE_3_7_SONNET=us-west1        # Vertex-Region überschreiben

Verhaltenssteuerung:

DISABLE_AUTOUPDATER=1                           # Automatische Hintergrund-Updates verhindern
DISABLE_UPDATES=1                               # ALLE Update-Pfade einschließlich manuellem `claude update` blockieren (v2.1.118+, strenger als DISABLE_AUTOUPDATER)[^160]
DISABLE_TELEMETRY=1                             # Nutzungstelemetrie deaktivieren
DISABLE_ERROR_REPORTING=1                       # Sentry deaktivieren
DISABLE_BUG_COMMAND=1                           # /bug-Befehl deaktivieren
DISABLE_COST_WARNINGS=1                         # Kostenwarnungen ausblenden
DISABLE_PROMPT_CACHING=1                        # Prompt-Caching global deaktivieren
DISABLE_PROMPT_CACHING_SONNET=1                 # Nur für Sonnet deaktivieren
DISABLE_PROMPT_CACHING_OPUS=1                   # Nur für Opus deaktivieren
DISABLE_NON_ESSENTIAL_MODEL_CALLS=1             # Nicht-kritische API-Aufrufe überspringen
ENABLE_PROMPT_CACHING_1H=1                      # 1-Stunden-Prompt-Cache-TTL aktivieren (v2.1.108+, API/Bedrock/Vertex/Foundry)
ENABLE_PROMPT_CACHING_1H_BEDROCK=1              # Veralteter Alias für die obige Variable; v2.1.108+ akzeptiert sie weiterhin auf Bedrock, gibt aber einen Veralterungshinweis aus
FORCE_PROMPT_CACHING_5M=1                       # 5-Minuten-Cache-TTL erzwingen (v2.1.108+)
ENABLE_TOOL_SEARCH=true                         # Tool-Suche auf Vertex AI wieder aktivieren (standardmäßig deaktiviert ab v2.1.119+, um nicht unterstützten Beta-Header zu vermeiden). Gültige Werte: true, false, auto, auto:N[^160]
CLAUDE_CODE_HIDE_CWD=1                          # Arbeitsverzeichnis im Start-Logo ausblenden (v2.1.119+)[^160]
CLAUDE_CODE_FORK_SUBAGENT=1                     # Geforkte subagents auf externen Builds aktivieren (v2.1.117+)[^160]

Tool-Konfiguration:

BASH_DEFAULT_TIMEOUT_MS=30000                   # Bash-Befehls-Timeout (30s)
BASH_MAX_TIMEOUT_MS=600000                      # Maximales Bash-Timeout (10 Min.)
BASH_MAX_OUTPUT_LENGTH=50000                    # Bash-Ausgabelimit
CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1     # CWD nach jedem Bash zurücksetzen
MCP_TIMEOUT=5000                                # MCP-Server-Startup-Timeout
MCP_TOOL_TIMEOUT=30000                          # MCP-Tool-Ausführungs-Timeout
MAX_MCP_OUTPUT_TOKENS=25000                     # MCP-Ausgabelimit
SLASH_COMMAND_TOOL_CHAR_BUDGET=15000            # Kontextlimit für Slash-Befehle

Netzwerk und Proxy:

HTTP_PROXY=http://proxy:8080                    # HTTP-Proxy
HTTPS_PROXY=https://proxy:8080                  # HTTPS-Proxy
NO_PROXY=localhost,example.com                  # Proxy für Domains umgehen
CLAUDE_CODE_CLIENT_CERT=/path/to/cert           # mTLS-Zertifikat
CLAUDE_CODE_CLIENT_KEY=/path/to/key             # Privater mTLS-Schlüssel
CLAUDE_CODE_CLIENT_KEY_PASSPHRASE=pass          # mTLS-Passphrase

UI und Terminal:

CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1            # Terminaltitel nicht aktualisieren
CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL=1             # IDE-Erweiterungsinstallation überspringen
CLAUDE_CODE_SHELL=/bin/zsh                      # Shell-Erkennung überschreiben
USE_BUILTIN_RIPGREP=1                           # Mitgeliefertes ripgrep verwenden (Standard)
CLAUDE_CONFIG_DIR=~/.myconfig                   # Benutzerdefiniertes Konfigurationsverzeichnis
IS_DEMO=1                                       # Sensible UI-Elemente ausblenden[^37]
CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1          # Hintergrundaufgaben und Strg+B deaktivieren[^46]
CLAUDE_CODE_TMPDIR=/path/to/tmp                 # Temp-Verzeichnis überschreiben[^50]
CLAUDE_CODE_DISABLE_1M_CONTEXT=1               # 1M-Kontextfenster deaktivieren (Standard 200K verwenden)[^103]
CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS=120000       # Git-Timeout für Plugin-Marketplace (Standard 120s, vorher 30s)[^105]
CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS=1        # Eingebaute Commit-/PR-Anweisungen entfernen[^117]
CLAUDE_CODE_DISABLE_CRON=1                    # Geplante Cron-Jobs mitten in der Sitzung stoppen[^121]
CLAUDE_CODE_SESSIONEND_HOOKS_TIMEOUT_MS=30000 # SessionEnd-hooks-Timeout (Standardwert variiert)[^123]
CLAUDE_CODE_USE_POWERSHELL_TOOL=1             # Windows-PowerShell-Tool unter Linux/macOS aktivieren (erfordert pwsh im PATH; v2.1.111+)[^153]
CLAUDE_CODE_ENABLE_AWAY_SUMMARY=1             # Sitzungs-Recap erzwingen, wenn Telemetrie deaktiviert ist (v2.1.108+)[^153]
OTEL_LOG_RAW_API_BODIES=1                     # Vollständige API-Anfrage-/Antwort-Bodies als OTel-Log-Events ausgeben (v2.1.111+)[^153]
TRACEPARENT=00-...                            # W3C-Trace-Context-Parent (v2.1.110+, SDK/headless)[^153]
TRACESTATE=vendor=value                       # W3C-Trace-Context-State (v2.1.110+, SDK/headless)[^153]

OpenTelemetry-Exporter + Gating sensibler Felder:¹⁶³

OTEL_LOGS_EXPORTER=none                       # OTel-Logs-Exporter (unterstützt 'none' zum Deaktivieren; v2.1.85 hat Crash behoben)
OTEL_METRICS_EXPORTER=none                    # OTel-Metrics-Exporter (unterstützt 'none'; v2.1.85 hat Crash behoben)
OTEL_TRACES_EXPORTER=none                     # OTel-Traces-Exporter (unterstützt 'none'; v2.1.85 hat Crash behoben)
OTEL_LOG_TOOL_CONTENT=1                       # Opt-in für die Ausgabe von Tool-Inhalten in OTel-Spans (v2.1.101+, standardmäßig sensibel)
OTEL_LOG_TOOL_DETAILS=1                       # Opt-in für tool_parameters in OTel-tool_result-Events (v2.1.85+)
OTEL_LOG_USER_PROMPTS=1                       # Opt-in für die Ausgabe von Benutzer-Prompts in OTel-Traces (v2.1.101+, standardmäßig sensibel)
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1    # Release-Notes-Abruf deaktivieren (v2.0.17+); v2.1.110 hat zudem die Auto-Title-Haiku-Anfrage in headless/SDK gestoppt, wenn gesetzt

v2.1.121+ Span-Attribute für LLM-Anfragen: stop_reason, gen_ai.response.finish_reasons und user_system_prompt werden nun bei LLM-Anfrage-Spans ausgegeben. user_system_prompt ist hinter OTEL_LOG_USER_PROMPTS=1 geschützt, da es PII enthalten kann.¹⁶¹

v2.1.122+ Änderungen auf Event-Ebene: Numerische Attribute bei api_request- und api_error-Log-Events werden jetzt als Zahlen ausgegeben (vorher Strings) — behebt Probleme bei nachgelagerten OTel-Collectoren, die das Schema strikt typisiert haben. Ein neues claude_code.at_mention-Log-Event wird ausgelöst, wenn Claude Code eine @-Erwähnung auflöst.¹⁶¹

API-/Modellsteuerung:¹⁶³

CLAUDE_CODE_EXTRA_BODY='{...}'                # Zusätzliche Body-Felder in API-Aufrufe einfügen; v2.1.113 hat 400-Fehler mit output_config.effort bei Vertex-/Subagent-Aufrufen behoben
CLAUDE_CODE_MAX_CONTEXT_TOKENS=200000         # Maximale Kontext-Tokens überschreiben (vorhandene Variable; v2.1.98 hat die Behandlung von DISABLE_COMPACT korrigiert, wenn beide gesetzt sind)
CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS=25000 # Standardmäßiges Token-Limit für Dateilesevorgänge überschreiben (v2.1.0+)
CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK=1   # Bei Streaming-Fehlern nicht auf Non-Streaming-API zurückfallen (v2.1.83+)
ANTHROPIC_BETAS=beta1,beta2                   # Beta-API-Header aktivieren; v2.1.78 hat das stille Ignorieren bei Haiku-Modellen behoben
ANTHROPIC_SMALL_FAST_MODEL=arn:...            # Schnelles Modell-ID (Bedrock-ARN unterstützt; v0.2.125 hat das Escapen von Slashes in ARN gestoppt)

Plugins / MCP:¹⁶³

CLAUDE_CODE_PLUGIN_CACHE_DIR=~/.claude/plugins # Plugin-Cache-Verzeichnis (v2.1.72 hat literales '~'-Verzeichnis in einigen Shells behoben)
CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1 # Plugin-Marketplace-Cache bei fehlgeschlagenem git pull beibehalten (offline-freundlich; v2.1.90+)
CLAUDE_CODE_MCP_SERVER_NAME=server1           # Wird an MCP-headersHelper-Skripte übergeben, sodass ein Helper mehrere Server bedienen kann (v2.1.85+)
CLAUDE_CODE_MCP_SERVER_URL=https://...        # Wird zusammen mit dem Namen an MCP-headersHelper-Skripte übergeben (v2.1.85+)

Shell / IDE:¹⁶³

CLAUDE_CODE_SHELL_PREFIX="time "              # Jeden von Claude aufgerufenen Shell-Befehl mit einem Präfix umschließen (v1.0.61+)
CLAUDE_CODE_GIT_BASH_PATH=C:\Program\ Files\Git\bin\bash.exe  # Benutzerdefinierter Git-Bash-Pfad unter Windows (v2.1.98+)
CLAUDE_CODE_EXIT_AFTER_STOP_DELAY=60000       # SDK: nach N ms Inaktivität beenden (v2.0.35+)
CLAUDE_CODE_AUTO_CONNECT_IDE=false            # IDE-Auto-Verbindung deaktivieren (v1.0.61+)

Enterprise / Auth:¹⁶³

CLAUDE_CODE_PROXY_RESOLVES_HOSTS=1            # Opt-in für proxyseitige DNS-Auflösung (v2.0.55 hat dies von Standard-an auf Opt-in verschoben)
CLAUDE_CODE_API_KEY_HELPER_TTL_MS=300000      # TTL für dynamisch generierte API-Schlüssel über apiKeyHelper (apiKeyHelper-Refresh hinzugefügt in v0.2.74 mit 5-Min.-Standard; Umgebungsvariable hinzugefügt in v0.2.117)

Skill-Variablen (v2.1.69+):

${CLAUDE_SKILL_DIR}                            # Selbstreferenz für skills, um ihr eigenes Verzeichnis zu finden[^117]

SDK-Aufrufer-Identität (v2.1.51+):

CLAUDE_CODE_ACCOUNT_UUID=uuid                  # Account-UUID synchron für SDK-Aufrufer bereitstellen
CLAUDE_CODE_USER_EMAIL=[email protected]        # Benutzer-E-Mail für SDK-Aufrufer bereitstellen
CLAUDE_CODE_ORGANIZATION_UUID=uuid             # Organisations-UUID für SDK-Aufrufer bereitstellen

Debugging:

ANTHROPIC_LOG=debug                             # API-Anfrage-Logging aktivieren

Welches Modell sollte ich wählen?

Die Wahl des richtigen Modells für jede Aufgabe wirkt sich erheblich auf Kosten und Qualität aus. Claude Code ermöglicht flexibles Modellwechseln auf mehreren Ebenen.

Verfügbare Modelle

Opus 4.7 (16. April 2026): Das aktuelle Flaggschiff. 1M-Token-Kontextfenster zum Standardpreis — kein Long-Context-Aufschlag. 128K maximale Ausgabe, ausschließlich adaptives Thinking (Extended Thinking entfernt) und eine neue Effort-Stufe xhigh, die als Ausgangspunkt für Coding- und agentische Workloads empfohlen wird.¹⁵² Verlässlicher Wissensstand: Januar 2026. Trainingsdaten-Stichtag: Januar 2026. Modell-ID: claude-opus-4-7. Die Preise entsprechen Opus 4.6 mit 5/25 $ pro MTok, 5-Min-Cache-Schreibvorgang 6,25 $, 1-Std-Cache-Schreibvorgang 10 $ und Cache-Lesevorgang 0,50 $ pro MTok.¹⁵¹ Opus 4.7 löst auf SWE-Bench dreimal mehr Produktionsaufgaben als Opus 4.6, erzielt 70 % auf CursorBench (gegenüber 58 % bei 4.6) und steigert die Lösungsrate um 13 % auf dem internen 93-Aufgaben-Coding-Benchmark von Anthropic.¹⁵¹ Verwendet einen neuen Tokenizer — rechnen Sie für denselben Text mit etwa 1× bis 1,35× Tokenanzahl; erhöhen Sie den max_tokens-Spielraum und passen Sie Compaction-Trigger an.¹⁵² Vision unterstützt Bilder bis zu 2.576 px / 3,75 MP mit 1:1-Pixelkoordinaten.¹⁵²

Opus 4.7 Coding-Benchmarks (April 2026):¹⁵⁸

Opus 4.7 führt SWE-bench Verified um 12,7 Punkte vor der vielzitierten GPT-5-Codex-Baseline und SWE-bench Pro um 6,6 Punkte vor GPT-5.4 (57,7 %). Auf Terminal-Bench 2.0 liegt GPT-5.3-Codex weiterhin knapp vor GPT-5.4 (77,3 % gegenüber 75,1 %), und beide führen vor Opus 4.7 (69,4 %). Die Benchmark-Spitzenposition ist im Fluss; prüfen Sie die Anbieterseiten, bevor Sie sich auf eine quartalsübergreifende Wahl festlegen.

Standardmodell nach Plan (Claude Code):¹⁵⁴

Opus 4.7 erfordert Claude Code v2.1.111 oder höher; führen Sie claude update aus, um zu aktualisieren.¹⁵⁴ Bedrock, Vertex und Foundry stellen Opus 4.7 über explizite vollständige Modellnamen oder ANTHROPIC_DEFAULT_OPUS_MODEL-Pins bereit, standardmäßig nicht über den opus-Alias.¹⁵⁴

Breaking Changes der Messages API in Opus 4.7 (für Aufrufer sichtbar):¹⁵²

• Extended Thinking budget_tokens wurde entfernt. Verwenden Sie stattdessen thinking: {type: "adaptive"}. Adaptives Thinking ist standardmäßig deaktiviert; Anfragen ohne thinking-Feld laufen ohne Thinking.
• Das Setzen von temperature, top_p oder top_k auf einen Nicht-Standardwert gibt HTTP 400 zurück. Lassen Sie diese Parameter weg und steuern Sie das Modell über das Prompting.
• Thinking-Inhalte werden standardmäßig aus den Antworten ausgelassen. Setzen Sie thinking.display: "summarized", um sichtbares Reasoning wiederherzustellen (erforderlich, wenn Ihr Produkt Thinking an Benutzer streamt).

Task Budgets (Beta-Header task-budgets-2026-03-13) ermöglichen es, dem Modell über output_config.task_budget ein Token-Ziel über eine vollständige agentische Schleife hinweg vorzugeben; Mindestwert 20K Tokens.¹⁵²

Opus 4.6 (Legacy): Weiterhin verfügbar als claude-opus-4-6 mit 1M Kontext und 128K maximaler Ausgabe. Erwägen Sie eine Migration auf Opus 4.7 für besseres agentisches Coding. Opus 4.6 erschien ursprünglich am 5. Februar 2026.⁸⁶¹⁵¹ Seit v2.1.117 (22. April 2026) verwenden Pro- und Max-Abonnenten standardmäßig die Effort-Stufe high bei Opus 4.6 und Sonnet 4.6 (zuvor medium); Opus 4.7 bleibt bei xhigh. Diese Umstellung stellte die Intelligenz nach dem Effort-Downgrade vom 4. März bis 7. April wieder her, das im Postmortem vom 23. April dokumentiert ist.¹⁵⁹¹⁶⁰

Sonnet 4.6 (17. Februar 2026): Ausgewogenes Modell; ersetzte Sonnet 4.5 als Standard auf claude.ai und in Claude Cowork.¹⁰⁰ Gleicher Preis wie Sonnet 4.5 (3/15 $ pro MTok). Verbesserte agentische Suchleistung bei geringerem Tokenverbrauch. Unterstützt Extended Thinking, adaptives Thinking und ein 1M-Token-Kontextfenster (Beta). 64K maximale Ausgabe (Obergrenze 128K in v2.1.77).¹²⁶ Wissensstand: August 2025 (verlässlich), Januar 2026 (Trainingsdaten). Modell-ID: claude-sonnet-4-6.

Claude Mythos Preview (7. April 2026): Ein Forschungs-Preview-Frontier-Modell für defensive Cybersecurity-Arbeit, angeboten unter Project Glasswing.¹⁴⁶ Nur auf Einladung; nicht allgemein verfügbar. Anthropic positioniert Opus 4.7 als bewusst weniger leistungsfähig als Mythos in Cyber-Dimensionen — ein Sicherheits-Tradeoff — und hat ein Cyber Verification Program unter https://claude.com/form/cyber-use-case für legitime Sicherheitsforscher eröffnet, die erweiterten Zugang benötigen.¹⁵³

Warum diese Preisunterschiede wichtig sind: Eine typische Coding-Session verbraucht 50K–200K Eingabe-Tokens und 10K–50K Ausgabe-Tokens. Mit Haiku sind das 0,10–0,45 $ pro Session. Mit Opus kostet dieselbe Session 0,50–2,25 $, also 5× mehr. Reservieren Sie Opus für wirklich schwierige Probleme.¹

Wann welches Modell verwenden

Haiku: Verwenden Sie es für Subagenten zur Exploration, einfache Dateisuchen und schnelle Fragen. Es ist etwa 5× günstiger als Opus und antwortet schneller. Perfekt für Hintergrundaufgaben, bei denen kein tiefes Reasoning erforderlich ist.

Sonnet: Das Arbeitspferd für die tägliche Entwicklung, wenn Kosten eine Rolle spielen. Bewältigt die meisten Coding-Aufgaben: Implementierung von Funktionen, Behebung von Bugs, Schreiben von Tests, Code-Review. Sonnet 4.6 liefert eine verbesserte agentische Suche und bessere Token-Effizienz im Vergleich zu Sonnet 4.5, mit Unterstützung für adaptives Thinking und einem 1M-Kontextfenster zum Standardpreis.¹⁰⁰ Seit Opus 4.7 (16. April 2026) verwendet Claude Code Opus standardmäßig nur in den Plänen Max und Team Premium; Pro, Team Standard, Enterprise und API-Konten behalten Sonnet 4.6 als Standard, bis Enterprise und API am 23. April 2026 auf Opus 4.7 wechseln.¹⁵⁴ Verwenden Sie Sonnet, wenn Sie günstigere Tokens, geringere Latenz oder Subagenten-Ökonomie benötigen.

Opus: Die Flaggschiff-Stufe seit dem 16. April 2026 und der Standard in den Plänen Max und Team Premium.¹⁵¹¹⁵⁴ Reservieren Sie das teurere Reasoning für Bereiche, in denen es sich auszahlt: Architekturentscheidungen, kniffliges Debugging, Verständnis komplexer Systeme, Sicherheitsanalyse, agentische Langzeitarbeit. Opus 4.7 löst auf SWE-Bench dreimal mehr Produktionsaufgaben als Opus 4.6, erzielt 70 % auf CursorBench (gegenüber 58 %) und steigert die Lösungsrate um 13 % auf einem internen 93-Aufgaben-Coding-Benchmark.¹⁵¹ Claude Code verwendet standardmäßig die Effort-Stufe xhigh bei Opus 4.7, einstellbar über /effort (v2.1.111+).¹⁵³¹⁵⁴ Auto Mode steht Max-Abonnenten auf Opus 4.7 über die Anthropic API ohne --enable-auto-mode zur Verfügung; andere Pläne/Anbieter haben planspezifische und administrativ kontrollierte Verfügbarkeiten.¹⁵³ 1M Kontext zum Standardpreis — kein Long-Context-Aufschlag. Verhaltensänderungen, die man kennen sollte: Opus 4.7 folgt Anweisungen wörtlicher, kalibriert die Antwortlänge an die Aufgabenkomplexität, führt standardmäßig weniger Subagenten aus und verwendet einen direkteren Ton mit weniger validierungslastigen Formulierungen. Wenn Ihre Prompts Gerüstkonstruktionen enthalten, um Zwischenberichte oder Doppelprüfungsverhalten zu erzwingen, versuchen Sie, diese zu entfernen.¹⁵²

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) verwendet. Hervorragend für komplexes Refactoring, bei dem Sie den besten Plan möchten, aber kein Opus-Reasoning für jede einzelne Bearbeitung benötigen.

Modelle wechseln

Während einer Session:

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

Beim Start:

claude --model opus

Per Umgebungsvariable:

export ANTHROPIC_MODEL=opus

In settings.json:

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

Speziell für Subagenten:

export CLAUDE_CODE_SUBAGENT_MODEL=haiku

Erweiterter Kontext

Aktivieren Sie für große Codebases oder lange Sessions den 1M-Token-Kontext:

claude --model sonnet[1m]
claude --model opus[1m]           # Opus 4.7 mit 1M Kontext

Oder innerhalb einer Session:

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

Opus 4.7, Opus 4.6 und Sonnet 4.6 enthalten alle das vollständige 1M-Token-Kontextfenster zum Standardpreis — kein Long-Context-Aufschlag.¹⁵⁵ Eine Anfrage mit 900K Tokens wird zum gleichen Token-Preis wie eine Anfrage mit 9K Tokens abgerechnet. Rabatte für Prompt-Caching und Batch-Verarbeitung gelten zu Standardraten über das gesamte Kontextfenster.

In den Abonnements Max, Team und Enterprise ist Opus mit 1M Kontext automatisch enthalten — kein [1m]-Suffix erforderlich (standardmäßig aktiviert seit v2.1.75, 13. März 2026).¹²⁴¹⁵⁴ Bei Pro ist 1M Kontext über Extra Usage zugänglich. API- und Pay-as-you-go-Benutzer haben vollen 1M-Zugang zu Standard-Token-Preisen.¹⁵⁴

Um 1M-Kontext-Varianten im Modell-Picker zu deaktivieren, setzen Sie CLAUDE_CODE_DISABLE_1M_CONTEXT=1.

Aktuelles Modell prüfen

> /status

Der Befehl zeigt das aktuelle Modell, Kontoinformationen, angewendete Einstellungen und weitere Session-Status an.

Modell-Picker-Beschriftungen (v2.1.51+): Der /model-Picker zeigt jetzt menschenlesbare Beschriftungen (z. B. „Sonnet 4.6”) anstelle von Roh-Modell-IDs für gepinnte Versionen, mit Upgrade-Hinweisen, wenn neuere Versionen verfügbar sind.¹⁰⁵

Fast Mode (v2.1.36+)

Fast Mode bietet deutlich schnellere Ausgabe vom gleichen Modell; es wird nicht zu einem günstigeren Modell gewechselt. Schalten Sie es während einer Session mit /fast um.⁹³

> /fast            # Fast Mode ein-/ausschalten

Preise (Opus 4.6 Fast Mode):

Fast Mode ist Research Preview, nur für Opus 4.6 und liefert etwa 2,5× schnellere Ausgabe zum 6-fachen Basispreis.¹⁵⁶ Das Aktivieren von /fast wechselt die Session automatisch zu Opus 4.6, falls Sie ein anderes Modell verwendet haben; das Deaktivieren von /fast belässt Sie auf Opus 4.6, bis Sie über /model wechseln. Fast Mode ist nicht verfügbar bei Opus 4.7, Sonnet, Haiku oder über Bedrock/Vertex/Foundry. Es erfordert aktiviertes Extra Usage und für Team/Enterprise eine administrative Freischaltung.

Wann Fast Mode verwenden: - Schnelles Iterieren bei kleinen Änderungen, wenn Latenz der Engpass ist - Generieren von Tests, Boilerplate oder repetitivem Code, wenn Geschwindigkeit wichtiger ist als Kosten - Sequenzielle Bearbeitung einer Liste ähnlicher Aufgaben

Wann Fast Mode NICHT verwenden: - Langlaufende agentische Aufgaben (Kosten summieren sich schnell zum 6-fachen Tarif) - Hintergrund-Subagenten-Arbeit (niemand wartet auf die Ausgabe) - Budgetbewusste Sessions

Opus 4.6 Fast Mode beinhaltet das vollständige 1M-Kontextfenster (v2.1.50+). Die Fast-Mode-Preise sind über den 1M-Kontext hinweg pauschal — kein zusätzlicher Long-Context-Aufschlag.¹⁰³¹⁵⁶

Experten-Tipp: Fast Mode lässt sich nicht mit opusplan kombinieren (opusplan mischt bereits Opus und Sonnet; Fast Mode wirkt sich nur auf Opus 4.6 aus). Verwenden Sie Fast Mode direkt, wenn Latenz wichtiger ist als Kosten, und deaktivieren Sie ihn für autonome oder Batch-Arbeit. /fast erfordert Extra Usage; Team-/Enterprise-Admins müssen es möglicherweise erst freischalten (v2.1.37 Fix).⁹³¹⁵⁶

Effort-Steuerung (v2.1.111+, Opus 4.7)

Opus 4.7 führt einen neuen Effort-Regler ein, der den Tradeoff zwischen Geschwindigkeit und Intelligenz abstimmt. Verwenden Sie /effort während einer Session:

> /effort              # öffnet einen interaktiven Schieberegler (Pfeiltasten + Enter)
> /effort xhigh        # direkt setzen

Claude Code verwendet jetzt standardmäßig die Effort-Stufe xhigh für Opus 4.7. xhigh ist nur für Opus 4.7 — andere Modelle fallen auf high zurück. Claude Managed Agents handhabt Effort automatisch; der Effort-Parameter ist ein Konzept der Messages API.¹⁵²¹⁵³

Auto Mode auf Max (v2.1.111+)

Auto Mode — ein sichererer Ersatz für --dangerously-skip-permissions — steht Max-Abonnenten auf Opus 4.7 über die Anthropic API ohne --enable-auto-mode zur Verfügung.¹⁵³ Ein Sonnet-4.6-Klassifikator überprüft jede Aktion vor der Ausführung und prüft Intent-Übereinstimmung und Sicherheit. Hinweis (v2.1.111+): Das Flag --enable-auto-mode wurde entfernt; starten Sie eine Session im Auto Mode stattdessen mit --permission-mode auto. Auto Mode ist nicht für Pro verfügbar; gemäß den Permission-Modes-Docs von Anthropic ist es derzeit nur direkt über Anthropic-API verfügbar — Bedrock, Vertex und Foundry werden noch nicht unterstützt.

Eigene Regeln ohne Verlust der Defaults (v2.1.118+). Frühere Versionen machten autoMode.allow, autoMode.soft_deny und autoMode.environment zu einem Entweder-oder: Definieren Sie eine eigene Liste und Sie verlieren die eingebauten Sicherheitsregeln. Das $defaults-Sentinel löst das Problem — es expandiert inline zur eingebauten Liste genau an der Position, an der Sie es platzieren, sodass Sie eigene Regeln darum herum schichten können:¹⁵⁹

// .claude/settings.json
{
  "autoMode": {
    "allow": [
      "Bash(npm test:*)",        // Ihre Ergänzungen, vorangestellt
      "$defaults",                // eingebaute Allow-Liste hier eingefügt
      "Bash(git push:origin/feature/*)"  // dahinter angehängt
    ]
  }
}

„Nicht erneut fragen”-Opt-in (v2.1.118+). Der Auto-Mode-Opt-in-Prompt bietet jetzt eine Option „Nicht erneut fragen”, sodass häufige Benutzer den Erklärtext unterdrücken können, ohne ein Flag in einem Skript zu hinterlegen.¹⁵⁹

Neue Befehle in v2.1.105–v2.1.114¹⁵³¹⁵⁷

Session-Recap (v2.1.108+)

Eine neue Funktion auf Session-Ebene, die Kontext anzeigt, wenn Sie zu einer pausierten Session zurückkehren. Standardmäßig aktiviert und deaktivierbar über /config oder CLAUDE_CODE_ENABLE_AWAY_SUMMARY=0. Das Modell kann auch eingebaute Slash-Befehle (/init, /review, /security-review) über das Skill-Tool aufrufen — eine Erweiterung des Subagent-/Skill-Musters.¹⁵³

Push-Benachrichtigungen (v2.1.110+)

Wenn Remote Control mit aktivierter Option „Push, wenn Claude entscheidet” konfiguriert ist, kann Claude jetzt nach eigenem Ermessen mobile Push-Benachrichtigungen über ein neues Push-Notification-Tool senden. Ergänzt die bestehende mobile/web-Oberfläche von Remote Control.¹⁵³ /context, /exit und /reload-plugins funktionieren jetzt ebenfalls von Remote-Control-Clients aus.

Windows PowerShell Tool (v2.1.111+, Rollout)

Claude Code rollt ein natives Windows-PowerShell-Tool aus. Auf Linux/macOS aktivieren Sie es mit CLAUDE_CODE_USE_POWERSHELL_TOOL=1 (erfordert pwsh auf PATH). Auf Windows steuert dieselbe Variable während des Rollouts das Opt-in/Opt-out.¹⁵³

Permission-Mode-Auto-Genehmigung (v2.1.119+). PowerShell-Tool-Befehle können jetzt im Permission-Modus auf die gleiche Weise wie Bash-Befehle automatisch genehmigt werden. Allow-Regeln wie PowerShell(Get-*:*) und die bestehende Pattern-Syntax umgehen jetzt den Prompt für schreibgeschützte Operationen und passen die Bediener-Ergonomie an, die Teams unter Linux/macOS bereits gewohnt sind.¹⁵⁹

Berechtigungs-Reduzierung: Schreibgeschützte Bash-Befehle (v2.1.111+)

Schreibgeschützte Bash-Patterns mit Glob-Argumenten (z. B. ls *.ts, cat src/*.md) und Befehle, die mit cd <project-dir> && beginnen, lösen keinen Berechtigungs-Prompt mehr aus.¹⁵³ Kombiniert mit /less-permission-prompts sind deutlich weniger Unterbrechungen in alltäglichen Workflows zu erwarten.

Distributed Tracing (v2.1.110+)

SDK- und Headless-Sessions lesen jetzt TRACEPARENT und TRACESTATE aus der Umgebung und verknüpfen Claude Code-Läufe in verteilte Traces. Kombinieren Sie dies mit OTEL_LOG_RAW_API_BODIES=1 (v2.1.111+), um vollständige API-Anfrage-/Antwort-Bodies als OpenTelemetry-Log-Events zum Debugging auszugeben.¹⁵³

Native Binary Distribution (v2.1.113+)¹⁵⁷

v2.1.113 ändert, wie der CLI startet: claude startet jetzt ein natives Claude Code-Binary über eine plattformspezifische optionale Abhängigkeit, anstatt gebündeltes JavaScript auszuführen. Installations- und Update-Befehle bleiben gleich, und Teams müssen ihre Rollout-Skripte nicht ändern.

Prompt-Editor-Tastenkombinationen (v2.1.113+)¹⁵⁷

Der Prompt-Editor erhält Readline-artige Navigation in mehrzeiliger Eingabe sowie Vollbild-Viewport-Scrolling:

Diese sind standardmäßig aktiviert. Keine Keybinding-Konfiguration erforderlich.

Subagent-Stall-Timeout (v2.1.113+)¹⁵⁷

Subagenten, die mitten im Stream hängen bleiben, schlagen jetzt nach 10 Minuten mit einer klaren Fehlermeldung fehl, anstatt stillschweigend zu hängen. Kombinieren Sie dies mit CLAUDE_STREAM_IDLE_TIMEOUT_MS (v2.1.84+) für eine breitere Abdeckung steckengebliebener Prozesse bei streamenden APIs.

v2.1.114 Stabilitäts-Fix¹⁵⁷

v2.1.114 (18. April 2026) liefert einen einzigen Fix: Der Berechtigungsdialog konnte abstürzen, wenn ein Agent-Teams-Teamkollege Tool-Berechtigungen anforderte. Aktualisieren Sie, wenn Sie Agent Teams verwenden.

Was kostet Claude Code?

Das Verständnis und die Kontrolle der Kosten sind für eine nachhaltige Nutzung von Claude Code unerlässlich. Siehe auch Modellauswahl für Modellfähigkeiten und Entscheidungsrahmen für die Auswahl des richtigen Modells je 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

Abonnementbenutzer sehen in /cost eine Aufschlüsselung pro Modell und Cache-Treffer, die genau zeigt, welche Modelle Tokens verbraucht haben und wie viel aus dem Cache bedient wurde (v2.1.92+).¹⁴⁴

Abonnement-Pläne

Ratenlimits (August 2025): Anthropic führte wöchentliche Ratenlimits für zahlende Abonnenten ein. Max-Abonnenten können zusätzliche Nutzung über das Ratenlimit hinaus zu Standard-API-Tarifen erwerben.²¹

API Token-Preise (April 2026)¹¹⁵¹

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

1M-Kontext-Preise (April 2026): Opus 4.7, Opus 4.6, Sonnet 4.6 und Mythos Preview umfassen alle 1M zu Standard-Preisen pro MTok — kein Aufschlag für langen Kontext.¹⁵⁵ Dies ist eine kürzliche Konsolidierung; ältere Hinweise darüber, dass Opus 4.6 oder Sonnet 4.6 das 2-fache für Eingabe / 1,5-fache für Ausgabe über 200K Eingabe-Tokens zahlen, sind nicht mehr aktuell. Legacy-Opus 4.5 und ältere Modelle behalten ihre ursprünglichen Preisstrukturen bei.

Preise für Datenresidenz: Die Angabe von US-exklusiver Inferenz über inference_geo fügt einen 1,1-fachen Multiplikator auf alle Token-Preise hinzu, einschließlich Cache-Lesevorgängen und -Schreibvorgängen (Opus 4.6+ Modelle).¹⁵⁵

Prompt Caching reduziert wiederholte Eingabekosten erheblich: Cache-Schreibvorgänge kosten das 1,25-fache der Basis (5-Minuten-Cache) oder das 2-fache (1-Stunden-Cache), aber Cache-Lesevorgänge kosten nur das 0,1-fache — eine Einsparung 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 mit 24-Stunden-Bearbeitungszeit für nicht dringende Aufgaben wie nächtliche Testsuiten.

Richtlinie zu mehreren Konten⁵⁹

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

Was erlaubt ist:

Technische Grenzen: - 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 Usage Policy): - Erstellen von Konten, um Sperren zu umgehen, nachdem man gesperrt wurde - Koordinieren böswilliger Aktivitäten über Konten hinweg, um Entdeckung zu vermeiden - Verwendung mehrerer Konten zur Umgehung von Ratenlimits oder Gutschriften der kostenlosen Stufe

Hinweis aus der Praxis: Im Januar 2026 wurden die 22 Max-Konten des Power-Users Jeffrey Emanuel (@doodlestein) automatisch markiert und vorübergehend gesperrt. Der Anthropic-Mitarbeiter Thariq (@trq212) löste dies innerhalb von 4 Stunden, nachdem die legitime Nutzung bestätigt wurde. Wenn Sie Claude Code sowohl für Arbeit als auch für private Projekte über mehrere Konten hinweg umfassend nutzen, ist genau das der Zweck des Dienstes, aber versuchen Sie nicht, das System auszunutzen.

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

Kostenfaktoren

Reale Kostenbeispiele

Kostenspar-Einsicht: Haiku für Exploration-Subagenten und Sonnet für die Implementierung reduziert die Kosten typischerweise um 40-50 % im Vergleich zur Nutzung von Sonnet für alles.

Team-Kostenmanagement

Empfohlene TPM/RPM nach Teamgröße:

Versteckte Tool-Gebühren

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

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

Kostenspar-Strategien

1. Haiku für Subagenten nutzen: Die meiste Exploration benötigt kein Sonnet
2. Prompt Caching aktivieren: Standard, aber prüfen, dass es nicht deaktiviert ist
3. Max Turns setzen: claude --max-turns 5 verhindert ausufernde Gespräche
4. Plan Mode für Exploration nutzen: Keine Ausführung = keine versehentlich teuren Operationen
5. Proaktiv verdichten: Kleinerer Kontext = weniger Tokens
6. Ausgabe begrenzen: export CLAUDE_CODE_MAX_OUTPUT_TOKENS=2000
7. Batch API für nicht dringende Arbeit: 50 % Rabatt auf Eingabe- und Ausgabe-Tokens

Nutzungsüberwachung

• Claude Console: platform.claude.com (erfordert Admin- oder Billing-Rolle)
• Workspace-Limits: Ausgabenlimits pro Workspace setzen
• Bedrock/Vertex: Native Cloud-Kostenüberwachung nutzen
• LiteLLM: Für detaillierte Nachverfolgung pro Benutzer mit Drittanbietern

Hintergrund-Token-Nutzung

Einige Operationen verbrauchen Tokens im Hintergrund: - Gesprächszusammenfassung für /resume - /cost- und /status-Befehle - Auto-Verdichtung

Typischerweise unter $0.04 pro Sitzung.

Claude Code Analytics API (Team/Enterprise)⁵³

Programmatischer Zugriff auf die Claude Code-Nutzungsanalysen und Produktivitätsmetriken Ihrer Organisation über die Admin API.

Endpunkt: GET /v1/organizations/usage_report/claude_code

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

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 (Annahme-/Ablehnungsraten für Edit, Write usw.) - Kostenverfolgung und -zuweisung über Teams hinweg - ROI-Begründung für KI-Coding-Tools

Hinweis: Daten erscheinen innerhalb von 1 Stunde nach Aktivitätsabschluss. Für Konsistenz werden in Antworten nur Daten berücksichtigt, die älter als 1 Stunde sind.

Entscheidungsrahmen

Zu wissen, dass Funktionen existieren, reicht nicht aus. Sie müssen wissen, wann Sie welche verwenden. Diese Entscheidungsbäume verwandeln Wissen in Handeln.

Welches Modell sollte ich verwenden?

START → Is the task simple? (file search, quick question, formatting)
         │
         ├── YES → Use Haiku
         │         Cost: ~$0.03/task
         │         Speed: Fastest
         │
         └── NO → Does it require deep reasoning?
                  (architecture, complex debugging, security analysis)
                  │
                  ├── YES → Use Opus 4.7 (xhigh effort default)
                  │         Cost: ~$2.00/task
                  │         Quality: Highest (1M context at standard price, adaptive reasoning)
                  │
                  └── NO → Use Sonnet
                           Cost: ~$0.75/task
                           Balance: Best overall when cost matters

Faustregel: Opus 4.7 ist der Standard für Max und Team Premium. Auf Pro/Team Standard/Enterprise/API ist Sonnet 4.6 der Standard (Enterprise + Anthropic API wechseln am 23. April 2026 zu Opus 4.7).¹⁵⁴ Wechseln Sie für Subagents zu Haiku. Eskalieren Sie zu Opus, wenn sich Sonnets Antwort oberflächlich anfühlt. 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?

Do you want explicit control over when it runs?
│
├── YES → Use Slash Command
│         Example: /deploy, /test, /security-review
│         You invoke it. You control timing.
│
└── NO → Should the expertise apply automatically based on context?
         │
         ├── YES → Use Skill
         │         Example: Security patterns, domain rules, code standards
         │         Claude recognizes context and applies expertise.
         │
         └── NO → Does the work need isolated context?
                  │
                  ├── YES → Is there one subtask or many parallel subtasks?
                  │         │
                  │         ├── ONE → Use Subagent (Task tool)
                  │         │         Example: Deep exploration, parallel analysis
                  │         │         Prevents context bloat in main conversation.
                  │         │
                  │         └── MANY → Use Agent Team (v2.1.32+)
                  │                   Example: 5 agents reviewing different modules simultaneously
                  │                   Opus coordinates; each agent works independently.
                  │
                  └── NO → Just prompt directly
                           Not everything needs abstraction.

Hook vs. Prompt?

Must the action ALWAYS happen, regardless of Claude's judgment?
│
├── YES → Use Hook (deterministic)
│         Examples:
│         - Format code after every edit
│         - Log all bash commands
│         - Block access to .env files
│         Claude cannot skip, forget, or decide otherwise.
│
└── NO → Use Prompt (probabilistic)
         Examples:
         - "Consider adding tests"
         - "Think about edge cases"
         - "Review for security if relevant"
         Claude decides based on context.

Wann sollten Sie Extended Thinking verwenden?

Is this a genuinely hard problem?
│
├── Architectural decision with many tradeoffs → YES, use thinking
├── Complex debugging with unclear root cause → YES, use thinking
├── Security analysis requiring careful reasoning → YES, use thinking
├── Understanding unfamiliar codebase → YES, use thinking
│
├── Routine bug fix → NO, skip thinking
├── Simple refactoring → NO, skip thinking
├── Code formatting → NO, skip thinking
└── Quick questions → NO, skip thinking

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

Opus 4.6 Adaptive 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 notwendig — Opus skaliert bei schwierigen Problemen nach oben und bleibt bei einfachen schnell. Das manuelle Umschalten des Thinkings ist bei Sonnet am nützlichsten, wenn Sie eine tiefere Analyse erzwingen möchten.

Welche Ausführungsumgebung?

Where should this work happen?
│
├── Requires YOUR local files and tools
│   │
│   ├── Interactive, iterative work → Main REPL session
│   ├── One-shot scripted task → claude -p "prompt" (print mode)
│   ├── CI/CD automation → claude -p --json (non-interactive + structured output)
│   └── Parallel isolated tasks → Subagents via Task tool
│
├── Requires SOMEONE ELSE'S environment
│   │
│   └── Remote codebase or server → Background agent (cloud)
│
└── Doesn't require any environment
    │
    ├── Research or analysis → Subagent with Explore type
    └── Web content extraction → WebFetch / WebSearch tools

Agent-Teams vs. Subagents vs. Parallele Sitzungen

Do you need multiple agents working on related subtasks?
│
├── YES → Are the subtasks independent (no shared state)?
│         │
│         ├── YES → Can they share the same codebase?
│         │         │
│         │         ├── YES → Use Agent Team (v2.1.32+)
│         │         │         Opus coordinates. Agents share repo access.
│         │         │         Example: "Review auth, API, and DB modules in parallel"
│         │         │
│         │         └── NO → Use Parallel Sessions (separate terminals)
│         │                  Each has its own working directory.
│         │                  Example: "Fix repo-A and repo-B simultaneously"
│         │
│         └── NO → Use Sequential Subagents
│                  Results from one feed into the next.
│                  Example: "Explore → Plan → Implement"
│
└── NO → Use Single Subagent or Main REPL

Welcher Hook-Typ?

What kind of automation do you need?
│
├── Run a shell command at a specific event?
│   │
│   └── Use Command Hook
│       Trigger: PreToolUse, PostToolUse, Notification, Stop, SubagentStop
│       Example: "Run prettier after every file edit"
│       Config: hooks.PostToolUse[].command = "prettier --write $FILE"
│
├── Modify Claude's system prompt based on context?
│   │
│   └── Use Prompt Hook (v2.1.35+)
│       Trigger: Same events
│       Example: "Inject project rules when working in /src/auth/"
│       Config: hooks.PreToolUse[].prompt = "When editing auth files..."
│
└── Have Claude make a judgment call before proceeding?
    │
    └── Use Agent Hook (v2.1.35+)
        Trigger: Same events
        Example: "Evaluate if this bash command is safe before running"
        Config: hooks.PreToolUse[].agent = { prompt: "Is this safe?" }

Wann sollten Sie /fast verwenden?

Is response speed more important than depth right now?
│
├── YES → Use /fast
│         Same Opus 4.6 model, faster output
│         Good for: quick questions, simple edits, code explanations,
│                   file searches, formatting tasks
│
└── NO → Stay in normal mode
         Good for: architecture decisions, complex debugging,
                   security reviews, multi-file refactors,
                   anything requiring deep reasoning

/fast schaltet den Fast-Modus für die aktuelle Sitzung ein. 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 fein abgestufte Kontrolle darüber, welche Operationen ausgeführt werden können. Das Verständnis dieses Systems ist sowohl für die Sicherheit als auch für die Effizienz des Workflows von entscheidender Bedeutung. Siehe auch Enterprise Deployment für verwaltete Einstellungen, die Berechtigungen organisationsweit durchsetzen.

Berechtigungsstufen

Schreibgeschützte Tools (automatisch genehmigt): - Read – Dateiinhalte lesen - Glob – Dateien anhand eines Musters finden - Grep – Dateiinhalte durchsuchen - WebSearch – Im Web suchen - LSP – Code-Intelligenz (Go-to-Definition, Find References, Hover-Dokumentation)²⁵

Funktionen des LSP-Tools (v2.0.74+): Das LSP-Tool bietet IDE-ähnliche Code-Intelligenz: - Go-to-Definition: Springen Sie zu der Stelle, an der ein Symbol definiert ist - Find References: Listen Sie alle Verwendungen eines Symbols im gesamten Codebase auf - Hover-Dokumentation: Erhalten Sie Typinformationen und Dokumentation zu jedem Symbol - Funktioniert mit TypeScript, Python, Go, Rust und anderen Sprachen mit LSP-Unterstützung - Erfordert einen verfügbaren Sprachserver (typischerweise mit Ihrer Toolchain installiert)

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

Beim ersten Ausführen eines Modifikations-Tools fordert Claude Code eine Genehmigung an. Genehmigungen bleiben für die Sitzung bestehen, sofern nicht ausdrücklich anders konfiguriert.

Berechtigungsmodi

Auto-Modus (v2.1.85+): Ein sichererer Ersatz für --dangerously-skip-permissions. Ein separates Klassifikatormodell (Sonnet 4.6) prüft jede Aktion vor der Ausführung und kontrolliert, ob sie der Benutzerabsicht entspricht und sicher ist.¹³¹

So funktioniert es: - Schreibgeschützte Aktionen und Dateibearbeitungen im Arbeitsverzeichnis werden automatisch genehmigt - Benutzerdefinierte Allow/Deny-Regeln werden zuerst aufgelöst - Alles andere geht zur Bewertung an den Klassifikator - Bei einer Blockade versucht Claude automatisch einen alternativen Ansatz

Standardmäßig automatisch blockiert: curl | bash, Force-Push auf main, Produktions-Deployments/Migrationen, Massenlöschungen in der Cloud, IAM-/Berechtigungsänderungen, Versand sensibler Daten nach außen.¹³²

Circuit Breaker: 3 aufeinanderfolgende Blockaden oder insgesamt 20 in einer Sitzung führen zur Pause und Rückkehr zur manuellen Aufforderung.¹³²

# Enable at startup
claude --enable-auto-mode

# Or cycle into it during a session
Shift+Tab  # Cycles through: default → acceptEdits → auto → plan

Verfügbarkeit: Zuerst für Team-Plan-Benutzer, danach folgen Enterprise und API. Erfordert Sonnet 4.6 oder Opus 4.6.¹³¹

YOLO-Modus (v2.0.68+): Für vollständig autonomen Betrieb ohne jeglichen Sicherheitsklassifikator verwenden Sie das Flag --dangerously-skip-permissions. Das Flag sagt zu allem Ja: Dateibearbeitungen, Bash-Befehle, alle Tool-Aufrufe. Das Wort „dangerous” ist beabsichtigt. Der Auto-Modus ist die empfohlene Alternative für die meisten Anwendungsfälle.⁶¹

claude --dangerously-skip-permissions

Modus über CLI festlegen:

claude --permission-mode auto  # or acceptEdits, plan, bypassPermissions

Während der Sitzung umschalten:

Shift+Tab  # Cycles through modes

In settings.json:

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

Syntax der Berechtigungsregeln

Fein abgestufte Regeln steuern bestimmte Operationen. Regeln werden in Reihenfolge 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 eine Präfix-Übereinstimmung: Bash(npm run test:*) erlaubt npm run test, npm run test:unit und npm run test:integration.

Wichtige Einschränkung: Bash-Muster stimmen nur mit Präfixen überein, nicht mit Regex. Ein Muster wie Bash(curl http:*) passt nicht auf curl -X GET http://..., weil die Optionen vor der URL stehen. Für eine zuverlässige Blockade verbieten Sie den Befehl vollständig: Bash(curl:*).

Muster für Dateioperationen:

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

Pfadsyntax: - Relative Pfade: Edit(src/**) – relativ zum Arbeitsverzeichnis - Absolut ab Settings-Datei: Edit(/build/**) – relativ zum Speicherort der Settings-Datei - 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 zu erlauben oder zu verweigern.³⁹ Die Wildcard-Syntax ist nützlich, um schnell alle Tools von vertrauenswürdigen Servern zu aktivieren 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 unverzichtbar für Monorepos oder wenn Claude auf Code in Geschwisterverzeichnissen zugreifen muss.

Sandbox-Modus

Aktivieren Sie die Isolation von Dateisystem und Netzwerk:

> /sandbox

Oder konfigurieren Sie es in den Einstellungen:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["git", "docker"],
    "network": {
      "allowUnixSockets": ["~/.ssh/agent-socket"],
      "allowLocalBinding": true,
      "deniedDomains": ["pastebin.com", "transfer.sh", "0x0.st"]
    }
  }
}

Im Sandbox-Modus: - Dateisystemzugriff ist auf das Projektverzeichnis beschränkt - Netzwerkzugriff wird kontrolliert - Bestimmte Befehle sind von den Sandbox-Beschränkungen ausgenommen - Bash-Befehle werden automatisch erlaubt, wenn autoAllowBashIfSandboxed aktiviert ist

Expertentipp: Der Sandbox-Modus eignet sich hervorragend, um Claude auf nicht vertrauenswürdigen Codebases auszuführen. Aktivieren Sie ihn, wenn Sie unbekannte Projekte erkunden oder eine zusätzliche Schutzebene wünschen. Interne Tests von Anthropic ergaben, dass Sandboxing die Berechtigungsaufforderungen um 84 % reduziert.⁴⁵ Die Sandbox nutzt Primitive auf Betriebssystemebene (macOS Seatbelt, Linux Bubblewrap) für die Isolation von Dateisystem und Netzwerk, sodass selbst eine erfolgreiche Prompt Injection vollständig eingedämmt ist. Anthropic hat die Sandbox-Runtime als Open Source veröffentlicht für Teams, die ihre eigenen Agenten entwickeln.⁸⁹

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

Ausnahme für .claude/-Agent-Konfiguration (v2.1.121+): --dangerously-skip-permissions fragt nicht mehr bei Schreibvorgängen in .claude/skills/, .claude/agents/ und .claude/commands/ nach.¹⁶¹

Sicherheitsverstärkung in v2.1.113:¹⁵⁷

• sandbox.network.deniedDomains blockiert bestimmte Hosts, selbst wenn ein umfassenderer allowedDomains-Wildcard sie ansonsten zulassen würde. Verwenden Sie die Blockliste, um Pastebins, File-Drops oder bekannte schädliche Hosts abzuschneiden, ohne Ihre gesamte Allow-Policy umzuschreiben.
• Deny-Regeln für Wrapper-Befehle. Bash-Deny-Regeln greifen jetzt auch bei Befehlen, die in env, sudo, watch, ionice, setsid und ähnliche Exec-Wrapper eingebettet sind. Regeln wie Bash(rm:*) erfassen nun auch env rm -rf, sudo rm -rf und ähnliche Umgehungsmuster.
• Allow-Regeln Bash(find:*) genehmigen find -exec oder find -delete nicht mehr automatisch. Diese Flags führen Befehle aus und löschen Dateien, deshalb leitet Claude Code sie über den normalen Berechtigungspfad.
• macOS-Löschschutz. Allow-Regeln Bash(rm:*) behandeln nun /private/etc, /private/var, /private/tmp und /private/home als gefährliche Löschziele. /var, /etc und /tmp sind Symlinks in /private/, weshalb die bisherige Regelform die kanonischen Ziele verfehlte.

Wie funktionieren Hooks?

Hooks führen deterministische Shell-Befehle an bestimmten Punkten im Workflow von Claude Code aus. Anders als wenn man Claude über Prompts dazu auffordert, Aktionen auszuführen, garantieren Hooks die Ausführung unabhängig vom Modellverhalten. Sie sind unverzichtbar, um Team-Standards durchzusetzen und repetitive Aufgaben zu automatisieren. Siehe Decision Frameworks für den Entscheidungsbaum „Welcher Hook-Typ?”, der Command-, Prompt- und Agent-Hooks abdeckt.

Warum Hooks statt Prompts: Claude anzuweisen „führe nach dem Bearbeiten von Dateien immer Prettier aus” funktioniert manchmal. Aber Claude könnte es vergessen, Geschwindigkeit priorisieren oder entscheiden, dass die Änderung „zu klein” sei. Hooks garantieren die Ausführung: Jedes Edit oder Write löst Ihren Formatter aus, jedes Mal, ohne Ausnahme. Für Compliance, Sicherheit und Team-Standards schlägt Determinismus die 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"
          }
        ]
      }
    ]
  }
}

Matchers

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-Eingabe-/Ausgabe-Protokoll

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 aus einem Subagent oder einer --agent-Session 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, das den finalen Antworttext von Claude enthält, sodass Hooks die Ausgabe inspizieren können, ohne Transcript-Dateien zu parsen:

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

Exit-Codes steuern das Verhalten: - 0: Erfolg: Operation wird fortgesetzt. Stdout wird im Verbose-Modus angezeigt (Ctrl+O). Bei UserPromptSubmit und SessionStart wird stdout dem Kontext hinzugefügt. - 2: Blockierender Fehler: Operation stoppt. Stderr wird zur Fehlermeldung, die an Claude zurückgegeben wird. - 1, 3, etc.: Nicht-blockierender Fehler: Operation wird fortgesetzt. Stderr wird im Verbose-Modus als Warnung 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 reichhaltigere Steuerung: drei Ergebnisse (allow/deny/ask) plus die Möglichkeit, Tool-Input 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, etc.) nutzen weiterhin das Top-Level-decision.⁹⁶

UserPromptSubmit Session-Titel (v2.1.94+): UserPromptSubmit-Hooks können den Session-Titel über hookSpecificOutput.sessionTitle setzen.¹⁴⁷

Async Hooks (Januar 2026)

Hooks können jetzt im Hintergrund laufen, 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 Async-Hooks verwendet werden sollten: - Benachrichtigungen (Slack, E-Mail, Pushover), die die Session nicht verlangsamen sollen - Logging und Telemetrie, die im Hintergrund laufen können - Nicht-kritische Nachverarbeitung (Analytik, Backups)

Wann Async-Hooks NICHT verwendet werden sollten: - Formatierung (muss vor der nächsten Bearbeitung abgeschlossen sein) - Validierung (muss bei Fehler blockieren) - Jeder Hook, der Tool-Input/-Output modifizieren muss

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

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

Prompt-Hooks (type: "prompt") senden einen Single-Turn-Prompt an ein schnelles Claude-Modell. Das Modell gibt { "ok": true } zum Erlauben 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 (geben JSON mit decision und reason zurück). 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 das Inspizieren tatsächlicher Dateien oder Test-Outputs 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 ist das schnelle Modell) und timeout. Unterstützte Events: PreToolUse, PostToolUse, PostToolUseFailure, PermissionRequest, UserPromptSubmit, Stop, SubagentStop, TaskCompleted. TeammateIdle unterstützt keine Prompt-/Agent-Hooks.

MCP Tool-Hooks (v2.1.118+)

Hooks können nun ein MCP-Tool direkt über type: "mcp_tool" aufrufen und umgehen damit die Notwendigkeit, einen Bash-Subprozess zu wrappen, der den Server aufruft.¹⁵⁹

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "mcp_tool",
            "server": "linear",
            "tool": "create_comment",
            "input": {"issue_id": "ENG-123", "body": "Auto-updated by Claude Code"}
          }
        ]
      }
    ]
  }
}

Dies passt gut zu den MCP-Servern, die Benutzer bereits konfiguriert haben: Jedes von /mcp erreichbare Tool wird hook-aufrufbar.

duration_ms in PostToolUse-Hooks (v2.1.119+)

PostToolUse- und PostToolUseFailure-Hook-Eingaben enthalten jetzt duration_ms, die Ausführungszeit des Tools ohne Berechtigungsanfragen und PreToolUse-Hooks.¹⁵⁹ Nützlich für die Erkennung langsamer Tools, Audit-Logs und Pro-Tool-Latenzmetriken:

# Stderr-flagged warning when an Edit takes more than 10 seconds
DUR=$(jq -r '.duration_ms')
if [ "$DUR" -gt 10000 ]; then
  echo "[slow-edit] ${DUR}ms — investigate $TOOL_INPUT_FILE_PATH" >&2
fi

updatedToolOutput für alle Tools (v2.1.121+)

In v2.1.118 erhielten MCP Tool-Hooks die Möglichkeit, Tool-Output über hookSpecificOutput.updatedToolOutput zu ersetzen. Ab v2.1.121 funktioniert dasselbe Feld für jeden PostToolUse-Hook — eingebaute Tools (Bash, Read, Edit, Glob, Grep, etc.), Subagent-Tools und MCP-Tools. Anwendungsfälle: Redigieren sensibler Inhalte aus dem Output jedes Tools, Normalisieren der Struktur für nachgelagerte Konsumenten, Injizieren von Metadaten, bevor der Agent das Ergebnis liest.¹⁶¹

Hook-Umgebungsvariablen

Hooks haben Zugriff auf Umgebungsvariablen zum Auflösen von Pfaden:⁹⁶

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 Exfiltration beliebiger Umgebungsvariablen über Header-Werte. HTTP-Hooks werden außerdem über den Sandbox-Netzwerk-Proxy geleitet, wenn Sandboxing aktiviert ist, wodurch die Domain-Allowlist durchgesetzt wird. 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 eine Workspace-Trust-Akzeptanz vor der Ausführung im interaktiven Modus, wodurch ein potenzieller Sicherheitsvektor geschlossen wird.¹⁰⁵

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 untersuchen:

claude --debug

Der Debug-Modus protokolliert: - Hook-Ausführungszeiten - Eingabe-/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 (Settings, Plugin oder Skill) an, was die Identifizierung erleichtert, welche Komponente Zugriff anfordert.¹²⁴

Komponenten-bezogene Hooks (v2.1.0+)

Hooks können direkt in Skills, Subagents und Slash-Commands ü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 Skills und Slash-Commands) stellt sicher, dass der Hook nur einmal pro Session ausgeführt wird, was nützlich für Aufräum- oder Finalisierungsaufgaben ist.

Strategie für lang laufende Sessions

Für nächtliche oder unbeaufsichtigte Claude Code-Sessions konfigurieren Sie Hooks, um Claude ohne manuelles Eingreifen auf Kurs zu halten. Die zentrale Erkenntnis: Verwenden Sie Linting- und Test-Hooks als Schutzplanken, die Claude zwingen, Probleme vor dem Fortfahren zu beheben.⁶⁴

Das Muster „Nicht stoppen, bis Tests bestehen”:

{
  "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 nächtliche Sessions:

1. Pre-Flight-Check: 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 überprüfen alle Akzeptanzkriterien, bevor Claude „fertig” deklariert
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 nächtliche Läufe. Claude wird weiter iterieren, bis die Tests bestehen oder die Optionen erschö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 explodiert: MCP verzeichnet inzwischen 100 Millionen monatliche Downloads und über 3.000 Server sind auf MCP.so indexiert (Januar 2026), womit es seine Position als Industriestandard für die Anbindung von KI an Tools und Daten gefestigt hat.³⁵⁴ Das Verständnis von MCP ist unerlässlich, 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 verwendet — alles über natürlichsprachliche Anfragen. Das Protokoll standardisiert, wie KI-Tools sich mit externen Diensten verbinden, und verhindert so Vendor-Lock-in. Siehe Decision Frameworks für Hinweise dazu, wann MCP im Vergleich zu anderen Erweiterungsmechanismen einzusetzen ist.

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

SDK mcp_authenticate redirectUri (v2.1.121+): Die mcp_authenticate-Funktion des Agent SDK akzeptiert einen redirectUri-Parameter zum Abschließen von OAuth über benutzerdefinierte URI-Schemata — erforderlich für Desktop-Anwendungen und claude.ai-Connector-Flows, die den Standard-Loopback-Redirect nicht verwenden können.¹⁶¹

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

Claude Code kann jetzt MCP-Connectors verwenden, die in Ihrem claude.ai-Konto konfiguriert sind. Dies schlägt eine Brücke zwischen Web und CLI: MCP-Server, die Sie über die claude.ai-Oberfläche eingerichtet haben, sind in Claude Code automatisch verfügbar, ohne dass sie lokal neu konfiguriert werden müssen.¹⁰²

Deaktivieren: Setzen Sie ENABLE_CLAUDEAI_MCP_SERVERS=false in Ihrer Umgebung oder im env-Block der settings.json, um zu verhindern, dass claude.ai-MCP-Server geladen werden.¹¹¹

MCP-Tool-Suche (v2.1.7+)

Mit zunehmender Leistungsfähigkeit von MCP-Servern (einige stellen mehr als 50 Tools bereit) begannen Tool-Beschreibungen, übermäßig viel Kontext zu verbrauchen. MCP-Tool-Suche löst dies, indem Tool-Beschreibungen dynamisch nur bei Bedarf geladen werden — eine Form von Lazy Loading für KI-Tools.⁵⁴

Auswirkungen auf die Leistung: Interne Benchmarks zeigen drastische Verbesserungen bei der Genauigkeit: - Opus 4: 49 % → 74 % bei MCP-Evaluierungen - Opus 4.5: 79,5 % → 88,1 % bei MCP-Evaluierungen - Reduktion des Token-Overheads: 85 %

Funktionsweise: Wenn die Tool-Beschreibungen von MCP 10 % des Kontextfensters überschreiten (Standardschwelle), verschiebt Claude Code das Laden vollständiger Beschreibungen, bis sie tatsächlich benötigt werden. Claude sieht Tool-Namen, ruft Beschreibungen jedoch bedarfsgesteuert ab.

Konfiguration:

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

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

Expertentipp: Mit aktivierter Tool-Suche können Sie sich mit deutlich mehr MCP-Servern verbinden, ohne sich um Kontextgrenzen sorgen zu müssen. Die Kontextreduktion von 95 % bedeutet, dass Server, die zuvor um Kontext konkurrierten, nun friedlich nebeneinander existieren.

MCP-Always-Load-Override (v2.1.121+)

Die Tool-Suche verzögert das Laden vollständiger Beschreibungen, bis ein Tool benötigt wird (Schwelle: mcpToolSearchAutoEnable, Standard auto:10). Für vertrauenswürdige Server, deren Tools Sie voraussichtlich in jedem Turn verwenden, deaktivieren Sie dies pro Server mit alwaysLoad: true — jedes Tool dieses Servers wird zu Sitzungsbeginn in den Prompt geladen, ohne ToolSearch-Round-Trip:¹⁶¹

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "alwaysLoad": true
    }
  }
}

MCP-Startup-Auto-Retry (v2.1.121+): Ein Server, der beim Start einen Fehler verursacht, wird jetzt bis zu dreimal erneut versucht, bevor er als getrennt markiert wird — nützlich für stdio-Server, die mit einem langsamen Elternprozess konkurrieren, oder für HTTP-Server hinter einem kalt startenden Backend.¹⁶¹

MCP-Elicitation (v2.1.76+)

MCP-Server können nun während einer Aufgabe strukturierte Eingaben vom Benutzer über interaktive Dialoge 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-Ereignisse — Elicitation (vor dem Erscheinen des Dialogs) 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, in denen Eingabeaufforderungen von MCP-Servern vorausgefüllt oder durch Richtlinien eingeschränkt werden.

MCP-Result-Size-Override (v2.1.91+)

MCP-Tool-Ergebnisse werden standardmäßig gekürzt. Server können dies pro Ergebnis über die Annotation _meta["anthropic/maxResultSizeChars"] überschreiben und so bis zu 500.000 Zeichen zulassen.¹⁴³ Dies ist nützlich, um große Nutzdaten wie Datenbankschemata, API-Antworten oder Dateiinhalte ohne Kürzung zurückzugeben.

Interaktiver MCP-Setup-Assistent

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 funktional):

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

Windows erfordert für stdio einen cmd-Wrapper:

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

Scope-Verwaltung

MCP-Server existieren in drei Geltungsbereichen mit klarer Rangfolge (Local überschreibt Project, Project überschreibt User):

Geben Sie den Scope während der Installation an:

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} und optionalen Standardwerten ${VAR:-default} expandiert.

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

MCP-Ressourcen und -Prompts verwenden

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 vermeiden: - Warnschwelle: 10.000 Token - Standardmaximum: 25.000 Token

Bei Bedarf erhöhen:

export MAX_MCP_OUTPUT_TOKENS=50000

Beliebte MCP-Server

Praktische MCP-Patterns

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?