Claude Code arbeitet als agentisches System, nicht als Chat-Oberfläche mit Programmierkenntnissen. Die 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 Befehlszeilenschnittstelle, die sich nahtlos in die tatsächliche Arbeitsweise von Entwicklern integriert.

Der Unterschied zwischen oberflächlicher und effektiver Nutzung von Claude Code liegt in fünf Kernsystemen. Beherrschen Sie diese, wird Claude Code zum Multiplikator Ihrer Produktivität:

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

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 umfassende Referenz, die ich mir gewünscht hätte, als ich anfing. Jede Funktion enthält die tatsächliche Syntax, echte Konfigurationsbeispiele und die Grenzfälle, die selbst erfahrene Benutzer ins Stolpern bringen.

Wie Claude Code funktioniert: Das mentale Modell

Bevor Sie sich mit den Funktionen beschäftigen, 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 │
└─────────────────────────────────────────────────────────┘

Core Layer: Ihre Hauptkonversation. Jede Nachricht, jede gelesene Datei und jede Tool-Ausgabe verbraucht Kontext aus einem gemeinsamen 200K-Token-Fenster (1M mit Premium). Wenn der Kontext voll ist, verliert Claude den Überblick über frühere Entscheidungen und die Qualität lässt nach. Diese Schicht kostet Geld pro Token.

Delegation Layer: Subagents starten mit sauberem Kontext, erledigen fokussierte Arbeit und geben Zusammenfassungen zurück. Die Erkundungsergebnisse blähen Ihre Hauptkonversation nicht auf – nur die Schlussfolgerungen werden zurückgegeben. Verwenden Sie Haiku-Subagents für die Erkundung (günstig, schnell) und Sonnet für die Implementierung.

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

Die wichtigste Erkenntnis: Die meisten Benutzer arbeiten ausschließlich im Core Layer und beobachten, wie der Kontext aufbläht und die Kosten steigen. Erfahrene Benutzer verlagern Erkundung und spezialisierte Arbeit in den Delegation Layer, halten den Extension Layer für ihren Workflow konfiguriert und nutzen den Core Layer nur für Orchestrierung und finale Entscheidungen.

Inhaltsverzeichnis

1. Wie installiere ich Claude Code?
2. Kern-Interaktionsmodi
3. Konfigurationssystem im Detail
4. Welches Modell sollte ich wählen?
5. Wie funktioniert das Berechtigungssystem?
6. Wie funktionieren Hooks?
7. Was ist MCP (Model Context Protocol)?
8. Was sind Subagents?
9. Was ist der Extended Thinking Mode?
10. Ausgabestile
11. Slash Commands
12. Wie funktionieren Skills?
13. Plugin-System
14. Wie funktioniert Memory?
15. Bilder und multimodale Eingabe
16. Wie funktioniert die Git-Integration?
17. Wie verwende ich Claude Code in meiner IDE?
18. Fortgeschrittene Nutzungsmuster
19. Was ist Claude Code Remote?
20. Was sind Background Agents?
21. Claude in Chrome
22. Claude Code in Slack
23. Was kostet Claude Code?
24. Leistungsoptimierung
25. Wie debugge ich Probleme?
26. Enterprise-Bereitstellung
27. Tastenkürzel-Referenz
28. Best Practices

Wie installiere ich Claude Code?

Systemvoraussetzungen

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

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)

Das native Binary bietet die sauberste Erfahrung ohne Node.js-Abhängigkeit:

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

# Homebrew alternative
brew install --cask claude-code

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

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

Für versionsspezifische Installation:

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

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

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

NPM-Installation (veraltet)

Hinweis: Ab v2.1.15 zeigen npm-Installationen einen Hinweis zur Einstellung an. Das native Binary ist jetzt die empfohlene Installationsmethode. Migrieren Sie mit claude install.

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

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

Verwenden Sie niemals sudo bei der npm-Installation – es verursacht Berechtigungsprobleme, die alles Nachfolgende komplizierter machen.

Migration von bestehender Installation

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

claude install

Authentifizierungsoptionen

Claude Code unterstützt drei Authentifizierungswege, jeder mit unterschiedlichen Vor- und Nachteilen:

Claude Console (API-Abrechnung)

Verbinden Sie sich direkt mit der Anthropic-API über platform.claude.com (früher console.anthropic.com). Erstellen Sie ein Konto, richten Sie die Abrechnung ein und authentifizieren Sie sich über die CLI. Dies 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 Sie können 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 monatlichen Tarif ab. Dies 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-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

Dies meldet den Installationstyp, die Version, die Systemkonfiguration und alle erkannten Probleme.

Updates

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

Auto-Updates deaktivieren:

export DISABLE_AUTOUPDATER=1

Oder in settings.json:

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

Manuelles Update:

claude update

Deinstallation

Native Installation (macOS/Linux/WSL):

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

Native Installation (Windows PowerShell):

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

Konfiguration bereinigen (entfernt alle Einstellungen):

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

Zentrale Interaktionsmodi

Interaktiver REPL

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

cd your-project
claude

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

Starten 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 Kompaktierungsereignisse hinweg bei. Wenn der Kontext zu groß wird, fasst Claude ältere Gesprächsinhalte automatisch zusammen und bewahrt dabei wichtige Entscheidungen und Code-Ausschnitte. Sie können dies manuell mit /compact auslösen oder eigene Anweisungen hinzufügen, was erhalten bleiben soll.

Nicht-interaktiver Modus

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

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

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

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

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

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

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

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

Für die Echtzeitverarbeitung von Streaming-Ausgaben:

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

Sitzungsverwaltung

Sitzungen speichern den Gesprächsverlauf zur Fortsetzung. Dies ist unverzichtbar für komplexe Arbeit über mehrere Sitzungen hinweg:

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

Erstellen Sie reproduzierbare Sitzungen mit expliziten IDs:

claude --session-id "feature-auth-$(date +%s)"

Expertentipp: Verwenden Sie Sitzungs-IDs, die Kontext kodieren: feature-${branch}-${timestamp} oder bug-JIRA-123. Wenn Sie Tage später zurückkehren, verrät Ihnen die ID, worum es in der Sitzung ging. Verfügbare Sitzungen können Sie im REPL mit /resume anzeigen.

Sitzungen werden als JSONL-Transkripte gespeichert. Bei der Agent-Ausführung werden eindeutige agentId-Werte zugewiesen, deren Transkripte als agent-{agentId}.jsonl gespeichert werden. Beim Fortsetzen wird der vollständige Kontext aus vorherigen Gesprächen wiederhergestellt.

Benannte Sitzungen (Dez. 2025): Benennen und verwalten Sie Sitzungen komfortabler:

# Name current session
> /rename my-feature-work

# Resume by name or number
> /resume 1                    # Resume first session
> /resume my-feature-work      # Resume by name
claude --resume 3              # Resume from terminal

# Fork with custom session ID
claude --session-id "new-exploration" --resume "base-session" --fork-session

Konfigurationssystem im Detail

Claude Code verwendet ein mehrschichtiges Konfigurationssystem. Das Verständnis der Hierarchie ist essenziell, 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 gemeinsamen Projekten – diese Datei sollte in .gitignore stehen. Verwenden Sie .claude/settings.json für teamweite Konfiguration, die in die Versionskontrolle eingecheckt wird.

Vollständige settings.json-Referenz

Eine umfassende Konfiguration, die alle wichtigen Optionen demonstriert:

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

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-5                 # Override default model
ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-5-20251101
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-5-20250929-v1:0
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

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]

Debugging:

ANTHROPIC_LOG=debug                             # Enable API request logging

## Welches Modell sollte ich wählen?

Die Wahl des richtigen Modells für jede Aufgabe beeinflusst sowohl die Kosten als auch die Qualität erheblich. Claude Code bietet flexibles Modellwechseln auf mehreren Ebenen.

### Verfügbare Modelle

| Alias | Modell | Ideal für | Input/1M | Output/1M |
|-------|-------|----------|----------|-----------|
| `sonnet` | Claude Sonnet 4.5 | Tägliches Programmieren, ausgewogene Leistung | $3.00 | $15.00 |
| `opus` | Claude Opus 4.5 | Komplexes Denken, Architektur | $5.00 | $25.00 |
| `haiku` | Claude Haiku 4.5 | Einfache Aufgaben, schnelle Operationen | $1.00 | $5.00 |
| `default` | Kontoabhängig | Allgemeine Verwendung | Variiert | Variiert |
| `sonnet[1m]` | Sonnet mit 1M Kontext | Große Codebasen | $6.00 | $22.50 |
| `opusplan` | Opus (Planung) + Sonnet (Ausführung) | Komplexes Refactoring | Hybrid | Hybrid |

**Warum diese Preisunterschiede wichtig sind:** Eine typische Programmiersitzung verbraucht 50K-200K Input-Token und 10K-50K Output-Token. Mit Haiku kostet das $0,10-$0,45 pro Sitzung. Mit Opus kostet dieselbe Sitzung $0,50-$2,25—fünfmal mehr. Reservieren Sie Opus für wirklich schwierige Probleme.[^1]

### Wann Sie welches Modell verwenden sollten

**Haiku**: Verwenden Sie es für Subagents, die Erkundungen durchführen, einfache Dateisuchen und schnelle Fragen. Es ist 10-20x günstiger als Opus und antwortet schneller. Perfekt für Hintergrundaufgaben, bei denen Sie kein tiefes Reasoning benötigen.

**Sonnet**: Das Arbeitstier für die tägliche Entwicklung. Bewältigt die meisten Programmieraufgaben gut: Features implementieren, Bugs beheben, Tests schreiben, Code-Review. Verwenden Sie dies als Ihren Standard.

**Opus**: Reservieren Sie es für wirklich komplexes Reasoning: Architekturentscheidungen, kniffliges Debugging, das Verstehen komplexer Systeme, Sicherheitsanalysen. Der Qualitätsunterschied ist bei schwierigen Problemen real, aber auch die Kosten. Opus 4.5 erreicht 80,9% bei SWE-bench Verified und halbiert dabei den Token-Verbrauch im Vergleich zu Vorgängern.[^45] **Hinweis:** Pro-Abonnenten haben jetzt Zugang zu Opus 4.5 als Teil ihres Abonnements.[^20]

