Kurzfassung: Claude Code ist ein agentisches CLI, das Ihre Codebasis liest, Befehle ausführt und Dateien über ein mehrschichtiges System aus Berechtigungen, Hooks, MCP-Integrationen und Subagents modifiziert. Beherrschen Sie fünf Kernsysteme (Konfiguration, Berechtigungen, Hooks, MCP und Subagents) und Sie erschließen sich eine vervielfachende Produktivität. Wählen Sie die Modellstufe, die zur jeweiligen Aufgabe passt — Opus für komplexes Reasoning, Sonnet für allgemeine Arbeiten, 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 in die tatsächliche Arbeitsweise von Entwicklern integriert. Stand Februar 2026 werden 4 % der öffentlichen GitHub-Commits (~135.000 pro Tag) von Claude Code erstellt — ein Wachstum um den Faktor 42.896 in 13 Monaten seit der Research Preview — und 90 % des eigenen Codes von Anthropic sind KI-geschrieben.¹¹⁰

Der Unterschied zwischen gelegentlicher und effektiver Nutzung von Claude Code liegt in fünf Kernsystemen. Beherrschen Sie diese, und Claude Code wird zum Kraftmultiplikator:

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

Wichtigste Erkenntnisse

• Fünf Systeme bestimmen Ihre Effektivität: Konfigurationshierarchie, Berechtigungen, Hooks, MCP und Subagents steuern alles von Verhalten bis Automatisierung.
• Verlagern Sie Arbeit auf die Delegationsschicht: Subagents verhindern Kontextüberladung, indem sie Exploration in sauberen Kontextfenstern isolieren und nur Zusammenfassungen zurückgeben.
• Hooks garantieren die Ausführung; Prompts nicht: Verwenden Sie Hooks für Linting, Formatierung und Sicherheitsprüfungen, die jedes Mal ausgeführt werden müssen — unabhängig vom Modellverhalten.
• Modellstufung 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 Lesen von Dateien und Bash-Befehle hinaus.

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

So verwenden Sie diesen Leitfaden

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

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

Wie Claude Code funktioniert: Das mentale Modell

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

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

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

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

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

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

Inhaltsverzeichnis

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

Wie installiere ich Claude Code?

Systemanforderungen

Claude Code läuft auf macOS 10.15+, Ubuntu 20.04+/Debian 10+ und Windows 10+ über WSL oder Git Bash. Das System erfordert 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, wenn Sie natives Windows bevorzugen. Alpine Linux und andere musl-basierte Systeme erfordern zusätzliche Pakete:

apk add libgcc libstdc++ ripgrep
export USE_BUILTIN_RIPGREP=0

Installationsmethoden

Native Installation (empfohlen)

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

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

# Homebrew alternative
brew install --cask claude-code

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

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

Für versionsspezifische Installation:

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

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

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

NPM-Installation (veraltet)

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

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

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

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

Migration von bestehender Installation

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

claude install

Authentifizierungsoptionen

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

Claude Console (API-Abrechnung)

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

Claude Pro- oder Max-Abonnement

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

Enterprise-Plattformen

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

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

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

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

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

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

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

Überprüfung

claude doctor

Der Befehl meldet Installationstyp, Version, 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 behebe ich Probleme? zur Fehlerbehebung bei Authentifizierungsproblemen.

Aktualisierungen

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

Automatische Aktualisierungen deaktivieren:

export DISABLE_AUTOUPDATER=1

Oder in settings.json:

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

Manuelle Aktualisierung:

claude update

Deinstallation

Native Installation (macOS/Linux/WSL):

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

Native Installation (Windows PowerShell):

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

Konfiguration bereinigen (entfernt alle Einstellungen):

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

Schnellstart: Ihre erste Sitzung

1. Installieren und starten:

claude                           # Launch in current directory

2. Zu einem Projekt navigieren:

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

3. Claude eine Aufgabe stellen:

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

4. Tastenkürzel während der Sitzung verwenden:

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

5. Später fortfahren:

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

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

Zentrale Interaktionsmodi

Interaktiver REPL

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

cd your-project
claude

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

Beginnen Sie mit einem initialen Prompt, um die Sitzung gezielt auszurichten:

claude "explain the authentication flow in this project"

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

Nicht-interaktiver Modus

Der Print-Modus (-p) führt eine einzelne Abfrage 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

Ausgabeformat-Optionen:

Exit-Codes:

Steuerung des agentischen Verhaltens im -p-Modus:

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

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

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

CI/CD-Integrationsmuster:

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

Sitzungsverwaltung

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

# Continue most recent session
claude -c

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

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

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

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

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

Sitzungen werden auch automatisch mit PRs verknüpft, wenn Sie diese während einer Sitzung über gh pr create erstellen. So lässt sich die Arbeit an einem bestimmten PR später einfach fortsetzen.

Benannte Sitzungen (Dez. 2025): Benennen und verwalten Sie Sitzungen für einfachen Zugriff:

# 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 Agenten-Ausführung weist eindeutige agentId-Werte zu, wobei Transkripte als agent-{agentId}.jsonl gespeichert werden. Das Fortsetzen bewahrt den vollständigen Kontext aus vorherigen Gesprächen.

Plan-Modus

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

Plan-Modus aktivieren:

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

# Or 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 schreibgeschützten Tools: Read, Glob, Grep, WebSearch, WebFetch
3. Schreibt einen Plan in .claude/plans/{session-slug}.md
4. Verlässt den Plan-Modus mit ExitPlanMode und präsentiert den Plan zur Überprüfung
5. Sie genehmigen, fordern Änderungen an oder lehnen ab

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

Nach der 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 Genehmigung aus

Kontext bei Genehmigung automatisch leeren ist der empfohlene Workflow. Es gibt dem Plan ein frisches Kontextfenster, was die Plantreue deutlich verbessert — Claude bleibt länger auf Kurs, ohne dass alte Gesprächsinhalte stören.