**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 wollen, 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:**
```bash
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]

Oder innerhalb einer Sitzung:

> /model anthropic.claude-sonnet-4-5-20250929-v1:0[1m]

Erweiterter Kontext kostet mehr pro Token. Verwenden Sie ihn, wenn Sie ihn wirklich brauchen, nicht als Standard.

Aktuelles Modell überprüfen

> /status

Dies zeigt das aktuelle Modell, Kontoinformationen, angewendete Einstellungen und anderen Sitzungszustand.

Entscheidungsrahmen

Zu wissen, dass Features existieren, reicht nicht aus—Sie müssen wissen, wann Sie welches verwenden sollten. Diese Entscheidungsbäume verwandeln Wissen in Handlung.

Welches Modell sollte ich verwenden?

START → Ist die Aufgabe einfach? (Dateisuche, schnelle Frage, Formatierung)
         │
         ├── JA → Verwenden Sie Haiku
         │         Kosten: ~$0,03/Aufgabe
         │         Geschwindigkeit: Am schnellsten
         │
         └── NEIN → Erfordert sie tiefes Reasoning?
                  (Architektur, komplexes Debugging, Sicherheitsanalyse)
                  │
                  ├── JA → Verwenden Sie Opus
                  │         Kosten: ~$2,00/Aufgabe
                  │         Qualität: Höchste
                  │
                  └── NEIN → Verwenden Sie Sonnet (Standard)
                           Kosten: ~$0,75/Aufgabe
                           Balance: Beste insgesamt

Faustregel: Beginnen Sie mit Sonnet. Wechseln Sie zu Haiku für Subagents. Eskalieren Sie nur dann zu Opus, wenn Sonnets Antwort oberflächlich wirkt.

Command vs Skill vs Subagent?

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 das Timing.
│
└── NEIN → Soll die Expertise automatisch basierend auf dem Kontext angewendet werden?
         │
         ├── JA → Verwenden Sie Skill
         │         Beispiel: Sicherheitsmuster, Domänenregeln, Codestandards
         │         Claude erkennt den Kontext und wendet Expertise an.
         │
         └── NEIN → Benötigt die Arbeit isolierten Kontext?
                  │
                  ├── JA → Verwenden Sie Subagent
                  │         Beispiel: Tiefe Erkundung, parallele Analyse
                  │         Verhindert Kontextaufblähung in der Hauptkonversation.
                  │
                  └── NEIN → Prompten Sie einfach direkt
                           Nicht alles braucht Abstraktion.

Hook vs Prompt?

Muss die Aktion IMMER geschehen, unabhängig von Claudes Urteil?
│
├── JA → Verwenden Sie Hook (deterministisch)
│         Beispiele:
│         - Code nach jeder Bearbeitung formatieren
│         - Alle Bash-Befehle protokollieren
│         - Zugriff auf .env-Dateien blockieren
│         Claude kann es nicht überspringen, vergessen oder anders entscheiden.
│
└── NEIN → Verwenden Sie Prompt (probabilistisch)
         Beispiele:
         - "Erwäge, Tests hinzuzufügen"
         - "Denke an Randfälle"
         - "Prüfe auf Sicherheit, wenn relevant"
         Claude entscheidet basierend auf dem Kontext.

Wann sollte Extended Thinking verwendet werden?

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

Wechseln Sie mit Tab während der Sitzung. Höhere Thinking-Budgets kosten mehr—beginnen Sie mit dem Minimum und erhöhen Sie nur, wenn Antworten gehetzt wirken.

Wie funktioniert das Berechtigungssystem?

Das Berechtigungssystem von Claude Code bietet feinkörnige Kontrolle darüber, welche Operationen ausgeführt werden können. Es zu verstehen ist sowohl für Sicherheit als auch für Workflow-Effizienz unerlässlich.

Berechtigungsstufen

Nur-Lese-Tools (automatisch genehmigt): - Read - Dateiinhalte lesen - Glob - Dateien nach Muster finden - Grep - Dateiinhalte durchsuchen - WebSearch - Im Web suchen - LSP - Code-Intelligenz (go-to-definition, find references, hover docs)²⁵

LSP Tool-Funktionen (v2.0.74+): Das LSP Tool bietet IDE-ähnliche Code-Intelligenz: - Go-to-definition: Zur Definition eines Symbols springen - Find references: Alle Verwendungen eines Symbols in der Codebasis auflisten - Hover docs: Typinformationen und Dokumentation für jedes Symbol abrufen - Funktioniert mit TypeScript, Python, Go, Rust und anderen Sprachen mit LSP-Unterstützung - Erfordert, dass ein Language Server verfügbar ist (typischerweise mit Ihrer Toolchain installiert)

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

Beim ersten Ausführen eines Modifikations-Tools fragt Claude Code nach Genehmigung. Genehmigungen bleiben für die Sitzung erhalten, sofern nicht explizit anders konfiguriert.

Berechtigungsmodi

YOLO Mode (v2.0.68+): Für vollständig autonomen Betrieb verwenden Sie das Flag --dangerously-skip-permissions. Dies sagt Ja zu allem—Dateibearbeitungen, Bash-Befehle, alle Tool-Aufrufe. Das Wort “dangerous” ist beabsichtigt. Verwenden Sie es in Sandbox-Umgebungen oder wenn Sie der Codebasis vollständig vertrauen.⁶¹

claude --dangerously-skip-permissions

Modus per CLI setzen:

claude --permission-mode acceptEdits

Während der Sitzung umschalten:

Shift+Tab  # Wechselt durch die Modi

In settings.json:

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

Syntax für Berechtigungsregeln

Feinkörnige Regeln steuern spezifische 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 Regex. Ein Muster wie Bash(curl http:*) wird nicht curl -X GET http://... matchen, weil die Optionen vor der URL kommen. Für robustes Blockieren verbieten Sie den Befehl vollständig: Bash(curl:*).

Dateioperationsmuster:

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

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

MCP-Tool-Muster:

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

Verwenden Sie Wildcard-Syntax mcp__server__*, um alle Tools eines bestimmten MCP-Servers zu erlauben oder zu verbieten.³⁹ Dies ist nützlich, um schnell alle Tools von vertrauenswürdigen Servern zu aktivieren oder ganze Server von nicht vertrauenswürdigen Quellen zu blockieren.

WebFetch-Muster:

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

Zusätzliche Verzeichnisse

Erweitern Sie Claudes Zugriff über das aktuelle Projekt hinaus:

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

Dies ist unerlässlich für Monorepos oder wenn Claude Code auf Code in Nachbarverzeichnissen zugreifen muss.

Sandbox-Modus

Aktivieren Sie Dateisystem- und Netzwerkisolierung:

> /sandbox

Oder in den Einstellungen konfigurieren:

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

Im Sandbox-Modus: - Dateisystemzugriff auf Projektverzeichnis beschränkt - Netzwerkzugriff kontrolliert - Bestimmte Befehle von Sandbox-Einschränkungen ausgenommen - Bash-Befehle automatisch erlaubt, wenn autoAllowBashIfSandboxed true ist

Expertentipp: Der Sandbox-Modus ist hervorragend geeignet, um Claude auf nicht vertrauenswürdigen Codebasen auszuführen. Aktivieren Sie ihn, wenn Sie unbekannte Projekte erkunden oder eine zusätzliche Schutzschicht wünschen. Interne Anthropic-Tests ergaben, dass Sandboxing Berechtigungsabfragen um 84% reduziert.⁴⁵

Wie funktionieren Hooks?

Hooks führen deterministische Shell-Befehle an bestimmten Punkten im Workflow von Claude Code aus. Im Gegensatz zu Anweisungen an Claude, bestimmte 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.

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 erhalten JSON über stdin:

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

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

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

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

PreToolUse-Hooks mit ask-Berechtigung (v2.1.0+): PreToolUse-Hooks können jetzt updatedInput zurückgeben, wenn sie die “ask”-Berechtigungsentscheidung verwenden. Dies ermöglicht es Hooks, als Middleware zu fungieren und gleichzeitig die Zustimmung des Benutzers einzuholen.³⁹

{
  "decision": "ask",
  "message": "Modified command requires approval",
  "updatedInput": {
    "command": "npm test -- --coverage --ci"
  }
}

PreToolUse-Hooks mit additionalContext (v2.1.9+): Hooks können Kontext in das Modell injizieren, indem sie additionalContext zurückgeben. Dies ist nützlich, um dynamische Informationen (API-Dokumentation, Datenbank-Schemas, Umgebungszustand) bereitzustellen, die das Modell berücksichtigen sollte.⁵¹

{
  "decision": "allow",
  "additionalContext": "Note: This database has a 5-second query timeout. Complex joins may need optimization."
}

Der String additionalContext wird für diesen Turn an den Kontext des Modells angehängt und steht für das Reasoning zur Verfügung, ohne die Konversation dauerhaft zu verändern.

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 1
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 Probleme mit Hooks zu beheben:

claude --debug

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

Komponenten-bezogene Hooks (v2.1.0+)

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

Skill mit eingebetteten Hooks:

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

Unterstützte Events: PreToolUse, PostToolUse, Stop

Die Option once (nur für Skills und Slash-Befehle) stellt sicher, dass der Hook nur einmal pro Session ausgeführt wird – nützlich für Aufräum- oder Finalisierungsaufgaben.

Strategie für langfristige Sessions

Für Über-Nacht- oder unbeaufsichtigte Claude Code-Sessions konfigurieren Sie Hooks, die Claude ohne manuelles Eingreifen auf Kurs halten. Die wichtigste Erkenntnis: Verwenden Sie Linting- und Testing-Hooks als Leitplanken, die Claude zwingen, Probleme zu beheben, bevor er fortfährt.⁶⁴

Das „Nicht aufhören bis Tests bestehen”-Muster:

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

Strategie für Über-Nacht-Sessions:

1. Pre-Flight-Check: Verwenden Sie einen Setup-Hook, um zu überprüfen, ob die Umgebung bereit ist
2. Kontinuierliche Validierung: PostToolUse-Hooks führen nach jeder Änderung Tests aus
3. Abschluss-Gate: Stop-Hooks verifizieren, dass alle Akzeptanzkriterien erfüllt sind, bevor Claude „fertig” erklärt
4. Benachrichtigung: Stop-Hooks können Sie via Slack/Pushover benachrichtigen, wenn Claude fertig ist oder nicht weiterkommt

Kombinieren Sie dies mit --dangerously-skip-permissions in einem isolierten Container für vollständig autonome Über-Nacht-Durchläufe. Claude wird weiter iterieren, bis die Tests bestehen oder er seine Optionen erschöpft hat.

Was ist MCP (Model Context Protocol)?

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

Warum MCP für Entwickler wichtig ist: Ohne MCP kann Claude Code nur Dateien lesen und Bash-Befehle ausführen. Mit MCP kann Claude Ihre Produktionsdatenbank abfragen, Jira-Tickets erstellen, GitHub-PRs reviewen, Sentry-Fehler prüfen und mit jeder API interagieren, die Ihr Team nutzt – alles über Anfragen in natürlicher Sprache. Das Protokoll standardisiert, wie KI-Tools sich mit externen Diensten verbinden, und verhindert so eine Anbieterabhängigkeit.

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

MCP Tool Search (v2.1.7+)

Da MCP-Server immer leistungsfähiger wurden (manche bieten über 50 Tools), begannen Tool-Beschreibungen übermäßig viel Kontext zu verbrauchen. MCP Tool Search löst dieses Problem, indem Tool-Beschreibungen dynamisch erst bei Bedarf 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 - Reduktion des Token-Overheads: 85 %

Funktionsweise: Wenn MCP-Tool-Beschreibungen 10 % des Kontextfensters überschreiten (Standard-Schwellenwert), verzögert Claude Code das Laden der vollständigen Beschreibungen, bis sie tatsächlich benötigt werden. Claude sieht die Tool-Namen, ruft die Beschreibungen aber 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 vorab 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%ige Kontextreduktion bedeutet, dass Server, die zuvor um Kontext konkurriert haben, nun problemlos koexistieren.

Interaktiver MCP-Einrichtungsassistent

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

Transporttypen

HTTP (empfohlen für Remote-Server):

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

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

SSE (veraltet, aber funktionsfähig):

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

Stdio (lokale Server):

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

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

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

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

Bereichsverwaltung

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

Geben Sie den Bereich bei der Installation an:

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

Format der Konfigurationsdatei

Die Datei .mcp.json definiert Server auf Projektebene:

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

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

MCP-Verwaltungsbefehle

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

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

OAuth-Authentifizierung

Für Server, die OAuth erfordern:

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

Verwendung von MCP-Ressourcen und Prompts

Ressourcen referenzieren:

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

MCP-Prompts als Slash-Befehle:

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

Ausgabelimits

Die MCP-Ausgabe ist begrenzt, 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 absoluten Vorrang. 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-Oberflächen direkt in der Claude-Benutzeroberfläche ermöglicht.⁷⁸ MCP Apps erlauben es Benutzern, Inhalte externer Dienste anzuzeigen, zu bearbeiten und mit ihnen zu interagieren, ohne Claude verlassen zu müssen – darunter Asana, Box, Canva, Figma, Hex, monday.com und Slack. Jeder MCP-Server kann eine interaktive Oberflä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 Fähigkeiten übernehmen.

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

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

Dies betrifft hauptsächlich API-Nutzer, deutet aber die Richtung für die Cloud-Ausführungsfähigkeiten von Claude Code an.

Was sind Subagenten?

Subagenten sind spezialisierte Claude-Instanzen, die komplexe Aufgaben eigenständig bearbeiten. Sie gehören zu den leistungsfähigsten Funktionen in Claude Code und werden gleichzeitig am wenigsten verstanden. Wenn Sie Subagenten beherrschen, erweitern Sie Ihre Möglichkeiten erheblich.

Warum Subagenten 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 beansprucht diesen Kontext. In langen Sitzungen füllt sich der Kontext, Claude verliert den Überblick über frühere Entscheidungen, und die Leistung verschlechtert sich. Subagenten lösen dieses Problem durch Isolation: Explorationsergebnisse blähen Ihre Hauptkonversation nicht auf, nur die Zusammenfassung wird zurückgegeben. Claude kann außerdem bis zu 10 Subagenten parallel ausführen, was gleichzeitige Arbeit ermöglicht, die sequenziell unmöglich wäre.²

Wie Subagenten funktionieren

Wenn Claude auf eine Aufgabe trifft, die von fokussierter Aufmerksamkeit profitiert – tiefgreifende Exploration, mehrstufige Analyse, spezialisierte Arbeit – kann Claude einen Subagenten starten. Der Subagent:

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

Diese Architektur verhindert Kontextüberlauf und ermöglicht gleichzeitig komplexe Arbeitsabläufe.

Integrierte Subagenten-Typen

Explore (schnell, schreibgeschützt): - Modell: Haiku (ultraschnell) - Modus: Strikt 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, Dateien finden, Struktur verstehen

General-purpose: - Modell: Sonnet - Modus: Voller Lese-/Schreibzugriff - Tools: Alle verfügbaren Tools - Verwendung für: Komplexe Recherche- und Modifikationsaufgaben

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

Subagenten auslösen

Claude delegiert basierend auf dem Aufgabentyp automatisch an Subagenten. 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

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

Benutzerdefinierte Subagenten erstellen

Definieren Sie Subagenten 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:

Subagenten verwalten

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

Agenten im Hintergrund ausführen

Für lang laufende Aufgaben:

> Run a thorough security review in the background

> /agents  # Status laufender Agenten prüfen

Ergebnisse später mit der Agenten-ID abrufen.

Fortgeschrittene Muster

Verkettete Subagenten:

> 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 Agenten: Agenten können mit ihrer ID fortgesetzt werden, um frühere Arbeit weiterzuführen:

> Resume agent abc123 and continue the analysis

Async Subagenten (Dezember 2025)

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

> Run security review in the background while I continue frontend work
> /tasks                    # Status laufender Agenten prüfen

Async-Agenten geben Ergebnisse über das einheitliche TaskOutputTool zurück, was effiziente Pipeline-artige Arbeitsabläufe ermöglicht.

Resilienz bei Berechtigungsverweigerung (v2.1.0+)

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

Agent Skills (Dezember 2025)

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

.claude/skills/
├── security-review/
│   ├── skill.md           # Anweisungen und Prompts
│   ├── checklist.md       # Sicherheits-Checkliste
│   └── common-vulns.sh    # Erkennungsskripte
└── performance-audit/
    ├── skill.md
    └── profiling-guide.md

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

Was ist der Extended Thinking Mode?

Extended Thinking gibt Claude mehr Zeit, komplexe Probleme zu durchdenken, bevor eine Antwort gegeben wird. Es ist besonders wertvoll für Architekturentscheidungen, das Debuggen kniffliger Probleme und Aufgaben, die 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.⁷⁰ Diese Änderung wurde 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. Diese Schlüsselwörter werden jetzt als reguläre Prompt-Anweisungen interpretiert und weisen 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.5
• Claude Sonnet 4.5
• Claude Haiku 4.5

Extended Thinking steuern

Schnelles Umschalten während der Sitzung:

Drücken Sie Alt+T, um Thinking ein-/auszuschalten

Hinweis: Der Thinking-Toggle wurde von Tab auf Alt+T geändert, um versehentliche Auslösung zu vermeiden.³⁹

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

Umgebungsvariable (dauerhaft):

# Benutzerdefiniertes Budget festlegen (Standard ist 31.999)
export MAX_THINKING_TOKENS=8000
claude

# Standard verdoppeln für komplexe Aufgaben
export MAX_THINKING_TOKENS=63999
claude

Zur Kosteneinsparung deaktivieren: Für einfachere Aufgaben, bei denen tiefes Reasoning nicht benötigt wird, können Sie Kosten reduzieren, indem Sie Thinking in /config deaktivieren oder das Budget senken:

export MAX_THINKING_TOKENS=8000  # Reduziert vom Standard 31.999

Thinking-Token-Budgets

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

Wie es funktioniert

Wenn Thinking aktiviert ist, enthält Claudes Antwort internes Reasoning, das in der Ausgabe nicht angezeigt wird, aber die Antwort beeinflusst. Das Thinking wird verschlüsselt und in einem signature-Feld zur Verifizierung zurückgegeben.

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

Wann Sie eine Deaktivierung/Reduzierung in Betracht ziehen sollten

Extended Thinking ist jetzt der Standard, aber erwägen Sie eine Budgetreduzierung oder Deaktivierung für: - Einfache Dateibearbeitungen - Routine-Refactoring - Schnelle Fragen - Code-Formatierung - Operationen mit hohem Volumen, bei denen sich Kosten summieren

Cache-Verhalten

System-Prompt-Caching bleibt erhalten, wenn sich Thinking-Parameter ändern. Message-Caching wird ungültig, wenn sich Thinking-Budget oder Aktivierungsstatus zwischen Turns ändert.

Output Styles

Output Styles passen an, wie Claude Informationen präsentiert – nützlich zum Lernen, für Dokumentation oder spezifische Teampräferenzen.¹⁹

Integrierte Styles

Output Style festlegen

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

Oder über Einstellungen:

{
  "outputStyle": "Explanatory"
}

Benutzerdefinierte Output Styles

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 Commands

Slash Commands 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

Erstellung benutzerdefinierter Befehle

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 dies als .claude/commands/security-review.md und rufen Sie es 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 Command-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 demselben Namen zeigen ihren Namespace in der Hilfe an: /test (project:backend) vs /test (project:frontend).

Wie funktionieren Skills?

Skills repräsentieren einen grundlegend anderen Ansatz zur Erweiterung von Claude Code. Anders als Slash Commands, die Sie explizit aufrufen, sind Skills model-invoked—Claude entdeckt und verwendet sie automatisch basierend auf dem Kontext. Sie betten Domänenwissen 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 Domänenwissen—die Zahlungsverarbeitungsregeln, 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 Wissen automatisch an, wann immer es relevant ist. Ihre Junior-Entwickler erhalten Anleitung auf Senior-Niveau, ohne zu fragen. Ihre Sicherheitsmuster werden durchgesetzt, ohne dass Sie daran denken müssen, sie aufzurufen.

Diese Unterscheidung ist wichtig. Ein Slash Command ist eine Abkürzung, an deren Verwendung Sie sich erinnern. Ein Skill ist Wissen, das Claude immer zur Verfügung hat. Wenn Sie einen Security-Review-Skill mit den spezifischen Schwachstellenmustern und Compliance-Anforderungen Ihres Teams erstellen, wendet Claude dieses Wissen an, wann immer er auf relevanten Code trifft—bei PR-Reviews, beim Refactoring oder bei jeder Aufgabe, bei der Sicherheit wichtig ist. Sie rufen nicht /security-review auf; Claude erkennt den Kontext und wendet den Skill automatisch an.

Skills vs Commands vs Subagents

Das Verständnis, wann welcher Erweiterungsmechanismus zu verwenden ist, verhindert Duplikation und maximiert die Effektivität:

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

Verwenden Sie Skills, wenn Wissen automatisch verfügbar sein soll: Sicherheitsmuster, Code-Style-Durchsetzung, domänenspezifisches Wissen. Claude entscheidet, wann es angewendet wird.

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

Skill-Struktur und Speicherort

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

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

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

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

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

Projekt-Skills werden in die Versionskontrolle eingecheckt. Wenn Teammitglieder pullen, erhalten sie Ihre Skills automatisch—keine Installation, keine Konfiguration. So standardisieren Sie Wissen 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

## Format der Review-Ausgabe

Für jeden Befund:
- **Datei**: path/to/file.ts:123
- **Schweregrad**: Kritisch | Hoch | Mittel | Niedrig
- **Kategorie**: Sicherheit | Performance | Wartbarkeit
- **Problem**: Klare Beschreibung des Problems
- **Empfehlung**: Spezifische Lösung mit Codebeispiel
- **Begründung**: Warum dies wichtig ist

Siehe [SECURITY_PATTERNS.md](SECURITY_PATTERNS.md) für detaillierte Schwachstellenmuster.
Siehe [PERFORMANCE_CHECKLIST.md](PERFORMANCE_CHECKLIST.md) für Optimierungsrichtlinien.

Frontmatter-Referenz

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

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

Schlechte Beschreibung:

description: Helps with code

Effektive Beschreibung:

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

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

Tool-Einschränkungen

Das allowed-tools-Feld begrenzt, was Claude tun kann, wenn ein Skill aktiv ist. Dies ist essenziell für Skills, die schreibgeschützt oder in ihrem Umfang begrenzt sein sollen:

---
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 Aktivierung und greift dann bei Bedarf auf unterstützende Dateien zu – eine schrittweise Offenlegung, die den Kontext effizient verwaltet.

Strukturmuster:

my-skill/
├── SKILL.md           # Erforderlich: Übersicht + Kurzreferenz
├── DETAILED_GUIDE.md  # Ausführliche Dokumentation
├── EXAMPLES.md        # Konkrete Beispiele
├── PATTERNS.md        # Referenzmuster
├── templates/         # Wiederverwendbare Vorlagen
│   └── component.tsx
└── scripts/           # Hilfsdienstprogramme
    └── validate.py

Referenzieren Sie unterstützende Dateien aus SKILL.md:

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 tiefgehendes Referenzmaterial. Claude liest SKILL.md sofort, greift aber nur bei Bedarf auf unterstützende Dateien zu. Wenn kritische Informationen in einer unterstützenden Datei vergraben 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

## Core Concepts

### Transaction States

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

### Money Handling Rules
- ALL monetary values stored as integers (cents, not dollars)
- Currency always explicitly tracked (never assume USD)
- Rounding: HALF_EVEN for calculations, HALF_UP for display
- Never use floating point for money

### Idempotency Requirements
Every payment operation MUST be idempotent:
```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;
}

Quick Reference

Fee Calculations

• Interchange: 1.5% + $0.10 (debit), 2.1% + $0.10 (credit)
• Platform fee: 2.9% + $0.30 (standard), 2.2% + $0.30 (enterprise)
• International: +1% cross-border fee
• Currency conversion: mid-market rate + 1%

Compliance Thresholds

• $3,000: Enhanced due diligence trigger
• $10,000: CTR filing required
• $25,000: Additional verification required

Refund Windows

• Full refund: 120 days from capture
• Partial refund: 180 days from capture
• Chargeback window: 120 days (Visa), 180 days (Mastercard)

Key Files

• src/payments/processor.ts - Core payment logic
• src/payments/refunds.ts - Refund handling
• src/compliance/aml.ts - AML checks
• src/models/transaction.ts - Transaction model

See BUSINESS_RULES.md for detailed business logic. See COMPLIANCE.md for regulatory requirements. See DATA_MODELS.md for schema documentation.

Mit diesem Skill aktiviert Claude automatisch die Payments-Domänenexpertise, wenn Sie an Transaktionscode arbeiten, nach Rückerstattungslogik fragen oder Zahlungsabläufe debuggen. Sie rufen nichts explizit auf – die Expertise ist einfach vorhanden.

### Effektive Skills erstellen