Wann Sie den Plan-Modus verwenden sollten: - Neue Feature-Implementierungen mit architektonischen Entscheidungen - Dateiübergreifende Refactorings, bei denen Sie den Ansatz vorab prüfen möchten - Unbekannte Codebasen, bei denen Erkundung der Bearbeitung vorausgehen sollte - Jede Aufgabe, bei der mehrere valide Ansätze existieren und Sie Input wünschen

Expertentipp: Je mehr Zeit Sie im Plan-Modus verbringen, desto wahrscheinlicher wird Claude bei der Implementierung erfolgreich sein. Der Plan-Modus ist im Grunde kostenlose 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 niedrigere überschreiben und Enterprise-Einstellungen überhaupt nicht umgangen werden können.

Konfigurationshierarchie

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

Vollständige settings.json-Referenz

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

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

Referenz der Umgebungsvariablen

Authentifizierung und API:

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

Modellkonfiguration:

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

Cloud-Anbieter-Konfiguration:

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

Verhaltenssteuerung:

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

Tool-Konfiguration:

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

Netzwerk und Proxy:

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

Benutzeroberfläche und Terminal:

CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1            # Don't update terminal title
CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL=1             # Skip IDE extension install
CLAUDE_CODE_SHELL=/bin/zsh                      # Override shell detection
USE_BUILTIN_RIPGREP=1                           # Use included ripgrep (default)
CLAUDE_CONFIG_DIR=~/.myconfig                   # Custom config directory
IS_DEMO=1                                       # Hide sensitive UI elements[^37]
CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1          # Disable background tasks and Ctrl+B[^46]
CLAUDE_CODE_TMPDIR=/path/to/tmp                 # Override temp directory[^50]
CLAUDE_CODE_DISABLE_1M_CONTEXT=1               # Disable 1M context window (use standard 200K)[^103]
CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS=120000       # Plugin marketplace git timeout (default 120s, was 30s)[^105]

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

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

Debugging:

ANTHROPIC_LOG=debug                             # Enable API request logging

Welches Modell sollte ich wählen?

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

Verfügbare Modelle

Opus 4.6 (5. Februar 2026): Das neueste Flaggschiff-Modell mit 1M-Token-Kontextfenster (Beta), 128K maximaler Ausgabe, adaptivem Thinking und Agent Teams.⁸⁶ Gleiche Preise wie Opus 4.5 ($5/$25 pro MTok). Long Context (>200K Input) kostet $10/$37,50 pro MTok. Modell-ID: claude-opus-4-6.¹

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

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

Wann welches Modell verwenden

Haiku: Verwenden Sie es für Subagents, die Exploration durchführen, einfache Dateisuchen und schnelle Fragen. Es ist ~5x 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. Bewältigt die meisten Coding-Aufgaben gut: Funktionen implementieren, Bugs beheben, Tests schreiben, Code Review. Verwenden Sie es als Ihren Standard. Sonnet 4.6 (Februar 2026) bietet verbesserte agentische Suche und bessere Token-Effizienz im Vergleich zu Sonnet 4.5, mit Unterstützung für adaptives Thinking und das 1M-Kontextfenster-Beta.¹⁰⁰

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

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

Modelle wechseln

Während der Sitzung:

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

Beim Start:

claude --model opus

Über Umgebungsvariable:

export ANTHROPIC_MODEL=opus

In settings.json:

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

Speziell für Subagents:

export CLAUDE_CODE_SUBAGENT_MODEL=haiku

Erweiterter Kontext

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

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

Oder innerhalb einer Sitzung:

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

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

Erweiterter Kontext kostet mehr pro Token (2x Input, 1,5x Output bei >200K Input-Tokens). Verwenden Sie ihn, wenn Sie ihn tatsächlich brauchen – nicht als Standard.

Aktuelles Modell überprüfen

> /status

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

Modellauswahl-Labels (v2.1.51+): Die /model-Auswahl zeigt jetzt lesbare Labels (z. B. „Sonnet 4.6”) anstelle roher Modell-IDs für festgelegte Versionen an, mit Upgrade-Hinweisen, wenn neuere Versionen verfügbar sind.¹⁰⁵

Fast Mode (v2.1.36+)

Fast Mode bietet deutlich schnellere Ausgabe mit demselben Modell – es wird nicht auf ein günstigeres Modell gewechselt. Schalten Sie ihn während einer Sitzung mit /fast um.⁹³

> /fast            # Toggle fast mode on/off

Preise (Opus 4.6 Fast Mode):

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

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

Wann Fast Mode NICHT verwenden: - Lang laufende agentische Aufgaben (Kosten summieren sich schnell bei 6x-Tarifen) - Hintergrund-Subagent-Arbeit (niemand wartet auf die Ausgabe) - Budgetbewusste Sitzungen

Opus 4.6 Fast Mode umfasst jetzt das volle 1M-Kontextfenster (v2.1.50+). Zuvor war Fast Mode auf den Standard-Kontext beschränkt; jetzt erhalten Sie dieselbe 1M-Token-Kapazität mit Fast-Mode-Geschwindigkeit.¹⁰³

Expertentipp: Fast Mode eignet sich gut in Kombination mit dem opusplan-Hybridmodus: Verwenden Sie Fast Mode während der Sonnet-Ausführungsphase für schnelle Iteration, während Sie Standardtarife für die Opus-Planung beibehalten. Beachten Sie, dass /fast erfordert, dass /extra-usage zuerst aktiviert ist (v2.1.37 Fix).⁹³

Was kostet Claude Code?

Das Verständnis und die Kontrolle der Kosten sind entscheidend für eine nachhaltige Nutzung von Claude Code. Siehe auch Modellauswahl für Modellfähigkeiten und Entscheidungsrahmen für die Wahl 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

Abonnement-Pläne

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

API-Token-Preise (Februar 2026)¹⁸⁶

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

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

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

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