**Beginnen Sie mit der Beschreibung.** Schreiben Sie zuerst die Beschreibung und erstellen Sie dann den Skill-Inhalt entsprechend. Die Beschreibung bestimmt, wann Claude den Skill verwendet, also machen Sie es richtig:

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

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

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

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

**Verwenden Sie schrittweise Offenlegung.** Platzieren Sie die wichtigsten Informationen direkt in SKILL.md. Referenzieren Sie unterstützende Dateien für Tiefe:

```markdown

## Kurzreferenz
[Wesentliche Muster hier - Claude sieht dies sofort]

## Vertiefung
Für umfassende Abdeckung siehe [DETAILED_GUIDE.md](DETAILED_GUIDE.md).

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

## Eingabevalidierung

### Muster
```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.** Nachdem Sie einen Skill erstellt haben, testen Sie, ob Claude ihn aktiviert:

Review this payment processing code for issues

Sollte payments-domain Skill aktivieren

How should I handle refunds?

Sollte payments-domain Skill aktivieren

What’s the weather like?

Sollte payments-domain Skill NICHT aktivieren

Wenn Claude den Skill nicht wie erwartet aktiviert, überarbeiten Sie die Beschreibung, um die Auslösebegriffe einzuschließen, die Sie verwenden.

### Strategien für Team-Sharing