Prompt Caching reduziert die Kosten für wiederholte Eingaben erheblich: Cache-Schreibvorgänge kosten das 1,25-Fache des Basispreises (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 für mehrere Konten⁵⁹

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

Was erlaubt ist:

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

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

Praxishinweis: Im Januar 2026 wurden die 22 Max-Konten des Power-Users Jeffrey Emanuel (@doodlestein) automatisch markiert und vorübergehend gesperrt. Anthropic-Mitarbeiter Thariq (@trq212) löste das Problem innerhalb von 4 Stunden nach Bestätigung der legitimen Nutzung. Wenn Sie Claude Code intensiv sowohl für berufliche als auch private Projekte über mehrere Konten nutzen, ist das genau das, wofür der Dienst konzipiert ist – versuchen Sie jedoch nicht, das System auszutricksen.

Im Zweifelsfall: Kontaktieren Sie den Anthropic-Support, um Ihre spezifische Konfiguration schriftlich bestätigen zu lassen.

Kostenfaktoren

Praxisbeispiele für Kosten

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

Team-Kostenmanagement

Empfohlene TPM/RPM nach Teamgröße:

Versteckte Tool-Gebühren

Über die Token-Preise hinaus verursachen einige Tools separate Gebühren:¹⁶

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

Strategien zur Kostensenkung

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

Nutzung überwachen

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

Token-Verbrauch im Hintergrund

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

Typischerweise unter $0,04 pro Sitzung.

Claude Code Analytics API (Team/Enterprise)⁵³

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

Endpunkt: GET /v1/organizations/usage_report/claude_code

Voraussetzungen: - Admin-API-Schlüssel (sk-ant-admin...) - Team- oder Enterprise-Plan - 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) - Metriken zur Tool-Nutzung (Akzeptanz-/Ablehnungsraten für Edit, Write usw.) - Kostenverfolgung und -zuordnung über Teams hinweg - ROI-Begründung für KI-Programmier-Tools

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

Entscheidungsrahmen

Funktionen zu kennen reicht nicht aus. Sie müssen wissen, wann Sie welche einsetzen. Diese Entscheidungsbäume verwandeln Wissen in Handlung.

Welches Modell sollte ich verwenden?

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

Faustregel: Beginnen Sie mit Sonnet. Wechseln Sie zu Haiku für Subagents. Eskalieren Sie nur dann zu Opus 4.6, wenn 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?

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

Hook vs Prompt?

Muss die Aktion IMMER ausgeführt werden, unabhängig von Claudes Einschätzung?
│
├── JA → Verwenden Sie Hook (deterministisch)
│         Beispiele:
│         - Code nach jeder Bearbeitung formatieren
│         - Alle Bash-Befehle protokollieren
│         - Zugriff auf .env-Dateien blockieren
│         Claude kann es nicht überspringen, vergessen oder anders entscheiden.
│
└── NEIN → Verwenden Sie Prompt (probabilistisch)
         Beispiele:
         - „Tests hinzufügen erwägen"
         - „An Grenzfälle denken"
         - „Bei Relevanz auf Sicherheit prüfen"
         Claude entscheidet basierend auf dem Kontext.

Wann Extended Thinking verwenden?

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

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

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

Welche Ausführungsumgebung?

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

Agent Teams vs Subagents vs Parallele Sitzungen

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

Welcher Hook-Typ?

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

Wann /fast verwenden?

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

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

Wie funktioniert das Berechtigungssystem?

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

Berechtigungsstufen

Nur-Lese-Tools (automatisch genehmigt): - Read – Dateiinhalte lesen - Glob – Dateien nach Muster suchen - Grep – Dateiinhalte durchsuchen - WebSearch – Im Web suchen - LSP – Code-Intelligenz (Go-to-Definition, Referenzen finden, Hover-Dokumentation)²⁵

Funktionen des LSP-Tools (ab v2.0.74): Das LSP-Tool bietet IDE-ähnliche Code-Intelligenz: - Go-to-Definition: Zur Stelle springen, an der ein Symbol definiert ist - Referenzen finden: Alle Verwendungen eines Symbols im gesamten Codebase auflisten - Hover-Dokumentation: Typinformationen und Dokumentation für jedes Symbol abrufen - Funktioniert mit TypeScript, Python, Go, Rust und anderen Sprachen mit LSP-Unterstützung - Erfordert einen verfügbaren Language Server (wird üblicherweise mit Ihrer Toolchain installiert)

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

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

Berechtigungsmodi

YOLO-Modus (ab v2.0.68): Für vollständig autonomen Betrieb verwenden Sie das Flag --dangerously-skip-permissions. Dieses Flag bestätigt alles automatisch: Dateibearbeitungen, Bash-Befehle, alle Tool-Aufrufe. Das Wort „dangerous” ist bewusst gewählt. Verwenden Sie es nur in isolierten Umgebungen oder wenn Sie dem Codebase vollständig vertrauen.⁶¹

claude --dangerously-skip-permissions

Modus per CLI festlegen:

claude --permission-mode acceptEdits

Während einer Sitzung umschalten:

Shift+Tab  # Wechselt durch die Modi

In settings.json:

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

Syntax der Berechtigungsregeln

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

Bash-Befehlsmuster:

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

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

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

Dateioperations-Muster:

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

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

MCP-Tool-Muster:

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

Verwenden Sie die Wildcard-Syntax mcp__server__*, um alle Tools eines bestimmten MCP-Servers zu erlauben oder zu verbieten.³⁹ Die Wildcard-Syntax ist nützlich, um schnell alle Tools vertrauenswürdiger Server 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 unerlässlich für Monorepos oder wenn Claude auf Code in benachbarten Verzeichnissen zugreifen muss.

Sandbox-Modus

Aktivieren Sie die Dateisystem- und Netzwerkisolierung:

> /sandbox

Oder konfigurieren Sie es in den Einstellungen:

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

Im Sandbox-Modus: - Dateisystemzugriff auf das Projektverzeichnis beschränkt - Netzwerkzugriff kontrolliert - Bestimmte Befehle von den Sandbox-Einschränkungen ausgenommen - Bash-Befehle automatisch genehmigt, wenn autoAllowBashIfSandboxed auf „true” gesetzt ist

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