**Git-basiertes Sharing (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übergreifendes Sharing über 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 breitere Verteilung paketieren Sie Skills in Plugins:

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

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

Skills debuggen

Skill aktiviert sich nicht:

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. Erste Zeile muss genau --- sein
3. Abschließendes --- vor dem Markdown-Inhalt
4. Keine Tabs im YAML (verwenden Sie Leerzeichen)

5. Name-Feld ist nur Kleinbuchstaben mit Bindestrichen

6. Führen Sie im Debug-Modus aus: bash claude --debug # Watch for skill loading messages

Skill aktiviert sich unerwartet:

Grenzen Sie die Beschreibung ein. Wenn sich Ihr Skill aktiviert, wenn er es nicht sollte, ist die Beschreibung zu breit:

# 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 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änenexpertise automatisch verfügbar sein sollte - Mehrere Teammitglieder das gleiche Wissen benötigen - Sie wiederholt die gleichen Muster oder Regeln erklären - Kontext ohne expliziten Aufruf injiziert werden sollte - Wissen über mehrere Dateien verteilt ist und Organisation benötigt

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

Expertentipp: Wenn Sie feststellen, dass Sie wiederholt /security-review eingeben, bevor Sie an Auth-Code arbeiten, konvertieren Sie ihn in einen Skill. Die Expertise sollte ambient sein, nicht explizit aufgerufen. Wenn Sie expliziten Aufruf wünschen, behalten Sie es als Befehl.

Plugin-System

Plugins bündeln Claude Code-Erweiterungen für die Verteilung. Ein Plugin kann benutzerdefinierte Befehle, Subagents, Skills, Hooks und MCP-Server enthalten. Anthropic hat den Plugin-Marktplatz im Dezember 2025 mit 36 kuratierten Plugins offiziell 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                              # Interactive interface
> /plugin install name@marketplace     # Install
> /plugin enable name@marketplace      # Enable
> /plugin disable name@marketplace     # Disable
> /plugin uninstall name@marketplace   # Remove
> /plugin marketplace add ./local      # Add local marketplace
> /plugin marketplace list             # View marketplaces

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

Plugin-Komponenten

• Commands: 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 das Gedächtnis?

Das Gedächtnissystem von Claude Code ermöglicht persistenten Kontext über Sitzungen hinweg. Effektives Gedächtnismanagement ist der Unterschied zwischen einem Claude, der Ihr Projekt tiefgehend versteht, und einem, der jede Sitzung als Neuanfang behandelt.

CLAUDE.md-Hierarchie

Effektive CLAUDE.md-Struktur

# Project Context

## Architecture
- Monorepo with packages in /packages
- React frontend in /packages/ui
- Node.js API in /packages/api
- Shared types in /packages/types
- PostgreSQL database via Prisma

## Code Standards
- TypeScript strict mode everywhere
- ESLint + Prettier enforced (pre-commit hooks)
- No default exports
- JSDoc on all public APIs
- Tests required for all new code

## Commands
- `npm test` - Run all tests
- `npm run test:watch` - Watch mode
- `npm run lint` - Check linting
- `npm run lint:fix` - Auto-fix lint issues
- `npm run build` - Production build
- `npm run dev` - Start dev servers
- `npm run db:migrate` - Run migrations
- `npm run db:seed` - Seed database

## Patterns

### API Endpoints
Create in packages/api/src/routes/
Use Zod for request/response validation
All endpoints need OpenAPI documentation

### React Components
Create in packages/ui/src/components/
Use React Query for server state
Prefer composition over inheritance

### Database
Prisma schema in packages/api/prisma/
Always create migration for schema changes
Use transactions for multi-table operations

## Important Notes
- NEVER commit .env files
- API runs on :3000, UI on :3001
- Local DB: postgres://localhost:5432/myapp
- Feature flags in packages/api/src/flags.ts

## Recent Decisions
- 2025-12-01: Migrated to React Query v5
- 2025-11-15: Adopted Zod for all validation
- 2025-11-01: Moved to ESM modules

# Summary Instructions
When using compact, focus on:
- Recent code changes
- Test results
- Architecture decisions made this session

Datei-Importe

Verweisen Sie auf andere Dateien innerhalb von CLAUDE.md:

See @README.md for project overview
Coding standards: @docs/STYLE_GUIDE.md
API documentation: @docs/API.md
Personal preferences: @~/.claude/preferences.md

Import-Syntax: - Relativ: @docs/file.md - Absolut vom Projekt: @/absolute/path.md - Home-Verzeichnis: @~/.claude/file.md - Maximale Tiefe: 5 Ebenen von Importen

Memory Rules-Verzeichnis

Für eine bessere Organisation des Gedächtnisses verwenden Sie .claude/rules/, um kategorisierte Regeldateien zu speichern:¹⁸

.claude/rules/
├── testing.md          # Testing conventions
├── security.md         # Security requirements
├── api-patterns.md     # API design patterns
└── deployments.md      # Deployment procedures

Regeln werden automatisch geladen und bieten strukturierten Kontext, ohne CLAUDE.md zu überladen.

Schnelles Hinzufügen von Notizen

Verwenden Sie das #-Präfix, um während einer Sitzung Notizen hinzuzufügen:

# Always run tests before committing
# The payment module is especially fragile
# Use the new logger from packages/api/src/logger.ts

Sie werden aufgefordert auszuwählen, in welcher Gedächtnisdatei die Notiz gespeichert werden soll.

Befehle zur Kontextverwaltung

Kontextnutzung anzeigen:

> /context

Zeigt ein visuelles Raster der Kontextzuweisung über System-Prompt, Konversation, Tools und Dateiinhalte.

Konversation komprimieren:

> /compact
> /compact focus on the authentication changes
> /compact preserve test output and error messages

Fasst ältere Konversationen intelligent zusammen und bewahrt dabei wichtige Informationen.

Benutzerdefinierte Komprimierungsanweisungen (in CLAUDE.md):

# Summary Instructions
When using compact, focus on:
- Test output and failures
- Code changes made this session
- Architecture decisions

Erweitertes Denken für Kontext:

export MAX_THINKING_TOKENS=10000

Mehr Thinking-Tokens bedeuten mehr Reasoning-Kapazität, aber höhere Kosten.

Strategien zur Kontextoptimierung

1. Verwenden Sie spezifische Dateireferenzen anstatt Claude suchen zu lassen
2. Löschen Sie nicht verwandte Konversationen mit /clear zwischen Aufgaben
3. Komprimieren Sie proaktiv während langer Sitzungen
4. Verwenden Sie Subagents, um explorative Arbeit zu isolieren
5. Teilen Sie komplexe Aufgaben in fokussierte Interaktionen auf
6. Setzen Sie Sitzungen fort für laufende Arbeit, anstatt alles neu zu erklären

Bild- und multimodale Eingabe

Claude Code kann Bilder analysieren—Screenshots, Diagramme, Mockups, Fehlermeldungen, Datenbankschemas.

Eingabemethoden

1. Drag and Drop: Ziehen Sie Bilddateien in das Claude Code-Fenster
2. Einfügen: Ctrl+V (nicht Cmd+V auf dem Mac), um aus der Zwischenablage einzufügen
3. Pfadreferenz: „Analysiere dieses Bild: /path/to/screenshot.png”

Angehängte Bilder anzeigen

Wenn Claude in seiner Antwort auf ein Bild verweist, ermöglichen anklickbare Bildlinks die direkte Ansicht:³⁴

[Image #1]   # Click to open in default image viewer
[Image #2]   # Navigate attached screenshots

Dies ist nützlich beim Überprüfen von Screenshots oder beim Debuggen visueller Probleme—klicken Sie auf die Referenz, um genau zu sehen, was Claude analysiert hat.

Anwendungsfälle

• UI-Probleme debuggen: „Hier ist ein Screenshot des Bugs, was verursacht ihn?”
• Designs implementieren: „Baue diese Komponente basierend auf dem Mockup”
• Diagramme analysieren: „Erkläre dieses Architekturdiagramm”
• Datenbankschemas: „Erstelle Prisma-Modelle passend zu diesem ERD”
• Fehleranalyse: „Was bedeutet dieser Fehler-Screenshot?”

Experten-Tipp: Wenn Sie von Mockups implementieren, fügen Sie mehrere Screenshots hinzu, die verschiedene Zustände zeigen (Standard, Hover, Laden, Fehler). Je mehr visueller Kontext, desto besser die Implementierung.

Wie funktioniert die Git-Integration?

Claude Code verfügt über eine tiefe Git-Integration mit integrierten Sicherheitsprotokollen.

Sicherheitsprotokolle

• Respektiert .gitignore automatisch
• Ändert keine Branches ohne Erlaubnis
• Zeigt Diffs vor Commits
• Befolgt die Commit-Konventionen des Projekts
• Führt niemals Force-Pushes ohne explizite Anfrage durch
• Prüft die Urheberschaft vor dem Amenden von Commits

Häufige Workflows

Commits erstellen:

> commit these changes
> create a commit with a meaningful message

Claude wird: 1. git status und git diff ausführen 2. Änderungen analysieren 3. Eine konventionelle Commit-Nachricht generieren 4. Auf Genehmigung warten, bevor der Commit durchgeführt wird

Pull Requests erstellen:

> create a PR for this feature
> summarize the changes and create a PR

Code überprüfen:

> review the changes in this PR
> what could go wrong with these changes?

GitHub Actions-Integration

Automatisieren Sie Claude in CI/CD mit der offiziellen Action:

Schnelle Einrichtung:

> /install-github-app

Manuelle Workflow-Datei:

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]
  issue_comment:
    types: [created]

jobs:
  claude-review:
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: "Review this PR for bugs, security issues, and performance problems"
          claude_args: "--max-turns 5"

Für Bedrock (mit OIDC):

- name: Configure AWS
  uses: aws-actions/configure-aws-credentials@v4
  with:
    role-to-assume: ${{ secrets.AWS_ROLE_TO_ASSUME }}
    aws-region: us-west-2

- uses: anthropics/claude-code-action@v1
  with:
    use_bedrock: "true"
    claude_args: '--model us.anthropic.claude-sonnet-4-5-20250929-v1:0'

Wie verwende ich Claude Code in meiner IDE?

VS Code-Erweiterung

Anforderungen: VS Code 1.98.0+

Installation: Suchen Sie „Claude Code” im Extensions-Marktplatz

Funktionen: - Seitenleistenpanel (Spark-Symbol) - Plan-Modus mit Diff-Vorschau - Auto-Accept-Edits-Umschalter - Extended-Thinking-Umschalter - Dateianhang und Bild-Einfügen - Konversationsverlauf - Mehrere gleichzeitige Sitzungen

Sicherheitshinweis: Eine WebSocket-Authentifizierungs-Bypass-Schwachstelle (CVE-2025-52882) wurde in IDE-Erweiterungen v1.0.24+ gepatcht. Stellen Sie sicher, dass Ihre Erweiterung aktualisiert ist—alle anfälligen Versionen wurden aus den Erweiterungs-Stores entfernt.³⁸

Konfiguration für Drittanbieter (in .claude/settings.json):

{
  "env": {
    "CLAUDE_CODE_USE_BEDROCK": "1",
    "AWS_REGION": "us-east-1",
    "AWS_PROFILE": "your-profile"
  }
}

JetBrains-Plugin

Unterstützt: IntelliJ IDEA, PyCharm, WebStorm, GoLand, PhpStorm, DataGrip

Installation: Settings → Plugins → Suchen Sie „Claude Code” → Install → Neustart

Wichtige Tastenkürzel: - Cmd+Esc (Mac) / Ctrl+Esc (Windows): Schnellstart - Cmd+Option+K (Mac) / Alt+Ctrl+K (Windows): Dateireferenz hinzufügen

Funktionen: - Diff-Anzeige im IDE-Diff-Viewer - Automatisches Teilen des Auswahlkontexts - Diagnose-Integration - Mehrere Sitzungen

WSL2-Konfiguration: Setzen Sie den Claude-Befehl auf:

wsl -d Ubuntu -- bash -lic "claude"

Terminal-Integration

Verbinden Sie ein externes Terminal mit Ihrer IDE:

> /ide

Claude Code erkennt automatisch VS Code, Cursor, Windsurf und JetBrains-IDEs.

Slack-Integration (Dezember 2025)

Claude Code integriert sich jetzt direkt mit Slack und ermöglicht Entwicklern, Programmieraufgaben aus Chat-Threads zu delegieren.¹⁴

Wie es funktioniert: 1. Erwähnen Sie @Claude in einem Slack-Kanal oder Thread 2. Claude überprüft die Nachricht, um festzustellen, ob es sich um eine Programmieraufgabe handelt 3. Eine Claude Code-Sitzung startet automatisch auf der Anthropic-Infrastruktur 4. Claude sammelt Kontext aus aktuellen Kanal-/Thread-Nachrichten 5. Fortschrittsupdates werden in Ihren Slack-Thread gepostet 6. Links zur Überprüfung von Änderungen und zum Öffnen von PRs werden bei Abschluss bereitgestellt

Anwendungsfälle: - Fehleruntersuchung basierend auf in Slack geposteten Fehlerberichten - Schnelle Code-Reviews basierend auf Team-Feedback - Kleine Feature-Implementierungen aus Feature-Anfragen

Anforderungen: - Claude-App über den Slack App Marketplace installiert - Bezahlter Slack-Plan - Zugriff auf Claude Code im Web

Datenschutz: Claude respektiert die bestehende Berechtigungsstruktur von Slack. Es kann nicht auf Konversationen oder Repositories zugreifen, für die Sie keine Berechtigung haben. Konversationen werden nicht für das Modelltraining verwendet.

Erweiterte Nutzungsmuster

Headless- und CI-Modus

Führen Sie Claude Code in Skripten und CI-Pipelines aus:

#!/bin/bash
# Automated code review

result=$(claude -p "Review this code for quality issues" \
  --output-format json \
  --allowedTools "Read,Grep,Glob" \
  --permission-mode plan \
  --disable-slash-commands \
  --max-turns 5)

if echo "$result" | jq -e '.result | test("critical|high severity")' > /dev/null; then
  echo "Issues found:"
  echo "$result" | jq -r '.result'
  exit 1
fi

echo "Review passed"
exit 0

Piping und Verkettung

# Analyze logs
cat production.log | claude -p "summarize errors" > error-summary.md

# Process multiple files
find . -name "*.ts" -exec cat {} \; | claude -p "find security issues"

# Chain with jq
claude -p "generate config" --output-format json | jq -r '.result' > config.json

Hintergrundaufgaben

Führen Sie langwierige Operationen aus, ohne den Arbeitsablauf zu blockieren:

> start the build in the background

Oder drücken Sie Ctrl+B während der Befehlsausführung.

Hintergrundaufgaben verwalten:

> /bashes                    # List running tasks
> get output from task xyz   # Retrieve output

Parallele Sitzungen mit Git Worktrees

# Create worktrees for parallel work
git worktree add ../project-feature-a -b feature-a
git worktree add ../project-bugfix bugfix-123

# Run Claude in each
cd ../project-feature-a && claude --session-id "feature-a"
cd ../project-bugfix && claude --session-id "bugfix-123"

Jeder Worktree ist ein unabhängiges Projektverzeichnis mit eigener Sitzung.

JSON-Ausgabe parsen

result=$(claude -p "analyze this code" --output-format json)

# Extract fields
echo "Result: $(echo $result | jq -r '.result')"
echo "Cost: $(echo $result | jq -r '.total_cost_usd')"
echo "Session: $(echo $result | jq -r '.session_id')"
echo "Duration: $(echo $result | jq -r '.duration_ms')ms"

Programmatische Sitzungsverwaltung

# Named sessions for tracking
claude --session-id "feature-$(git branch --show-current)-$(date +%s)"

# Continue previous work
claude -c "continue implementing the tests"

# Fork for parallel exploration
claude -r "main-session" --fork-session "try alternative approach"

Was ist Claude Code Remote?

Claude Code Remote überbrückt die Lücke zwischen Web und Terminal und ermöglicht es Ihnen, Aufgaben in der Cloud zu starten und lokal fortzusetzen – oder umgekehrt. Diese Funktion verändert grundlegend, wie Sie geräteübergreifend arbeiten.

Das Grundkonzept

Die Weboberfläche unter claude.ai/code führt Claude Code in der Cloud aus. Aufgaben werden im Hintergrund ausgeführt, während Sie nicht am Terminal sind. Wenn Sie bereit sind fortzufahren, teleportieren Sie die Sitzung auf Ihren lokalen Rechner und setzen genau dort an, wo Claude aufgehört hat.

Dies ermöglicht Arbeitsabläufe, die zuvor nicht möglich waren: - Starten Sie eine komplexe Refactoring-Aufgabe von Ihrem Smartphone, lassen Sie sie während des Pendelns laufen, und beenden Sie sie an Ihrem Arbeitsplatz - Reihen Sie mehrere Aufgaben über die Weboberfläche ein und überprüfen Sie die Ergebnisse, wenn Sie an Ihren Schreibtisch zurückkehren - Übergeben Sie langwierige Operationen an die Cloud, wenn Sie Ihren Laptop zuklappen müssen

Das &-Präfix

Senden Sie eine Aufgabe zur Ausführung im Hintergrund an Claude Code Web:

& Build a comprehensive REST API for user management with authentication, CRUD operations, and proper error handling

Das &-Präfix sendet Ihren Prompt an die Cloud. Claude arbeitet asynchron daran – Sie können Ihr Terminal schließen, das Gerät wechseln oder mit anderer Arbeit fortfahren. Die Weboberfläche unter claude.ai/code zeigt Ihre laufenden und abgeschlossenen Sitzungen an.

Das --teleport-Flag

Holen Sie eine Cloud-Sitzung in Ihr lokales Terminal:

claude --teleport session_abc123

Damit wird der Sitzungszustand aus dem Web abgerufen und lokal fortgesetzt. Sie erhalten den vollständigen Gesprächsverlauf, alle von Claude geänderten Dateien und können die Interaktion fortsetzen, als wären Sie die ganze Zeit dabei gewesen.

Die Sitzungs-ID wird in der Weboberfläche angezeigt. Klicken Sie auf eine beliebige Sitzung, um deren ID und aktuellen Status einzusehen.

Voraussetzungen

Claude Code Remote ist für Abonnenten von Pro, Max, Team (Premium-Plätze) und Enterprise (Premium-Plätze) verfügbar.⁷³ Die Weboberfläche läuft auf der Infrastruktur von Anthropic und führt dieselben Claude Code-Funktionen aus, die Ihnen lokal zur Verfügung stehen – Dateioperationen, Bash-Befehle, MCP-Integrationen – jedoch in einer verwalteten Cloud-Umgebung. Der Zugang für Team und Enterprise wurde im Januar 2026 erweitert – Kontoadministratoren können den Zugang in den Claude-Einstellungen aktivieren.

iOS-App (November 2025): Claude Code ist auch in der Claude iOS-App verfügbar, sodass Sie Programmieraufgaben unterwegs starten und den Fortschritt des Agenten von Ihrem Smartphone aus verfolgen können.²² Sie können Aufgaben starten, während Sie nicht am Schreibtisch sind, und sie später in Ihr Terminal teleportieren, wenn Sie bereit sind, die Ergebnisse zu überprüfen.

Praktischer Arbeitsablauf

Morgendlicher Pendelweg:

& Review all PRs assigned to me and prepare summaries with recommendations

Am Schreibtisch:

# Check what completed
# Visit claude.ai/code to see session list

# Pull the session locally to review and act on recommendations
claude --teleport pr-review-session-xyz

Vor Feierabend:

& Run the full test suite, fix any failures, and prepare a summary of what was changed

Am nächsten Morgen:

claude --teleport test-fixes-session-abc
# Review what Claude did overnight, make final adjustments

Aktueller Status

Claude Code Remote befindet sich derzeit in der Forschungsvorschau. Erwarten Sie, dass sich die Funktion weiterentwickelt, während Anthropic Feedback sammelt. Der grundlegende Arbeitsablauf – Cloud-Ausführung mit lokaler Teleportation – ermöglicht kontinuierliche KI-gestützte Entwicklung: Claude arbeitet, während Sie nicht am Rechner sind, und Sie setzen genau dort fort, wo es aufgehört hat.

Aktuelle Einschränkung: Die Sitzungsteleportation funktioniert derzeit nur in eine Richtung – Sie können Web-Sitzungen in Ihr Terminal holen, aber keine bestehende Terminal-Sitzung ins Web übertragen. Es gibt noch keine Möglichkeit, eine lokale Sitzung auf einem Remote-Rechner fortzusetzen (z. B. einer AWS-Instanz über SSH).

Was sind Background Agents?

Background Agents laufen weiter, während Sie an anderen Aufgaben arbeiten – kein Warten auf langwierige Aufgaben mehr.¹⁷

Wie Background Agents funktionieren

Anstatt Ihr Terminal zu blockieren, während Claude eine komplexe Aufgabe ausführt, arbeiten Background Agents wie folgt: 1. Sie laufen unabhängig in einem separaten Prozess 2. Sie arbeiten weiter, auch wenn Sie Ihr Terminal schließen 3. Sie melden Ergebnisse per Benachrichtigung, sobald sie fertig sind 4. Sie können während der Ausführung überwacht und verwaltet werden

Einen Background Agent starten

Mit Ctrl+B: Während Claude arbeitet, drücken Sie Ctrl+B, um die aktuelle Aufgabe in den Hintergrund zu verschieben. Ihr Terminal ist sofort wieder verfügbar.

Mit dem &-Präfix:

& Run all tests and fix any failures
& Refactor the authentication module to use JWT
& Generate comprehensive API documentation

Das &-Präfix sendet die Aufgabe an Claude Code Remote (Cloud-Ausführung). Für lokale Hintergrundausführung verwenden Sie Ctrl+B bei einer bereits laufenden Aufgabe.

Hintergrundaufgaben überwachen

> /tasks                    # List all running tasks
> /task status abc123       # Check specific task
> /task cancel abc123       # Stop a task
> /task output abc123       # View task output so far

Parallele Hintergrund-Arbeitsabläufe

Führen Sie mehrere Agenten gleichzeitig aus:

& Fix all failing tests in src/
& Update documentation for the API module
& Run security scan on the codebase

Jeder läuft unabhängig. Überwachen Sie den Fortschritt mit /tasks und rufen Sie Ergebnisse ab, sobald sie fertig sind.

Claude in Chrome (Dezember 2025)

Claude Code integriert sich jetzt über die Claude in Chrome-Erweiterung in Ihren Browser und ermöglicht die direkte Browsersteuerung aus Ihrem Terminal.²⁴

Einrichtung

1. Installieren Sie die Chrome-Erweiterung von https://claude.ai/chrome
2. Starten Sie Claude Code – die Integration wird automatisch erkannt
3. Verwenden Sie natürliche Sprache, um Ihren Browser zu steuern

Funktionsumfang

Browser-Automatisierung aus dem Terminal:

> Navigate to github.com and open my repositories
> Fill out this form with the test user data
> Take a screenshot of the current page
> Click the submit button and wait for the page to load

Web Scraping und Tests:

> Extract all product prices from this e-commerce page
> Run through the signup flow and report any issues
> Check if the mobile menu works correctly

Anwendungsfälle

• E2E-Tests: Führen Sie Integrationstests direkt aus Claude Code aus
• Web Scraping: Extrahieren Sie Daten von Webseiten, ohne Browser-Automatisierungscode schreiben zu müssen
• Formularausfüllung: Automatisieren Sie wiederkehrende Web-Arbeitsabläufe
• Visuelle Überprüfung: Erstellen Sie Screenshots und analysieren Sie Seitenlayouts

Die Chrome-Integration läuft innerhalb Ihrer bestehenden Browser-Sitzung und greift auf Ihren angemeldeten Zustand und Ihre Cookies zu – nützlich für das Testen authentifizierter Abläufe.

Claude Code in Slack (Dezember 2025)

Anthropic hat Claude Code in Slack eingeführt, wodurch Entwickler Programmieraufgaben direkt aus Chat-Threads delegieren können.²⁶

Funktionsweise

1. Erwähnen Sie @Claude in einem beliebigen Slack-Kanal oder Thread
2. Beschreiben Sie die Programmieraufgabe mit Kontext
3. Claude analysiert die Slack-Nachrichten, um das Repository zu ermitteln
4. Fortschrittsmeldungen erscheinen im Thread
5. Claude teilt Links zur Überprüfung der Arbeit und zum Öffnen von PRs

Beispiel-Arbeitsablauf

@Claude The login form validation is broken on mobile devices.
Can you fix it? Check the bug report from earlier in this thread.

Claude wird: 1. Den Thread lesen, um Kontext zu erhalten 2. Das relevante Repository identifizieren 3. Die Codebasis klonen und analysieren 4. Fortschrittsmeldungen posten 5. Einen PR mit der Korrektur erstellen 6. Den PR-Link zur Überprüfung teilen

Vorteile

• Kontextbewusstsein: Claude liest den Slack-Verlauf für Fehlerberichte, Feature-Anfragen und Diskussionen
• Team-Sichtbarkeit: Fortschrittsmeldungen in Threads halten alle Beteiligten auf dem Laufenden
• Geringe Einstiegshürde: Kein Terminal oder IDE erforderlich – starten Sie direkt aus dem Chat
• GitHub-Integration: PRs werden automatisch mit aussagekräftigen Beschreibungen erstellt

Voraussetzungen

• Slack-Workspace mit aktivierter Claude-Integration
• Verbundenes GitHub-Repository
• Entsprechende Berechtigungen für Claude zum Erstellen von Branches/PRs

Diese Funktion befindet sich derzeit in der Forschungsvorschau für Pro-, Max-, Team- und Enterprise-Benutzer.

Was kostet Claude Code?

Das Verständnis und die Kontrolle der Kosten sind für eine nachhaltige Nutzung von Claude Code unerlässlich.

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 führte wöchentliche Ratenlimits für zahlende Abonnenten ein. Max-Abonnenten können zusätzliche Nutzung über das Ratenlimit hinaus zu Standard-API-Tarifen erwerben.²¹

API Token-Preise (Januar 2026)⁵⁷

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

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

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

Richtlinie für mehrere Konten⁵⁹

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

Was erlaubt ist:

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

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

Praxishinweis: Im Januar 2026 wurden 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 hinweg nutzen, ist das genau das, wofür der Service konzipiert ist – versuchen Sie nur 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-basierte Preisgestaltung hinaus fallen für einige Tools separate Gebühren an:¹⁶

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

Strategien zur Kostensenkung

1. Haiku für Subagents verwenden: Die meisten Explorationen benötigen kein Sonnet
2. Prompt Caching aktivieren: Standard, aber überprüfen Sie, ob es nicht deaktiviert ist
3. Max Turns setzen: claude --max-turns 5 verhindert ausufernde Konversationen
4. Plan-Modus für Exploration verwenden: Keine Ausführung = keine versehentlichen teuren Operationen
5. Proaktiv komprimieren: Kleinerer Kontext = weniger Token
6. Output begrenzen: export CLAUDE_CODE_MAX_OUTPUT_TOKENS=2000
7. Batch API für nicht dringende Arbeiten: 50% Rabatt auf Input- und Output-Token

Nutzungsüberwachung

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

Hintergrund-Token-Verbrauch

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

Typischerweise unter $0,04 pro Sitzung.

Claude Code Analytics API (Team/Enterprise)⁵³

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

Endpoint: GET /v1/organizations/usage_report/claude_code

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

Verfügbare Metriken:

Beispielanfrage:

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

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

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

Leistungsoptimierung

Latenz reduzieren

Modellauswahl: - Haiku: Schnellste Antworten, niedrigste Kosten - Sonnet: Gute Balance - Opus: Beste Qualität, höchste Latenz

Streaming: Alle Antworten werden standardmäßig gestreamt – Sie sehen die Ausgabe, während sie generiert wird.

Prompt Caching: Standardmäßig aktiviert. Reduziert die Latenz für wiederholten Kontext (System-Prompts, Tool-Definitionen).

Caching-Strategien

System-Prompts und Tool-Definitionen werden automatisch gecacht: - Cache-Dauer: 5 Minuten (ephemeral) - Cache-Treffer: Reduzierte Input-Token und schnellere Antwort

Thinking-Blöcke aus vorherigen Turns werden in Multi-Turn-Konversationen gecacht.

Deaktivieren Sie das Caching pro Modell bei Bedarf:

export DISABLE_PROMPT_CACHING_SONNET=1
export DISABLE_PROMPT_CACHING_OPUS=1
export DISABLE_PROMPT_CACHING_HAIKU=1

Parallele Operationen

Subagent-Parallelisierung: Mehrere Subagents können gleichzeitig ausgeführt werden. Jeder arbeitet unabhängig, ohne den Hauptkontext zu verunreinigen.

Hintergrund-Bash: Lang laufende Befehle blockieren die Konversation nicht:

> run the full test suite in the background

Git Worktrees: Ermöglichen echte parallele Sitzungen auf separaten Branches.

Speicheroptimierung

• Spezifische Dateireferenzen: @src/auth.ts statt „finde die Auth-Datei”
• Gezielte Suchen: „suche in src/api” nicht „suche überall”
• Frische Sitzungen: /clear zwischen nicht zusammenhängenden Aufgaben
• Benutzerdefinierte Komprimierung: Fügen Sie Anweisungen zu CLAUDE.md hinzu, was erhalten bleiben soll

Wie debugge ich Probleme?

Installationsprobleme

WSL-Pfadprobleme:

npm config set os linux
npm install -g @anthropic-ai/claude-code --force --no-os-check
which npm  # Should start with /usr not /mnt/c

Node-Versionskonflikte (nvm): Fügen Sie zu ~/.bashrc oder ~/.zshrc hinzu:

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"

Berechtigungsfehler: Verwenden Sie die native Installation anstelle von npm:

curl -fsSL https://claude.ai/install.sh | bash

Authentifizierungsprobleme

# Vollständiger Reset
/logout
rm -rf ~/.config/claude-code/auth.json
claude  # Neue Anmeldung

Leistungsprobleme

Hohe CPU-/Speicherauslastung: - Verwenden Sie /compact, um den Kontext zu reduzieren - Neustart zwischen größeren Aufgaben - Große Verzeichnisse zu .gitignore hinzufügen - claude doctor ausführen

Langsame Suche: Installieren Sie ripgrep systemweit:

# macOS
brew install ripgrep

# Windows
winget install BurntSushi.ripgrep.MSVC

# Linux
sudo apt install ripgrep

Dann:

export USE_BUILTIN_RIPGREP=0

Langsam unter WSL: - Projekt ins Linux-Dateisystem verschieben (nicht /mnt/c/) - Spezifische Verzeichnisfilter in Suchen verwenden

IDE-Integrationsprobleme

JetBrains wird nicht erkannt (WSL2):

Option 1 - Windows Firewall:

wsl hostname -I  # Get WSL IP
New-NetFirewallRule -DisplayName "Allow WSL2" -Direction Inbound -Protocol TCP -Action Allow -RemoteAddress 172.21.0.0/16

Option 2 - Mirrored Networking (zu ~/.wslconfig hinzufügen):

[wsl2]
networkingMode=mirrored

Dann: wsl --shutdown

Escape-Taste funktioniert nicht in JetBrains: Einstellungen → Tools → Terminal → Häkchen bei „Move focus to the editor with Escape” entfernen

Debug-Modus

claude --debug                    # Vollständige Debug-Ausgabe
ANTHROPIC_LOG=debug claude       # API-Anfragen-Logging
claude doctor                    # Gesundheitscheck

Konfiguration zurücksetzen

# Benutzereinstellungen zurücksetzen
rm ~/.claude.json
rm -rf ~/.claude/

# Projekteinstellungen zurücksetzen
rm -rf .claude/
rm .mcp.json

Häufige Fehlermeldungen

Enterprise-Bereitstellung

Vergleich der Cloud-Anbieter

Bereitstellung verwalteter Einstellungen

Organisationsweite Richtlinien über managed-settings.json bereitstellen:

Speicherort: - macOS: /Library/Application Support/ClaudeCode/managed-settings.json - Linux: /etc/claude-code/managed-settings.json - Windows: C:\Program Files\ClaudeCode\managed-settings.json

Beispielrichtlinie:

{
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Bash(npm run:*)",
      "Bash(git:*)"
    ],
    "deny": [
      "Bash(rm -rf:*)",
      "Bash(curl:*)",
      "Read(.env*)",
      "WebFetch"
    ],
    "defaultMode": "default"
  },
  "model": "claude-sonnet-4-5-20250929",
  "disableBypassPermissionsMode": "disable"
}

Benutzer können verwaltete Einstellungen nicht überschreiben.

Enterprise CLAUDE.md

Organisationsweiten Kontext bereitstellen:

Speicherort: - macOS: /Library/Application Support/ClaudeCode/CLAUDE.md - Linux: /etc/claude-code/CLAUDE.md

Inhalt:

# Company Standards

## Security Requirements
- Never commit secrets or credentials
- All external API calls require security review
- Use parameterized queries for all database access

## Code Standards
- Follow company style guide at @docs/STYLE.md
- All PRs require two approvals
- Test coverage minimum: 80%

## Approved Tools
- npm, yarn, pnpm for package management
- Jest for testing
- ESLint + Prettier for formatting

Rollout-Strategie

1. Mit Dokumentation beginnen: CLAUDE.md richtig aufsetzen, bevor die Bereitstellung erfolgt
2. Pilotgruppe: Mit 5–10 Entwicklern starten
3. Frage-und-Antwort-Phase: Pilotnutzern die Code-Exploration mit Claude ermöglichen
4. Begleitete Entwicklung: Zu kleinen Fehlerbehebungen übergehen
5. Vollständige Bereitstellung: Mit verwalteten Einstellungen ausrollen
6. Kosten überwachen: Nutzung pro Team verfolgen

Audit und Compliance