Sicherheitshinweise (ab v2.1.34): Befehle, die über sandbox.excludedCommands oder dangerouslyDisableSandbox von der Sandbox ausgenommen waren, konnten zuvor die Bash-Genehmigungsregel umgehen, wenn autoAllowBashIfSandboxed aktiviert war; dies wurde in v2.1.34 behoben.⁹⁴ Seit v2.1.38 werden Schreibzugriffe auf .claude/skills im Sandbox-Modus blockiert, um zu verhindern, dass Prompt-Injection Skill-Definitionen modifiziert.⁹⁵

Wie funktionieren Hooks?

Hooks führen deterministische Shell-Befehle an bestimmten Punkten im Workflow von Claude Code aus. Anders als wenn Sie Claude auffordern, Aktionen auszuführen, garantieren Hooks die Ausführung unabhängig vom Modellverhalten. Sie sind unverzichtbar für die Durchsetzung von Team-Standards und die Automatisierung wiederkehrender Aufgaben. Siehe Entscheidungs-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” ist. 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 ist deterministisch besser als probabilistisch.⁷

Verfügbare Events

Hook-Konfiguration

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

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

Matcher

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

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

Hook-Eingabe-/Ausgabe-Protokoll

Hooks empfangen JSON über stdin:

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

Stop/SubagentStop-Hooks (v2.1.47+) erhalten ein zusätzliches Feld last_assistant_message, das den endgültigen Antworttext von Claude enthält, sodass Hooks die Ausgabe überprüfen können, ohne Transkriptdateien 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: Die Operation wird fortgesetzt. Stdout wird im Verbose-Modus angezeigt (Ctrl+O). Bei UserPromptSubmit und SessionStart wird Stdout zum Kontext hinzugefügt. - 2: Blockierender Fehler: Die Operation wird gestoppt. Stderr wird zur Fehlermeldung, die an Claude zurückgegeben wird. - 1, 3, usw.: Nicht-blockierender Fehler: Die Operation wird fortgesetzt. Stderr wird als Warnung im Verbose-Modus angezeigt.

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

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

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

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

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

Asynchrone 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 Sie asynchrone Hooks verwenden sollten: - Benachrichtigungen (Slack, E-Mail, Pushover), die die Sitzung nicht verlangsamen sollen - Logging und Telemetrie, die im Hintergrund laufen können - Nicht-kritische Nachbearbeitung (Analysen, Backups)

Wann Sie asynchrone Hooks NICHT verwenden sollten: - Formatierung (muss vor der nächsten Bearbeitung abgeschlossen sein) - Validierung (muss bei Fehler blockieren) - Jeder Hook, der Tool-Eingaben/-Ausgaben 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 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-Anfrage an eine URL und erhalten JSON zurück. Verwenden Sie diese für Webhooks, externe Benachrichtigungsdienste oder API-basierte Validierung (v2.1.63+):¹¹¹

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

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

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

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

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

Hook-Umgebungsvariablen

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

Umgebungsvariablen aus SessionStart persistieren:

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

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

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

Hook-Workspace-Vertrauen (v2.1.51+): statusLine- und fileSuggestion-Hook-Befehle erfordern jetzt im interaktiven Modus die Annahme des Workspace-Vertrauens vor der Ausführung, was einen potenziellen Sicherheitsvektor schließt.¹⁰⁵

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

claude --debug

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

Komponentenbezogene 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 für Skills und Slash-Commands) stellt sicher, dass der Hook nur einmal pro Sitzung ausgeführt wird, was nützlich für Bereinigungs- oder Abschlussaufgaben ist.

Strategie für langlaufende Sitzungen

Für nächtliche oder unbeaufsichtigte Claude Code-Sitzungen konfigurieren Sie Hooks, die Claude ohne manuelles Eingreifen auf Kurs halten. Die zentrale Erkenntnis: Verwenden Sie Linting- und Test-Hooks als Leitplanken, die Claude zwingen, Probleme zu beheben, bevor es fortfährt.⁶⁴

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

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

Strategie für nächtliche Sitzungen:

1. Pre-Flight-Check: Verwenden Sie einen Setup-Hook, um sicherzustellen, 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 sich als „fertig” erklärt
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 sandboxed Container für vollständig autonome nächtliche Durchläufe. Claude wird weiter iterieren, bis die Tests bestehen oder alle Optionen erschöpft sind.

Was ist MCP (Model Context Protocol)?

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

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 eine Anbieterabhängigkeit. Siehe Entscheidungsrahmen für Hinweise, wann Sie MCP im Vergleich zu anderen Erweiterungsmechanismen einsetzen sollten.

Remote-MCP-Unterstützung (Juni 2025)

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

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

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

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

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

MCP Tool Search (v2.1.7+)

Mit wachsendem Funktionsumfang der MCP-Server (manche stellen über 50 Tools bereit) begannen Tool-Beschreibungen übermäßig viel Kontext zu verbrauchen. MCP Tool Search löst dieses Problem, indem Tool-Beschreibungen nur bei Bedarf dynamisch geladen werden – eine Form des Lazy Loading für KI-Tools.⁵⁴

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

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

Konfiguration:

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

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

Expertentipp: Mit aktiviertem Tool Search können Sie deutlich mehr MCP-Server verbinden, ohne sich um Kontextlimits sorgen zu müssen. Die 95-prozentige Kontextreduzierung ermöglicht es Servern, die zuvor um Kontext konkurrierten, problemlos nebeneinander zu existieren.

Interaktiver MCP-Einrichtungsassistent

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

Transporttypen

HTTP (empfohlen für Remote-Server):

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

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

SSE (veraltet, aber funktionsfähig):

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

Stdio (lokale Server):

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

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

Windows erfordert einen cmd-Wrapper für Stdio:

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

Geltungsbereich-Verwaltung

MCP-Server existieren in drei Geltungsbereichen mit klarer Priorität (Lokal überschreibt Projekt, Projekt überschreibt Benutzer):

Geltungsbereich bei der Installation angeben:

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

Format der Konfigurationsdatei

Die Datei .mcp.json definiert Server auf Projektebene:

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

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

MCP-Verwaltungsbefehle

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

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

OAuth-Authentifizierung

Für Server, die OAuth erfordern:

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

Verwendung von MCP-Ressourcen und Prompts

Ressourcen referenzieren:

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

MCP-Prompts als Slash-Befehle:

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

Ausgabelimits

Claude Code begrenzt die MCP-Ausgabe, um ein Überlaufen des Kontexts zu verhindern: - Warnschwelle: 10.000 Token - Standardmaximum: 25.000 Token

Bei Bedarf erhöhen:

export MAX_MCP_OUTPUT_TOKENS=50000

Beliebte MCP-Server

Praktische MCP-Muster

GitHub-Workflow:

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

Datenbankabfragen:

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

Fehlerüberwachung:

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

MCP-Konfiguration für Unternehmen

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

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

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

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

MCP Apps (Januar 2026)

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

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

Anthropic hat v2 des Code Execution Tool in der öffentlichen Beta veröffentlicht, das die ursprüngliche reine Python-Sandbox durch Bash-Befehlsausführung und direkte Dateimanipulation ersetzt.⁷⁹ Wesentliche Änderungen: - Bash-Befehle (nicht nur Python) in Sandbox-Containern ausführen - Code in jeder Programmiersprache schreiben und ausführen - Programmatischer Tool-Aufruf (ebenfalls öffentliche Beta): Claude kann Tools aus der Codeausführung heraus aufrufen, was Latenz und Token-Verbrauch in Multi-Tool-Workflows reduziert

Das v2-Tool betrifft primär API-Nutzer, zeigt aber die Richtung für die Cloud-Ausführungsfähigkeiten von Claude Code auf.

Was sind Subagents?

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

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

Wie Subagents funktionieren

Wenn Claude auf eine Aufgabe stößt, die von fokussierter Aufmerksamkeit profitiert (tiefgehende Exploration, mehrstufige Analyse, spezialisierte Arbeit), kann er einen Subagent starten. Der Subagent:

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

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

Integrierte Subagent-Typen

Explore (schnell, schreibgeschützt): - Modell: Haiku (ultraschnell) - Modus: Streng schreibgeschützt - Tools: Glob, Grep, Read und sichere Bash-Befehle (ls, git status, git log, git diff, find, cat, head, tail) - Gründlichkeitsstufen: Schnell, Mittel, Sehr gründlich - Verwendung für: Codebase-Exploration, Dateisuche, Strukturverständnis

Allzweck: - Modell: Sonnet - Modus: Vollständiger Lese-/Schreibzugriff - Tools: Alle verfügbaren Tools - Verwendung für: Komplexe Recherche- und Änderungsaufgaben

Plan: - Modell: Sonnet (oder Opus mit opusplan) - Modus: Schreibgeschützt - Tools: Read, Glob, Grep, Bash - Verwendung für: Planung komplexer Implementierungen vor der Ausführung

Subagents auslösen

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

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

> Have a subagent analyze the database schema thoroughly

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

Expertentipp: Fordern Sie bei komplexen Aufgaben explizit die Delegation an Subagents an. „Use an explore agent to find…” verhindert Kontextaufblähung in Ihrer Hauptkonversation.

Benutzerdefinierte Subagents erstellen

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

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

You are a senior security engineer reviewing code for vulnerabilities.

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

Focus on actionable security findings, not style issues.

Konfigurationsfelder:

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

CLI-definierte Subagents (v2.1.32+)

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

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

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

Subagents verwalten

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

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

claude agents                # Shows agents grouped by source (built-in, user, project, plugin)

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

claude remote-control        # Start serving local environment for external builds

Agents im Hintergrund ausführen

Für lang laufende Aufgaben:

> Run a thorough security review in the background

> /agents  # Check status of running agents

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

Fortgeschrittene Muster

Verkettete Subagents:

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

Parallele Exploration:

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

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

> Resume agent abc123 and continue the analysis

Asynchrone Subagents (Dezember 2025)

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

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

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

Resilienz bei Berechtigungsverweigerungen (v2.1.0+)

Ab v2.1.0 arbeiten Subagents nach Berechtigungsverweigerungen weiter, anstatt vollständig anzuhalten. Wenn ein Subagent auf eine Berechtigungsgrenze stößt, versucht er automatisch alternative Ansätze. Diese Änderung macht autonome Workflows widerstandsfähiger und reduziert den Bedarf an menschlichem Eingreifen.⁴⁷

Agent Teams (Februar 2026, Research Preview)

Agent Teams koordinieren mehrere Claude Code-Instanzen, die zusammenarbeiten. Eine Sitzung fungiert als Teamleiter, der Teammitglieder startet, die unabhängig in ihren eigenen Kontextfenstern arbeiten und über ein gemeinsames Postfach und eine Aufgabenliste direkt miteinander kommunizieren.⁸⁶⁹¹

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

Aktivieren:

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

Oder über Umgebungsvariable: export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

Architektur:

Anzeigemodi:

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

Tastenkombinationen: - Shift+Down: Durch Teammitglieder wechseln (In-Process-Modus; springt nach dem letzten Teammitglied zurück zum Leiter) - Shift+Tab: Delegate-Modus aktivieren (beschränkt den Leiter auf reine Koordination, keine Codeänderungen) - Ctrl+T: Gemeinsame Aufgabenliste ein-/ausblenden - Enter auf Teammitglied: Deren Sitzung anzeigen; Escape zum Unterbrechen ihres Durchlaufs

Wann Agent Teams vs. Subagents verwenden:

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

Plangenehmigung für Teammitglieder: Bei komplexen oder riskanten Aufgaben können Sie verlangen, dass Teammitglieder vor der Implementierung einen Plan erstellen. Das Teammitglied arbeitet im schreibgeschützten Planmodus, bis der Leiter den Ansatz überprüft und genehmigt:

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

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