• Sitzungsprotokolle werden standardmäßig lokal gespeichert
• Cloud-Anbieter-Protokollierung für Enterprise-Audits nutzen
• LiteLLM für detaillierte Nutzungsverfolgung in Betracht ziehen
• Verwaltete Einstellungen setzen Compliance-Richtlinien durch

Analytics API (Admin)

Enterprise- und Team-Pläne haben Zugang zur Claude Code Analytics API für die programmatische Nutzungsverfolgung.

Endpunkt: GET /v1/organizations/usage_report/claude_code

Authentifizierung: Erfordert einen Admin API key (sk-ant-admin...), der in der Console von Organisationsadministratoren bereitgestellt wird.

Verfügbare Metriken:

Anfrageparameter: - starting_at – Datum für tägliche Aggregation (YYYY-MM-DD) - Gibt benutzerbezogene Daten für den angegebenen Tag zurück

Beispiel:

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

Einschränkungen: - Nur tägliche Aggregate (~1 Std. Verzögerung für Konsistenz) - Für Echtzeit-Überwachung die OpenTelemetry-Integration verwenden - Erfasst nur die Nutzung der 1st-Party-API (nicht Bedrock/Vertex)

Kosten: Kostenlos für Organisationen mit Admin API-Zugang.

Tastenkombinationen – Referenz

Allgemeine Steuerung

Anpassbare Tastenkombinationen (v2.1.18+): Führen Sie /keybindings aus, um Tastenkombinationen anzupassen. Unterstützt kontextspezifische Zuordnungen, Chord-Sequenzen (Mehrfachtasten-Kombinationen) und vollständige Personalisierung. Tastenkombinationen werden in ~/.claude/keybindings.json gespeichert. Siehe Keybindings-Dokumentation für die vollständige Konfigurationsreferenz.⁷⁷

Prompt-Vorschläge (Dez. 2025): Claude schlägt jetzt Prompts vor, um Ihren Workflow zu beschleunigen. Drücken Sie Tab, um einen Vorschlag anzunehmen, oder Enter, um Ihren eigenen Prompt abzusenden.¹³

Mehrzeilige Eingabe

Schnellpräfixe

Dateireferenz-Performance (Jan. 2026): @-Erwähnungen sind jetzt 3× schneller in Git-Repositorys. Claude Code berücksichtigt auch .ignore- und .rgignore-Dateien bei Dateivorschlägen – nützlich, um Build-Artefakte oder generierte Dateien aus den Vorschlägen auszuschließen.³⁵

Vim-Modus

Aktivieren mit /vim:

Normal-Modus: - h/j/k/l – Navigation - w/e/b – Wortweise Bewegung - 0/$ – Zeilenanfang/-ende - gg/G – Pufferanfang/-ende - dd – Zeile löschen - cc/C – Zeile ändern/bis zum Ende ändern - dw/de/db – Wort-Löschvarianten - x – Zeichen löschen - . – Letzte Bearbeitung wiederholen

Einfügemodus: - i/I – Vor dem Cursor/am Zeilenanfang einfügen - a/A – Nach dem Cursor/am Zeilenende einfügen - o/O – Neue Zeile darunter/darüber öffnen - Esc – Zurück zum Normal-Modus

Bewährte Vorgehensweisen

Sitzungsstrategie

Verwenden Sie aussagekräftige Sitzungs-IDs:

claude --session-id "feature-$(git branch --show-current)-$(date +%s)"
claude --session-id "bug-JIRA-456"
claude --session-id "spike-new-architecture"

Setzen Sie Sitzungen für laufende Arbeit fort, anstatt den Kontext erneut zu erklären.

CLAUDE.md-Gestaltung

Übersichtlich halten. Claude liest diese Datei bei jeder Sitzung – dichter Fließtext verschwendet Kontext.

Auf Nicht-Offensichtliches fokussieren. Projektspezifische Muster, ungewöhnliche Konventionen und Entscheidungen dokumentieren. Überspringen Sie, was Claude aus dem Code ableiten kann.

Kontinuierlich aktualisieren. Während der Entwicklung Notizen mit # hinzufügen. Wöchentlich überprüfen und konsolidieren.

Befehlsreferenz einschließen. Die Befehle, die Sie ständig verwenden, sollten dokumentiert sein.

Benutzerdefinierte Befehle

Erstellen Sie Befehle für wiederkehrende Arbeitsabläufe:

---
description: Start new feature
allowed-tools: Bash(git:*), Read, Edit
---

1. Create branch: !`git checkout -b feature/$ARGUMENTS`
2. Pull latest main
3. Set up boilerplate
4. Begin implementation

Effektives Prompting

Seien Sie spezifisch:

# Good
"Add email validation to LoginForm in src/components/LoginForm.tsx"

# Too vague
"Improve the login"

Dateien direkt referenzieren:

"Review @src/auth/middleware.ts for security issues"

Einschränkungen angeben:

"Refactor using the same pattern as @src/repositories/UserRepository.ts"

Subagents für die Exploration nutzen:

"Have an explore agent find all places where we handle errors"

Kostenkontrolle

• Regelmäßig /cost verwenden
• Haiku für einfache Aufgaben und Subagents nutzen
• MAX_THINKING_TOKENS nur bei Bedarf setzen
• --max-turns für automatisierte Skripte verwenden
• In langen Sitzungen proaktiv komprimieren

Sicherheit

• Ablehnungsregeln für sensible Dateien in .claude/settings.json konfigurieren
• Sandbox-Modus für nicht vertrauenswürdige Projekte verwenden
• Niemals Bash(rm -rf:*) oder Bash(sudo:*) erlauben
• Hooks verwenden, um den Zugriff auf Geheimnisse zu blockieren
• Verwaltete Einstellungen für den Enterprise-Einsatz bereitstellen

Community-Tipps und -Techniken⁵⁶⁵⁸

Die Claude Code-Community hat leistungsstarke Muster entdeckt, die über die offizielle Dokumentation hinausgehen. Diese Tipps stammen von Power-Usern, darunter Boris Cherny (Claude Code-Entwickler) und dem Repository mit über 40 Tipps.

Plan Mode vor dem Programmieren verwenden

Wenn Sie sich nur einen Tipp merken, dann diesen. Je mehr Zeit Sie mit der Planung verbringen, desto wahrscheinlicher ist der Erfolg von Claude. Drücken Sie Shift+Tab, um vor der Implementierung in den Plan Mode zu wechseln.

Neu im Januar 2026: Wenn Sie einen Plan akzeptieren, bietet Claude jetzt an, Ihren Kontext automatisch zu leeren, wodurch der Plan ein frisches Kontextfenster erhält. Dies verbessert die Planeinhaltung erheblich – Claude bleibt länger auf Kurs, ohne dass alter Kontext stört. Die Optionen umfassen: „Ja, Kontext leeren und Bearbeitungen automatisch akzeptieren” (Shift+Tab), „Ja, und Bearbeitungen manuell genehmigen” oder „Ja, Bearbeitungen automatisch akzeptieren” (ohne Leeren).

Kontext häufig leeren

Verwenden Sie /clear oft. Jedes Mal, wenn Sie etwas Neues beginnen, leeren Sie den Chat. Sie benötigen keine alte Historie, die Token verbraucht oder teure Komprimierungsaufrufe auslöst. Leeren Sie einfach und machen Sie weiter.

Bilder und Screenshots verwenden

Claude ist hervorragend bei visueller Eingabe. Unter macOS: Cmd+Ctrl+Shift+4 erfasst einen Screenshot in die Zwischenablage, dann Ctrl+V zum direkten Einfügen in Claude Code. Nutzen Sie dies, um UI-Mockups, Fehlermeldungen oder Design-Referenzen zu teilen.

GitHub App für PR-Reviews installieren

Führen Sie /install-github-app aus und Claude wird automatisch Ihre PRs überprüfen. Dies ist besonders wertvoll, da KI-gestützte Entwicklung das PR-Volumen erhöht – Claude erkennt oft Logikfehler und Sicherheitsprobleme, die menschliche Reviewer übersehen.

Container-basierter autonomer Betrieb

Für vollständig autonomen Betrieb führen Sie Claude Code in einem Docker-Container mit tmux als Steuerungsschicht aus. Ihr lokales Claude Code steuert die containerisierte Instanz, die langläufige oder experimentelle Aufgaben ohne manuelle Genehmigung ausführen kann. Wenn etwas schiefgeht, ist es isoliert.

# Conceptual pattern (varies by setup)
# Local Claude Code → tmux → Container Claude Code
# Results pulled back when complete

Docker Sandbox Mode (Schnellstart): Claude Code unterstützt eine vereinfachte Docker-Sandbox über den docker-Unterbefehl. Dies erstellt eine isolierte Umgebung zum Erkunden nicht vertrauenswürdiger Codebasen oder zum sicheren Ausführen experimenteller Prompts.⁶³

# Run Claude Code in Docker sandbox
docker sandbox run claude

# Or with specific project
docker sandbox run claude /path/to/project

Verwenden Sie den Sandbox-Modus, wenn Sie: - Unbekannte oder nicht vertrauenswürdige Codebasen erkunden - Experimentelle Prompts testen, die Dateien ändern könnten - Autonome Sitzungen ausführen möchten, die Sie vollständig isoliert haben wollen - Claude Code ohne Risiko für Ihre tatsächlichen Dateien erlernen möchten

Gemini CLI als Fallback

Das WebFetch-Tool von Claude Code kann auf bestimmte Websites (wie Reddit) nicht zugreifen. Erstellen Sie einen Skill, der Claude anweist, Gemini CLI als Fallback zu verwenden – Gemini hat Webzugriff und kann Inhalte von Websites abrufen, die Claude nicht direkt erreichen kann.

Meta-Agent Factory Pattern

Anstatt Agenten zu erstellen, die Aufgaben erledigen, erstellen Sie einen Agenten, der andere Agenten erstellt. Das ist keine clevere Rekursion – es ist ein echter Produktivitätsmultiplikator für komplexe Automatisierungs-Workflows.

Claude Squad: Multi-Agent Manager