Beispiel-Prompts:

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

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

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

Hook-Integration: Verwenden Sie TeammateIdle (Exit-Code 2, um Feedback zu senden und das Teammitglied weiterarbeiten zu lassen) und TaskCompleted (Exit-Code 2, um den Abschluss zu verhindern) Hooks, um Qualitätskontrollen für Teammitglieder durchzusetzen.

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

Agent Skills (Dezember 2025)

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

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

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

Was ist der Extended Thinking Modus?

Extended Thinking gibt Claude mehr Zeit, komplexe Probleme durchzudenken, bevor eine Antwort gegeben wird. Dies ist besonders wertvoll für Architekturentscheidungen, das Debuggen kniffliger Probleme und Aufgaben, die eine sorgfältige Analyse erfordern.

Aktueller Stand (Januar 2026)

Extended Thinking ist jetzt standardmäßig aktiviert mit einem Budget von 31.999 Token – dem maximalen Budget, das zuvor durch „ultrathink” ausgelöst wurde.⁷⁰ Anthropic hat diese Änderung vorgenommen, weil Extended Thinking die Leistung bei komplexen Planungs- und Reasoning-Aufgaben erheblich verbessert.

Wichtig: Natürlichsprachliche Auslöser wie „think”, „think hard”, „think harder” und „ultrathink” funktionieren nicht mehr. Claude interpretiert diese Schlüsselwörter jetzt als reguläre Prompt-Anweisungen und weist keine Thinking-Token zu. Das Thinking-Budget wird ausschließlich über die Umgebungsvariable MAX_THINKING_TOKENS oder über /config gesteuert.⁷⁰

Unterstützte Modelle

• Claude Opus 4.6 (unterstützt auch adaptives Thinking, das die Reasoning-Tiefe automatisch bestimmt)
• Claude Sonnet 4.6 (unterstützt ebenfalls adaptives Thinking)
• Claude Opus 4.5
• Claude Sonnet 4.5
• Claude Haiku 4.5

Extended Thinking steuern

Schnelles Umschalten während der Sitzung:

Press Alt+T to toggle thinking on/off

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

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

Umgebungsvariable (dauerhaft):

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

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

Deaktivieren zur Kostenersparnis: Für einfachere Aufgaben, bei denen tiefgehendes Reasoning nicht erforderlich ist, können Sie Kosten reduzieren, indem Sie Thinking in /config deaktivieren oder das Budget verringern:

export MAX_THINKING_TOKENS=8000  # Reduce from default 31,999

Thinking-Token-Budgets

Kostenhinweis: Anthropic berechnet Thinking-Token als Output-Token. Das Standard-Budget von 31.999 funktioniert für die meisten Aufgaben gut, aber bei einfachen Operationen können Sie Kosten sparen, indem Sie das Budget reduzieren oder Thinking vollständig deaktivieren.

Funktionsweise

Wenn Thinking aktiviert ist, führt Claude internes Reasoning durch, das die Antwort beeinflusst, aber nicht in der Ausgabe erscheint. Claude Code verschlüsselt das Thinking und gibt es in einem signature-Feld zur Verifizierung zurück.

In mehrstufigen Konversationen mit Tool-Nutzung müssen Thinking-Blöcke an die API zurückgegeben werden, um die Reasoning-Kontinuität zu bewahren. Claude Code übernimmt dies automatisch.

Wann Sie eine Reduzierung/Deaktivierung in Betracht ziehen sollten

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

Cache-Verhalten

Claude Code bewahrt das System-Prompt-Caching, wenn sich Thinking-Parameter ändern. Das Ändern des Thinking-Budgets oder des Aktivierungsstatus zwischen Turns macht das Nachrichten-Caching ungültig.

Ausgabestile

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

Integrierte Stile

Ausgabestil festlegen

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

Oder über die Einstellungen:

{
  "outputStyle": "Explanatory"
}

Benutzerdefinierte Ausgabestile

Erstellen Sie diese in .claude/styles/:

# my-style

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

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

Aufrufen mit /output-style my-style.

Slash-Befehle

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

Referenz der integrierten Befehle

Benutzerdefinierte Befehle erstellen

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

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

Review this code for security vulnerabilities:

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

Focus on actionable findings with specific line references.

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

Frontmatter-Optionen für Befehle

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

Argument-Interpolation

Alle Argumente als einzelner String:

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

Fix GitHub issue #$ARGUMENTS following our coding standards.

Verwendung: /fix-issue 123

Nummerierte Argumente:

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

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

Verwendung: /create-component Button functional

Inline-Bash-Ausführung

Führen Sie Bash-Befehle innerhalb von Befehl-Prompts aus:

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

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

Summarize the current state of this repository.

Dateireferenzen

Binden Sie Dateiinhalte in Befehle ein:

---
description: Compare implementations
---

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

Which implementation is more maintainable?

Befehls-Namespacing

Organisieren Sie Befehle in Unterverzeichnissen:

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

Befehle mit dem gleichen Namen zeigen ihren Namespace in der Hilfe an: /test (project:backend) vs /test (project:frontend).

Wie funktionieren Skills?

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

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

Der Unterschied ist wichtig. Ein Slash-Befehl ist eine Abkürzung, an deren Verwendung Sie sich erinnern. Ein Skill ist Wissen, das Claude immer zur Verfügung hat. Wenn Sie einen Skill für Sicherheitsüberprüfungen mit den spezifischen Schwachstellenmustern und Compliance-Anforderungen Ihres Teams erstellen, wendet Claude dieses Fachwissen an, wann immer er auf relevanten Code stößt – sei es bei PR-Reviews, Refactoring oder jeder Aufgabe, bei der Sicherheit eine Rolle spielt. Sie rufen nicht /security-review auf; Claude erkennt den Kontext und wendet den Skill automatisch an.

Skills vs. Befehle vs. Subagents

Das Verständnis, wann welcher Erweiterungsmechanismus einzusetzen ist, verhindert Doppelarbeit und maximiert die Effektivität:

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

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

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

Skill-Struktur und Speicherort

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

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

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

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

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

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

SKILL.md-Format

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

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

# Code Review Expertise

## Security Analysis

When reviewing code, check for:

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

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

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

## Performance Patterns

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

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

## Review Output Format

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

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

Frontmatter-Referenz

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

Das Feld description ist entscheidend. Claude erkennt Skills, indem er Ihre Anfragen mit den Skill-Beschreibungen abgleicht. Eine vage Beschreibung bedeutet, dass Claude nicht erkennt, wann der Skill eingesetzt werden soll. Eine spezifische Beschreibung mit klaren Auslösebedingungen sorgt für zuverlässige Aktivierung.

Schlechte Beschreibung:

description: Helps with code

Effektive Beschreibung:

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

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

Tool-Einschränkungen

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

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

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

Gängige Einschränkungsmuster:

Unterstützende Dateien

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

Strukturmuster:

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

Unterstützende Dateien aus SKILL.md referenzieren:

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

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

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

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

### Vollständiges Beispiel: Domänenexperten-Skill

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

**Verzeichnisstruktur:**

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

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

# Payments Domain Expertise

## Kernkonzepte

### Transaktionszustände

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

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

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

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

Kurzreferenz

Gebührenberechnungen

• Interchange: 1,5 % + 0,10 $ (Debit), 2,1 % + 0,10 $ (Credit)
• Plattformgebühr: 2,9 % + 0,30 $ (Standard), 2,2 % + 0,30 $ (Enterprise)
• International: +1 % grenzüberschreitende Gebühr
• Währungsumrechnung: Mittelkurs + 1 %

Compliance-Schwellenwerte

• 3.000 $: Auslöser für erweiterte Sorgfaltspflicht
• 10.000 $: CTR-Meldung erforderlich
• 25.000 $: Zusätzliche Verifizierung erforderlich

Erstattungsfristen

• Vollständige Erstattung: 120 Tage ab Erfassung
• Teilerstattung: 180 Tage ab Erfassung
• Chargeback-Frist: 120 Tage (Visa), 180 Tage (Mastercard)

Schlüsseldateien

• src/payments/processor.ts – Kernlogik der Zahlungsverarbeitung
• src/payments/refunds.ts – Erstattungsverarbeitung
• src/compliance/aml.ts – AML-Prüfungen
• src/models/transaction.ts – Transaktionsmodell

Siehe BUSINESS_RULES.md für detaillierte Geschäftslogik. Siehe COMPLIANCE.md für regulatorische Anforderungen. Siehe DATA_MODELS.md für Schema-Dokumentation.

Wenn diese Skill-Datei vorhanden ist, wendet Claude automatisch Zahlungsdomänen-Expertise an, wenn Sie an Transaktionscode arbeiten, nach Erstattungslogik fragen oder Zahlungsabläufe debuggen. Sie müssen nichts aufrufen – die Expertise ist einfach da.

### Effektive Skills erstellen

**Beginnen Sie mit der Beschreibung.** Schreiben Sie zuerst die Beschreibung und erstellen Sie dann den Skill-Inhalt passend dazu. Die Beschreibung bestimmt, wann Claude den Skill verwendet – formulieren Sie sie daher sorgfältig:

1. Beschreiben Sie, was der Skill bereitstellt
2. Listen Sie konkrete Auslösebedingungen auf
3. Fügen Sie relevante Schlüsselwörter und Phrasen ein

**Halten Sie Skills fokussiert.** Ein Skill deckt eine Domäne oder Fähigkeit ab:

| Gut (fokussiert) | Schlecht (zu breit) |
|------------------|---------------------|
| `security-auditor` | `code-helper` |
| `react-patterns` | `frontend-stuff` |
| `postgres-optimization` | `database-expert` |
| `api-documentation` | `docs-generator` |

Wenn ein Skill zu viel abdecken soll, wird seine Beschreibung vage und Claude erkennt nicht zuverlässig, wann er verwendet werden soll.

**Verwenden Sie progressive Offenlegung.** Platzieren Sie die wichtigsten Informationen direkt in SKILL.md. Verweisen Sie auf unterstützende Dateien für mehr Tiefe:

```markdown

## Quick Reference
[Essential patterns here - Claude sees this immediately]

## Deep Dive
For full coverage, see [DETAILED_GUIDE.md](DETAILED_GUIDE.md).

Fügen Sie konkrete Beispiele ein. Abstrakte Beschreibungen sind weniger nützlich als konkrete Muster:

## Input Validation

### Pattern
```typescript
// Good: Explicit validation with typed errors
const validated = PaymentSchema.safeParse(input);
if (!validated.success) {
  throw new ValidationError(validated.error.issues);
}

// Bad: Implicit coercion
const amount = Number(input.amount); // Silent NaN on invalid input

**Testen Sie mit realistischen Anfragen.** Testen Sie nach dem Erstellen eines Skills, ob Claude ihn aktiviert:

Review this payment processing code for issues

Should activate payments-domain skill

How should I handle refunds?

Should activate payments-domain skill

What’s the weather like?

Should NOT activate payments-domain skill

Wenn Claude den Skill nicht wie erwartet aktiviert, überarbeiten Sie die Beschreibung, um die verwendeten Auslösephrasen einzubeziehen.

### Strategien für die Team-Weitergabe

**Git-basierte Weitergabe (empfohlen für Projekt-Skills):**
```bash
# Add skill to project
mkdir -p .claude/skills/team-standard
# Create SKILL.md and supporting files

# Commit
git add .claude/skills/
git commit -m "Add team coding standards skill"
git push

# Teammates get it automatically
git pull
claude  # Skill now available

Projektübergreifende Weitergabe via Symlinks:

# Create canonical skill location
mkdir -p ~/shared-skills/security-reviewer
# Create SKILL.md

# Symlink into projects
ln -s ~/shared-skills/security-reviewer ~/.claude/skills/security-reviewer
# Now available in all your projects

Plugin-Distribution: Für eine breitere Verteilung können Sie Skills in Plugins verpacken:

my-plugin/
├── .claude-plugin/
│   └── plugin.json
└── skills/
    └── my-skill/
        └── SKILL.md

In Plugins gebündelte Skills werden verfügbar, sobald Benutzer das Plugin installieren.

Skills debuggen

Skill wird nicht aktiviert:

1. Prüfen Sie, ob die Beschreibung zu Ihrer Anfrage passt: yaml # If you're saying "check this code" but description says "review" description: Review OR check code for issues...

2. Überprüfen Sie den Dateispeicherort: ```bash # Personal ls ~/.claude/skills/my-skill/SKILL.md