Claude Squad verwaltet mehrere Claude Code-Instanzen parallel, jede in ihrer eigenen tmux-Sitzung mit isolierten Worktrees. Führen Sie mehrere Agenten gleichzeitig für verschiedene Aufgaben aus, überwachen Sie deren Fortschritt von einem einzigen Dashboard aus und rufen Sie die Ergebnisse ab, wenn sie fertig sind.⁶⁵

# Install
npm install -g @smtg-ai/claude-squad

# Start multiple agents
claude-squad start "Implement auth feature" --worktree auth-feature
claude-squad start "Write API tests" --worktree api-tests
claude-squad start "Update documentation" --worktree docs-update

# Monitor all agents
claude-squad status

Anwendungsfälle: - Unabhängige Features parallel auf Agenten verteilen - Explorative Prompts ausführen, ohne Ihre Hauptsitzung zu blockieren - Autonomes Programmieren über ein einzelnes Kontextfenster hinaus skalieren

Produktivitätsstatistiken von Power-Usern

Boris Cherny demonstrierte das Potenzial von Claude Code: In 30 Tagen landete er 259 PRs mit 497 Commits – 40.000 hinzugefügte und 38.000 entfernte Zeilen. Dies zeigt, was möglich ist, wenn Claude Code vollständig in den Entwicklungsworkflow integriert ist.

Personen zum Folgen

Bleiben Sie über Claude Code-Entwicklungen auf dem Laufenden, indem Sie diesen Accounts folgen:

Anthropic-Team (Primärquellen)

Top Content-Ersteller

Wichtige Ressourcen

• GitHub Releases: anthropics/claude-code/releases – Nur Releases beobachten
• Discord: Anthropic-Community-Kanäle
• Vollständige Liste: Siehe ~/.claude/docs/following-list.md für 20+ kuratierte Accounts

Boris und das Anthropic-Team teilen Features, sobald sie veröffentlicht werden – oft der schnellste Weg, um neue Funktionen kennenzulernen, bevor die Dokumentation nachzieht.

Häufige Anti-Patterns

Zu lernen, was man NICHT tun sollte, bietet oft mehr Wert als Best Practices. Diese Muster verursachen durchgehend Probleme:

Kosten-Anti-Patterns

Kontext-Anti-Patterns

Workflow-Anti-Patterns

Konfigurations-Anti-Patterns

Prompt-Anti-Patterns

Workflow-Rezepte

End-to-End-Muster für häufige Szenarien.

Rezept 1: Ein neues Projekt starten

# 1. Initialize
cd my-project
claude

# 2. Let Claude understand the codebase
> "Explore this codebase and summarize the architecture"

# 3. Set up project configuration
> /init

# 4. Create CLAUDE.md with learned patterns
> "Create CLAUDE.md documenting the patterns you observed"

# 5. Add team commands
> "Create a /test command that runs our test suite"
> "Create a /deploy command for staging deployment"

Rezept 2: Täglicher Entwicklungs-Flow

# 1. Continue yesterday's session
claude -c

# 2. Quick context recap
> "What did we work on yesterday?"

# 3. Check current state
> /status

# 4. Work on feature (Sonnet handles most tasks)
> "Implement the user profile endpoint"

# 5. Proactive context management
> /compact  # Before context exceeds 50%

# 6. Check spending
> /cost

# 7. End session cleanly
> "Summarize what we accomplished today"

Rezept 3: Komplexes Refactoring

# 1. Use Opus for planning, Sonnet for execution
> /model opusplan

# 2. Plan the refactoring
> "Plan refactoring our authentication from sessions to JWT"

# 3. Review the plan
# (Claude presents approach, you approve or modify)

# 4. Execute with Sonnet
> "Execute the plan"

# 5. Verify nothing broke
> "Have an explore agent verify all auth-related tests pass"

# 6. Review the diff
> !git diff

Rezept 4: PR-Review-Automatisierung

# In CI/CD (GitHub Actions, etc.)
claude -p "Review this PR for:" \
  --input-file pr_diff.txt \
  --output-format json \
  --permission-mode plan \
  --max-turns 5 << EOF
- Security vulnerabilities
- Performance issues
- Code style violations
- Missing test coverage
Provide findings in JSON format.
EOF

Rezept 5: Produktionsprobleme debuggen

# 1. Configure Sentry MCP for error access
claude --add-mcp sentry

# 2. Get error context
> "Fetch the last 10 errors from Sentry for the auth service"

# 3. Deep dive with thinking
> Tab  # Enable extended thinking
> "Analyze these errors and identify the root cause"

# 4. Fix and verify
> "Implement a fix and add a regression test"
> !npm test

Migrationsleitfaden

Sie kommen von anderen KI-Coding-Tools? Hier sehen Sie, wie sich die Konzepte zuordnen lassen.

Von GitHub Copilot

Was Sie gewinnen: Echte agentische Fähigkeiten—Claude Code liest Ihre Codebasis, führt Tests aus, erstellt PRs und delegiert an Subagents. Nicht nur Vorschläge.

Von Cursor

Was Sie gewinnen: MCP-Integrationen (Datenbanken, GitHub, Sentry), Subagent-Delegation, Hooks für Automatisierung und Terminal-nativer Workflow.

Von ChatGPT / Claude Web

Was Sie gewinnen: Alles. Web-Interfaces erfordern Kopieren-Einfügen-Workflows; Claude Code arbeitet direkt an Ihrer Codebasis.

Wichtige Denkweise-Änderungen

1. Hören Sie auf, Code zu kopieren. Claude Code schreibt direkt in Dateien.
2. Hören Sie auf, den Kontext zu wechseln. MCP bringt externe Tools in die Session.
3. Delegieren Sie aggressiv. Subagents übernehmen die Erkundung, ohne Ihren Kontext aufzublähen.
4. Automatisieren Sie mit Hooks. Formatierung, Linting und Logging geschehen automatisch.
5. Denken Sie in Sessions. Setzen Sie die Arbeit mit -c fort, nicht mit neuen Konversationen.

Wichtige Erkenntnisse

Für Entwickler: - Haiku kostet 10-20x weniger als Opus—verwenden Sie es für Subagents und einfache Aufgaben - Verwenden Sie /compact proaktiv während langer Sessions zur Kontextverwaltung - Session-IDs mit Kontext-Kodierung (feature-${branch}-${timestamp}) helfen bei der Navigation zu früherer Arbeit - Stellen Sie häufigen Prompts # voran, um sie ohne zusätzliche Eingabe zum persistenten Speicher hinzuzufügen

Für DevOps- und Plattform-Teams: - Der Headless-Modus (-p Flag) ermöglicht CI/CD-Integration mit JSON-Ausgabe zum Parsen - Hooks garantieren die Ausführung unabhängig vom Modellverhalten—verwenden Sie sie für Linting, Formatierung und Sicherheitsprüfungen - MCP erweitert die Fähigkeiten auf Datenbanken, GitHub, Sentry und 300+ Integrationen - Hintergrundaufgaben (& Präfix) laufen auf Claude Code Remote für asynchrone Ausführung

Für Sicherheitsteams: - Berechtigungsregeln werden nach dem Prinzip „erste Übereinstimmung gewinnt” ausgewertet—strukturieren Sie Allow/Deny-Listen sorgfältig - Der Sandbox-Modus isoliert Dateisystem und Netzwerk für nicht vertrauenswürdige Codebasen - Bash-Muster matchen nur Präfixe—Bash(curl:*) blockiert alle curl-Befehle, nicht nur bestimmte URLs - Verwaltete Unternehmenseinstellungen können von Benutzern nicht überschrieben werden

Für Teamleiter: - Skills aktivieren sich automatisch basierend auf dem Kontext—betten Sie Domänenexpertise ohne explizite Aufrufe ein - Projekt-Skills werden in Git committet—Teammitglieder erhalten automatisch standardisierte Expertise - Kostenverfolgung über /cost zeigt die Session-Aufschlüsselung; budgetieren Sie 10k-300k TPM pro Benutzer basierend auf der Teamgröße - Benutzerdefinierte Befehle in .claude/commands/ erstellen wiederverwendbare Workflows

Für Enterprise-Architekten: - Verwaltete Einstellungen deployen organisationsweite Richtlinien über /etc/claude-code/managed-settings.json - AWS Bedrock, Google Vertex AI und Microsoft Foundry integrieren sich mit bestehender Cloud-Abrechnung - Extended Thinking (Tab zum Umschalten) verbessert komplexes Reasoning bei höheren Kosten - Starten Sie ein Pilotprojekt mit 5-10 Entwicklern vor dem vollständigen Rollout

Kurzreferenzkarte

Drucken Sie diese aus. Kleben Sie sie an Ihren Monitor.

╔═══════════════════════════════════════════════════════════════╗
║                    CLAUDE CODE QUICK REFERENCE                 ║
╠═══════════════════════════════════════════════════════════════╣
║  MODELS                                                        ║
║    haiku     $1/$5/M     Exploration, simple tasks            ║
║    sonnet    $3/$15/M    Daily coding (default)               ║
║    opus      $5/$25/M    Architecture, hard problems          ║
║    sonnet[1m] $6/$22.50/M Large codebases (1M context)        ║
╠═══════════════════════════════════════════════════════════════╣
║  ESSENTIAL COMMANDS                                            ║
║    /compact        Reduce context (do at 50% capacity)        ║
║    /cost           Check session spending                     ║
║    /model opus     Switch to Opus                             ║
║    /status         Show current state                         ║
║    /init           Set up project config                      ║
║    /mcp            Configure integrations                     ║
╠═══════════════════════════════════════════════════════════════╣
║  KEYBOARD SHORTCUTS                                            ║
║    Tab             Toggle extended thinking                   ║
║    Shift+Tab       Cycle permission modes                     ║
║    Ctrl+C          Interrupt current operation                ║
║    Esc → Esc       Rewind last change                         ║
║    Ctrl+L          Clear screen                               ║
╠═══════════════════════════════════════════════════════════════╣
║  PREFIXES                                                      ║
║    #message        Add to persistent memory                   ║
║    @path/file      Reference file in prompt                   ║
║    !command        Execute bash directly                      ║
║    &task           Send to cloud (async)                      ║
╠═══════════════════════════════════════════════════════════════╣
║  CONFIG FILE HIERARCHY (first found wins)                      ║
║    .claude/settings.local.json    Personal (gitignored)       ║
║    .claude/settings.json          Project (shared)            ║
║    ~/.claude/settings.json        User global                 ║
║    /etc/.../managed-settings.json Enterprise (locked)         ║
║    CLAUDE.md                      Project context             ║
╠═══════════════════════════════════════════════════════════════╣
║  DAILY WORKFLOW                                                ║
║    1. claude -c              Continue session                 ║
║    2. Work on features       Use Sonnet                       ║
║    3. /compact               Before context bloats            ║
║    4. /cost                  Check spending                   ║
║    5. Summarize              Clean exit                       ║
╠═══════════════════════════════════════════════════════════════╣
║  DECISION RULES                                                ║
║    Simple task?        → Haiku                                ║
║    Hard reasoning?     → Opus                                 ║
║    Everything else?    → Sonnet                               ║
║    Must always run?    → Hook (not prompt)                    ║
║    Auto-apply wisdom?  → Skill (not command)                  ║
║    Needs isolation?    → Subagent                             ║
╚═══════════════════════════════════════════════════════════════╝

Änderungsprotokoll

Diese Referenz ist ein lebendiges Dokument. Aktualisierungen werden angewendet, sobald sich Claude Code weiterentwickelt.

Führen Sie /update-cc-guide aus, um nach den neuesten Claude Code-Updates zu suchen und diese anzuwenden.

Referenzen