# Project ls .claude/skills/my-skill/SKILL.md ```

1. Validieren Sie das YAML-Frontmatter:
2. Die erste Zeile muss exakt --- sein
3. Abschließendes --- vor dem Markdown-Inhalt
4. Keine Tabs im YAML (verwenden Sie Leerzeichen)

5. Das Name-Feld besteht nur aus Kleinbuchstaben mit Bindestrichen

6. Starten Sie im Debug-Modus: bash claude --debug # Watch for skill loading messages

Skill wird unerwartet aktiviert:

Schränken Sie die Beschreibung ein. Wenn Ihr Skill aktiviert wird, obwohl er nicht sollte, ist die Beschreibung zu weit gefasst:

# Too broad - activates on any "code" mention
description: Help with code

# Specific - activates only for security contexts
description: Audit code for security vulnerabilities including injection attacks, authentication flaws, and data exposure. Use when specifically asked about security, vulnerabilities, or when reviewing code for security issues.

Unterstützende Dateien werden nicht gefunden:

• Verwenden Sie relative Pfade vom SKILL.md-Speicherort
• Nur Schrägstriche (auch unter Windows)
• Prüfen Sie, ob die Datei tatsächlich existiert: ls .claude/skills/my-skill/REFERENCED.md

Wann Sie einen Skill erstellen sollten

Erstellen Sie einen Skill, wenn: - Domänen-Expertise automatisch aktiviert werden soll - Mehrere Teammitglieder dasselbe Wissen benötigen - Sie wiederholt dieselben Muster oder Regeln erklären - Kontext ohne expliziten Aufruf eingebunden werden soll - Wissen mehrere Dateien umfasst und Organisation benötigt

Erstellen Sie keinen Skill, wenn: - Sie explizite Kontrolle über den Aufruf möchten (verwenden Sie einen Slash-Befehl) - Die Aufgabe separaten Kontext benötigt (verwenden Sie einen Subagent) - Es sich um einen einmaligen Prompt handelt (tippen Sie ihn einfach ein) - Der „Skill” eigentlich nur ein einzelnes Template ist (verwenden Sie einen Slash-Befehl)

Expertentipp: Wenn Sie wiederholt /security-review eingeben, bevor Sie an Auth-Code arbeiten, wandeln Sie es in einen Skill um. Machen Sie die Expertise allgegenwärtig, nicht explizit aufgerufen. Wenn Sie einen expliziten Aufruf wünschen, behalten Sie es als Befehl bei.

Plugin-System

Plugins verpacken Claude Code-Erweiterungen zur Verteilung. Ein Plugin kann benutzerdefinierte Befehle, Subagents, Skills, Hooks und MCP-Server enthalten. Anthropic hat den Plugin-Marktplatz offiziell im Dezember 2025 mit 36 kuratierten Plugins gestartet.⁴⁷

Plugin-Struktur

my-plugin/
├── .claude-plugin/
│   └── plugin.json              # Required: metadata
├── commands/                     # Slash commands
│   └── hello.md
├── agents/                       # Subagents
│   └── helper.md
├── skills/                       # Skills
│   └── my-skill/
│       └── SKILL.md
├── hooks/                        # Event handlers
│   └── hooks.json
└── .mcp.json                     # MCP servers

Plugin-Manifest

Minimale plugin.json:

{
  "name": "my-plugin",
  "description": "What this plugin does",
  "version": "1.0.0",
  "author": {
    "name": "Your Name"
  }
}

Plugin-Verwaltung

> /plugin                              # Interaktive Oberfläche
> /plugin install name@marketplace     # Installieren
> /plugin enable name@marketplace      # Aktivieren
> /plugin disable name@marketplace     # Deaktivieren
> /plugin uninstall name@marketplace   # Entfernen
> /plugin marketplace add ./local      # Lokalen Marktplatz hinzufügen
> /plugin marketplace list             # Marktplätze anzeigen

Lokale Entwicklung

Erstellen Sie einen lokalen Marktplatz zum Testen:

mkdir dev-marketplace && cd dev-marketplace
mkdir my-plugin
# Create plugin structure

cd ..
claude
> /plugin marketplace add ./dev-marketplace
> /plugin install my-plugin@dev-marketplace

Verbesserungen bei der Plugin-Installation (v2.1.51+)

Plugins unterstützen jetzt benutzerdefinierte npm-Registries und spezifische Versionspinnung bei der Installation aus npm-Quellen. Das Standard-Git-Timeout für Marktplatz-Operationen wurde von 30 s auf 120 s erhöht und ist über CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS konfigurierbar.¹⁰⁵

Plugin-Komponenten

• Befehle: Verfügbar als Slash-Befehle (/plugin-command)
• Agents: Erscheinen in der /agents-Liste
• Skills: Werden automatisch basierend auf der Skill-Konfiguration geladen
• Hooks: Werden mit Benutzer-/Projekt-Hooks zusammengeführt und parallel ausgeführt
• MCP-Server: Starten automatisch, wenn das Plugin aktiviert ist

Wie funktioniert der Speicher?

Das Speichersystem von Claude Code ermöglicht persistenten Kontext über Sitzungen hinweg. Effektive Speicherverwaltung ist der Unterschied zwischen einem Claude, das Ihr Projekt tiefgreifend versteht, und einem, das jede Sitzung als Neuanfang behandelt.

CLAUDE.md-Hierarchie