Claude Code: KI-gestützte Entwicklung auf der Kommandozeile

Stell dir vor, du beschreibst in natürlicher Sprache, was du programmieren möchtest - und ein KI-Agent setzt es direkt in deinem Terminal um. Er liest deinen Code, versteht den Kontext, schreibt Dateien, führt Befehle aus und testet das Ergebnis. Das ist Claude Code - ein agentenbasiertes CLI-Tool von Anthropic, das KI direkt in deine Entwicklungsumgebung bringt.

---

Was ist Claude Code?

Claude Code ist ein interaktives Kommandozeilen-Tool, das auf Anthropics Claude-Modellen basiert. Im Gegensatz zu Chat-basierten Assistenten, die nur Textantworten liefern, ist Claude Code ein vollwertiger Agent: Er kann Dateien lesen und schreiben, Shell-Befehle ausführen, im Web suchen und komplexe mehrstufige Aufgaben autonom abarbeiten.

Die wichtigsten Fähigkeiten:

• Codebases verstehen und navigieren
• Dateien erstellen, bearbeiten und löschen
• Git-Operationen durchführen
• Shell-Befehle ausführen
• Tests schreiben und ausführen
• Bugs finden und beheben
• Refactoring durchführen

Claude Code arbeitet lokal in deinem Terminal - dein Code verlässt nie deinen Rechner, nur die Konversation mit Claude wird über die API gesendet.

---

Installation und Erste Schritte

Voraussetzungen

• Node.js 18 oder höher
• Ein Anthropic API-Key (oder Claude Max Abo)

Installation

# Global installieren
npm install -g @anthropic-ai/claude-code

# Oder mit npx direkt ausführen
npx @anthropic-ai/claude-code

Erster Start

# In dein Projektverzeichnis wechseln
cd ~/mein-projekt

# Claude Code starten
claude

# Oder direkt mit einer Aufgabe starten
claude "Erkläre mir die Struktur dieses Projekts"

Beim ersten Start wirst du aufgefordert, dich zu authentifizieren. Du kannst entweder:

1. API-Key verwenden: Setze ANTHROPIC_API_KEY als Umgebungsvariable
2. Claude Max: Authentifiziere dich über den Browser

---

Die Konfigurationsdateien

Claude Code verwendet mehrere Konfigurationsdateien auf verschiedenen Ebenen. Das Verständnis dieser Hierarchie ist der Schlüssel zu effektiver Nutzung.

flowchart TB
    subgraph Global["Globale Konfiguration (~/.claude/)"]
        G_CLAUDE["CLAUDE.md"]
        G_SETTINGS["settings.json"]
        G_MCP[".claude.json (MCP)"]
    end

    subgraph Project["Projekt-Konfiguration (.claude/)"]
        P_CLAUDE["CLAUDE.md"]
        P_SETTINGS["settings.json"]
        P_LOCAL["settings.local.json"]
        P_MCP[".mcp.json"]
        P_RULES["rules/*.md"]
    end

    subgraph Root["Projekt-Root"]
        R_CLAUDE["CLAUDE.md"]
    end

    G_CLAUDE --> P_CLAUDE
    G_SETTINGS --> P_SETTINGS
    P_CLAUDE --> R_CLAUDE
    P_SETTINGS --> P_LOCAL

Priorität der Konfiguration

Die Konfigurationen werden in folgender Reihenfolge geladen (höhere überschreibt niedrigere):

Priorität	Scope	Ort	Zweck
1 (höchste)	Lokal	.claude/settings.local.json	Persönliche Projekt-Overrides
2	Projekt	.claude/settings.json	Team-geteilte Einstellungen
3	Benutzer	~/.claude/settings.json	Globale persönliche Settings
4 (niedrigste)	Managed	/etc/claude-code/	IT-verwaltete Einstellungen

---

CLAUDE.md - Das Gedächtnis von Claude

Die CLAUDE.md-Datei ist das Herzstück der Konfiguration. Sie wird bei jedem Gespräch geladen und gibt Claude Kontext über dein Projekt, deine Präferenzen und spezielle Anweisungen.

Wo kann CLAUDE.md liegen?

Ort	Scope	Beispiel
~/.claude/CLAUDE.md	Global	Gilt für alle Projekte
./CLAUDE.md	Projekt	Im Repository-Root
./.claude/CLAUDE.md	Projekt	Im .claude-Ordner
./.claude/CLAUDE.local.md	Lokal	Persönlich, nicht committet

Was gehört in eine CLAUDE.md?

Gute Inhalte:

## Build-Befehle

- `npm run dev` - Entwicklungsserver starten
- `npm test` - Tests ausführen
- `npm run lint` - Code-Style prüfen

## Code-Konventionen

- TypeScript strict mode verwenden
- Funktionale Komponenten mit Hooks
- Tests mit Vitest schreiben

## Projekt-Struktur

- `/src/components/` - React-Komponenten
- `/src/api/` - Backend-Integration
- `/tests/` - Test-Dateien

## Git-Workflow

- Feature-Branches: `feature/beschreibung`
- Commit-Messages auf Deutsch
- Vor Push: Tests ausführen

Was NICHT hineingehört:

• Dinge, die Claude aus dem Code lesen kann
• Standard-Konventionen der Sprache
• Lange Erklärungen oder Tutorials
• Datei-für-Datei Beschreibungen

Halte die CLAUDE.md kurz und prägnant. Claude liest sie bei jeder Interaktion - je kürzer, desto effizienter.

Praxis-Beispiel: Homelab-Projekt

Hier ein reales Beispiel aus einem Homelab-Ansible-Projekt:

## VM-Zugang

| Parameter | Wert |
|-----------|------|
| Host | 192.168.60.141 |
| User | admin |
| SSH | `ssh [email protected]` |

## Deployment-Workflow

1. Lokale Änderungen testen
2. `scp` auf Ziel-VM
3. `docker compose up -d` auf VM

## Wichtige Pfade

- `/opt/app/docker-compose.yml` - Aktive Konfiguration
- `/opt/app/.env` - Secrets (NIE committen!)
- `/mnt/data/` - Persistente Daten

## Häufige Befehle

```bash
# Container-Status prüfen
ssh [email protected] "docker ps"

# Logs anzeigen
ssh [email protected] "docker logs -f app"

{: file="CLAUDE.md" }

---

## settings.json - Berechtigungen und Verhalten

Die `settings.json` steuert, was Claude darf und was nicht. Dies ist besonders wichtig für die Sicherheit.

### Grundstruktur

```json
{
  "permissions": {
    "allow": [],
    "ask": [],
    "deny": []
  },
  "env": {},
  "model": "claude-sonnet-4-20250514"
}

Berechtigungssystem

Claude fragt standardmäßig bei jeder potenziell gefährlichen Aktion um Erlaubnis. Mit der permissions-Konfiguration kannst du das anpassen:

Liste	Bedeutung
allow	Automatisch erlaubt, keine Nachfrage
ask	Immer nachfragen (Standard)
deny	Immer blockiert

Syntax für Berechtigungsregeln

{
  "permissions": {
    "allow": [
      "Bash(npm run:*)",      // Alle npm run Befehle
      "Bash(git status)",     // Exakter Befehl
      "Read(src/**)",         // Alle Dateien in src/
      "WebSearch"             // Web-Suche erlauben
    ],
    "deny": [
      "Read(.env)",           // Keine .env lesen
      "Read(**/*secret*)",    // Keine Secret-Dateien
      "Bash(rm -rf:*)"        // Kein rekursives Löschen
    ]
  }
}

Pattern-Syntax:

Pattern	Bedeutung
Tool	Alle Verwendungen des Tools
Tool(exact)	Exakter Match
Tool(prefix:*)	Prefix-Match mit Wortgrenze
Tool(glob*)	Glob-Pattern

Sicherheits-Empfehlung

Eine sichere Basis-Konfiguration:

{
  "permissions": {
    "allow": [
      "Bash(git status)",
      "Bash(git diff:*)",
      "Bash(git log:*)",
      "Bash(npm run:*)",
      "Bash(npm test:*)"
    ],
    "deny": [
      "Read(~/.ssh/**)",
      "Read(~/.aws/**)",
      "Read(**/.env)",
      "Read(**/.env.*)",
      "Read(**/secrets/**)",
      "Read(**/*credential*)",
      "Bash(rm -rf:*)",
      "Bash(sudo:*)"
    ]
  }
}

---

Das .claude-Verzeichnis

Das .claude/-Verzeichnis im Projekt-Root enthält alle projektspezifischen Konfigurationen:

.claude/
├── settings.json          # Team-Einstellungen (git-tracked)
├── settings.local.json    # Persönliche Overrides (gitignored)
├── CLAUDE.md              # Projekt-Anweisungen
├── .mcp.json              # MCP-Server Konfiguration
├── agents/                # Custom Agenten
│   ├── code-reviewer.md
│   └── debugger.md
└── rules/                 # Modulare Regeln
    ├── code-style.md
    ├── testing.md
    └── security.md

settings.local.json

Diese Datei wird nicht ins Git committet und enthält persönliche Anpassungen:

{
  "permissions": {
    "allow": [
      "Bash(ssh [email protected]:*)",
      "Bash(scp:*)"
    ]
  }
}

Modulare Regeln mit rules/

Statt alles in eine CLAUDE.md zu packen, kannst du thematische Regel-Dateien erstellen:

---
paths:
  - "src/**/*.ts"
  - "src/**/*.tsx"
---

# TypeScript-Regeln

- Strict Mode verwenden
- Interfaces statt Types für Objekte
- Generics für wiederverwendbare Komponenten

Der paths-Header sorgt dafür, dass diese Regeln nur geladen werden, wenn Claude mit passenden Dateien arbeitet.

---

MCP-Server - Erweiterungen für Claude

MCP (Model Context Protocol) ermöglicht es, Claude um externe Tools zu erweitern. Damit kann Claude z.B. mit Datenbanken, APIs oder spezialisierten Tools interagieren.

Konfiguration

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.github.com/mcp/"
    },
    "database": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    }
  }
}

Scope-Optionen:

Ort	Scope	Sichtbarkeit
~/.claude.json	User	Alle deine Projekte
.mcp.json	Project	Team-geteilt

---

Workflow-Automatisierung

Mit den richtigen Konfigurationen wird Claude zu einem mächtigen Automatisierungswerkzeug.

Beispiel: Automatisches Deployment

CLAUDE.md:

## Deployment

Nach Änderungen am Code:

1. Tests ausführen: `npm test`
2. Auf VM kopieren: `scp -r dist/ admin@server:/opt/app/`
3. Container neustarten: `ssh admin@server "docker compose restart"`

## Commit-Konventionen

- Keine automatischen Signaturen
- Deutsche Commit-Messages
- Format: `<typ>: <beschreibung>`

settings.local.json:

{
  "permissions": {
    "allow": [
      "Bash(npm test)",
      "Bash(npm run build)",
      "Bash(scp:*)",
      "Bash(ssh admin@server:*)",
      "Bash(git add:*)",
      "Bash(git commit:*)",
      "Bash(git push)"
    ]
  }
}

Nutzung:

claude "Deploye die aktuellen Änderungen auf den Server"

Claude wird dann:

1. Tests ausführen
2. Den Build erstellen
3. Dateien auf den Server kopieren
4. Container neustarten
5. Bei Erfolg optional committen

---

Die Verzeichnisstruktur im Überblick

flowchart TB
    subgraph Home["Home-Verzeichnis (~/)"]
        direction TB
        H_CLAUDE[".claude/"]
        H_CLAUDEJSON[".claude.json"]
    end

    subgraph ClaudeDir["~/.claude/"]
        direction TB
        C_MD["CLAUDE.md<br/>(Global Instructions)"]
        C_SETTINGS["settings.json<br/>(Global Settings)"]
        C_COMMANDS["commands/<br/>(Custom Commands)"]
        C_CACHE["cache/<br/>(Temporary Data)"]
        C_HISTORY["history.jsonl<br/>(Conversation Log)"]
    end

    subgraph Project["Projekt-Verzeichnis"]
        direction TB
        P_ROOT["./"]
        P_CLAUDE[".claude/"]
        P_ROOTMD["CLAUDE.md"]
    end

    subgraph ProjectClaude[".claude/"]
        direction TB
        PC_SETTINGS["settings.json"]
        PC_LOCAL["settings.local.json"]
        PC_MD["CLAUDE.md"]
        PC_MCP[".mcp.json"]
        PC_AGENTS["agents/*.md"]
        PC_RULES["rules/*.md"]
    end

    H_CLAUDE --> ClaudeDir
    P_CLAUDE --> ProjectClaude

Zusammenfassung der Dateien

Datei	Ort	Zweck	Git?
CLAUDE.md	~/.claude/	Globale Anweisungen	-
CLAUDE.md	Projekt-Root	Projekt-Anweisungen	Ja
CLAUDE.local.md	.claude/	Persönliche Anweisungen	Nein
settings.json	~/.claude/	Globale Einstellungen	-
settings.json	.claude/	Team-Einstellungen	Ja
settings.local.json	.claude/	Persönliche Overrides	Nein
.claude.json	~/	MCP-Server (User)	-
.mcp.json	.claude/	MCP-Server (Projekt)	Ja
agents/*.md	~/.claude/	Globale Agenten	-
agents/*.md	.claude/	Projekt-Agenten	Ja

---

Agenten - Spezialisierte Assistenten

Eine der mächtigsten Funktionen von Claude Code sind Subagenten - spezialisierte KI-Assistenten, die bestimmte Aufgaben autonom übernehmen. Jeder Agent läuft in seinem eigenen Kontext mit eigenem System-Prompt, definierten Tools und unabhängigen Berechtigungen.

Warum Agenten?

Vorteil	Beschreibung
Kontext-Trennung	Exploration und Implementierung bleiben getrennt
Tool-Beschränkung	Nur notwendige Werkzeuge verfügbar
Wiederverwendbarkeit	Einmal definiert, überall nutzbar
Spezialisierung	Fokussierte System-Prompts für bessere Ergebnisse
Kostenoptimierung	Schnellere Modelle (Haiku) für einfache Tasks

Built-in Agenten

Claude Code bringt bereits einige Agenten mit:

Agent	Modell	Tools	Zweck
Explore	Haiku	Nur Lesen	Schnelle Codebase-Suche
Plan	Erbt	Nur Lesen	Recherche für Planungsmodus
General-purpose	Erbt	Alle	Komplexe mehrstufige Aufgaben
Bash	Erbt	Bash	Terminal-Befehle in separatem Kontext

Eigene Agenten erstellen

Agenten werden als Markdown-Dateien mit YAML-Frontmatter definiert:

Speicherorte:

Ort	Scope	Empfehlung
.claude/agents/	Projekt	Team-geteilt, in Git
~/.claude/agents/	Global	Persönliche Agenten

Dateiformat:

---
name: code-reviewer
description: Code-Review-Spezialist. Prüft Code auf Qualität und Sicherheit.
tools: Read, Grep, Glob, Bash
model: sonnet
---

Du bist ein erfahrener Code-Reviewer.

Wenn du aufgerufen wirst:
1. Führe `git diff` aus, um Änderungen zu sehen
2. Fokussiere dich auf geänderte Dateien
3. Beginne sofort mit dem Review

Prüfe auf:
- Code-Klarheit und Lesbarkeit
- Korrekte Namensgebung
- Keine doppelten Code-Blöcke
- Fehlerbehandlung
- Keine exponierten Secrets
- Input-Validierung

Organisiere Feedback nach Priorität:
- Kritisch (muss behoben werden)
- Warnung (sollte behoben werden)
- Vorschlag (Verbesserungspotential)

Frontmatter-Felder

Feld	Pflicht	Beschreibung
name	Ja	Eindeutiger Name (lowercase, Bindestriche)
description	Ja	Wann Claude diesen Agent nutzen soll
tools	Nein	Komma-getrennte Tool-Liste
model	Nein	sonnet, opus, haiku oder inherit
permissionMode	Nein	default, acceptEdits, plan

Agenten aufrufen

Automatisch: Claude erkennt anhand der description, wann ein Agent passend ist:

claude "Prüfe meine letzten Code-Änderungen"
# → Claude delegiert automatisch an code-reviewer

Explizit: Direkt einen Agenten anfordern:

claude "Nutze den code-reviewer Agent für die Änderungen in src/"

Per /agents Befehl: Interaktive Verwaltung:

/agents

Beispiel: Debugger-Agent

Ein Agent zum Finden und Beheben von Fehlern:

---
name: debugger
description: Debugging-Spezialist für Fehler und unerwartetes Verhalten.
tools: Read, Edit, Bash, Grep, Glob
model: sonnet
---

Du bist ein Debugging-Experte für Root-Cause-Analyse.

Debugging-Prozess:
1. Erfasse Fehlermeldung und Stack-Trace
2. Identifiziere Reproduktionsschritte
3. Lokalisiere die Fehlerquelle
4. Implementiere minimalen Fix
5. Verifiziere die Lösung

Für jeden Fehler liefere:
- Ursachen-Erklärung
- Evidenz für die Diagnose
- Konkreten Code-Fix
- Test-Ansatz
- Präventions-Empfehlungen

Behebe die Ursache, nicht das Symptom.

Beispiel: Datenbank-Agent mit Hook

Ein Read-Only Agent für Datenbank-Abfragen mit Sicherheits-Hook:

---
name: db-reader
description: Führt nur SELECT-Abfragen aus. Für Datenanalysen.
tools: Bash
hooks:
  PreToolUse:
    - matcher: "Bash"
      hooks:
        - type: command
          command: "./scripts/validate-readonly-query.sh"
---

Du bist ein Datenbank-Analyst mit Read-Only-Zugriff.

Du darfst NUR SELECT-Abfragen ausführen.
Bei INSERT, UPDATE, DELETE oder Schema-Änderungen:
→ Erkläre, dass du nur Lesezugriff hast.

Wenn du Daten analysierst:
1. Identifiziere relevante Tabellen
2. Schreibe effiziente SELECT-Queries
3. Präsentiere Ergebnisse klar strukturiert

Das Validierungs-Script blockiert Write-Operationen:

#!/bin/bash
INPUT=$(cat)
COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty')

if echo "$COMMAND" | grep -iE '\b(INSERT|UPDATE|DELETE|DROP|CREATE|ALTER)\b' > /dev/null; then
  echo "Blocked: Nur SELECT-Queries erlaubt." >&2
  exit 2
fi
exit 0

Agent-Workflow visualisiert

flowchart TB
    User([Benutzer])
    Claude[Claude Code]

    subgraph Agents["Verfügbare Agenten"]
        Explore[Explore<br/>Haiku]
        Reviewer[Code-Reviewer<br/>Sonnet]
        Debugger[Debugger<br/>Sonnet]
        Custom[Custom Agent<br/>...]
    end

    User -->|"Prüfe meinen Code"| Claude
    Claude -->|Delegiert| Reviewer
    Reviewer -->|Liest Code| Files[(Dateien)]
    Reviewer -->|Ergebnis| Claude
    Claude -->|Review-Feedback| User

    User -->|"Finde den Bug"| Claude
    Claude -->|Delegiert| Debugger
    Debugger -->|Analysiert| Files
    Debugger -->|Fix| Claude
    Claude -->|Lösung| User

Best Practices für Agenten

1. Fokussiert bleiben - Ein Agent = Eine Aufgabe
2. Tools beschränken - Nur notwendige Berechtigungen
3. Gute Description - Klar beschreiben, wann der Agent helfen soll
4. In Git committen - .claude/agents/ versionieren
5. Hooks für Sicherheit - Kritische Operationen validieren

Agenten sind besonders nützlich für wiederkehrende Aufgaben wie Code-Reviews, Debugging, oder Dokumentation. Einmal definiert, übernimmt Claude automatisch die Delegation.

---

Tipps für Einsteiger

1. Klein anfangen

Starte mit einer minimalen CLAUDE.md:

## Projekt

Dies ist ein [Projekttyp]-Projekt.

## Befehle

- Build: `npm run build`
- Test: `npm test`

2. Berechtigungen schrittweise erweitern

Beginne mit restriktiven Berechtigungen und erweitere sie, wenn du Claude besser kennst:

{
  "permissions": {
    "allow": ["Bash(git status)", "Bash(git diff:*)"]
  }
}

3. Sensitive Dateien schützen

Füge immer Deny-Regeln für sensitive Dateien hinzu:

{
  "permissions": {
    "deny": [
      "Read(**/.env*)",
      "Read(**/secret*)",
      "Read(~/.ssh/**)"
    ]
  }
}

4. Projekt-spezifische Konfiguration nutzen

Lege für jedes Projekt eine .claude/-Struktur an:

mkdir -p .claude
echo '{}' > .claude/settings.json
echo '# Projekt-Anweisungen' > .claude/CLAUDE.md
echo '.claude/settings.local.json' >> .gitignore

5. CLAUDE.md regelmäßig pflegen

Lösche Anweisungen, die Claude nicht mehr braucht. Eine kürzere CLAUDE.md ist eine bessere CLAUDE.md.

---

Häufige Probleme

Claude fragt ständig nach Berechtigungen

Lösung: Füge häufig genutzte Befehle zu allow hinzu:

{
  "permissions": {
    "allow": ["Bash(npm:*)", "Bash(git:*)"]
  }
}

Claude versteht den Projekt-Kontext nicht

Lösung: Verbessere die CLAUDE.md mit relevanten Informationen:

• Build-System und Befehle
• Projektstruktur
• Technologie-Stack
• Besondere Konventionen

Claude macht unerwartete Änderungen

Lösung: Nutze präzisere Anweisungen und aktiviere ggf. den Plan-Modus:

{
  "permissions": {
    "defaultMode": "plan"
  }
}

Im Plan-Modus zeigt Claude erst seinen Plan und führt ihn erst nach Bestätigung aus.

---

Tipps und Tricks für Fortgeschrittene

Tastenkürzel und Befehle

Kürzel/Befehl	Funktion
Ctrl+C	Aktuelle Aktion abbrechen
Ctrl+D	Session beenden
Ctrl+L	Terminal leeren
Ctrl+R	In History suchen
/help	Hilfe anzeigen
/clear	Konversation zurücksetzen
/compact	Kontext komprimieren
/config	Konfiguration anzeigen
/agents	Agenten verwalten
/model	Modell wechseln

Effiziente Prompts schreiben

Schlecht:

Kannst du vielleicht mal schauen ob da irgendwo ein Bug ist?

Gut:

In src/api/auth.ts schlägt der Login fehl wenn das Passwort
Sonderzeichen enthält. Finde den Bug und behebe ihn.

Noch besser:

Bug: Login schlägt fehl bei Sonderzeichen im Passwort
Datei: src/api/auth.ts
Fehler: "Invalid character in input"
Erwartung: Login sollte mit allen UTF-8 Zeichen funktionieren

Kontext-Management

Claude hat ein begrenztes Kontext-Fenster. So nutzt du es optimal:

# Kontext komprimieren wenn er voll wird
/compact

# Neue Session für unabhängige Aufgaben
claude --new

# Session fortsetzen
claude --resume

Multi-File Operationen

Für Änderungen an mehreren Dateien:

claude "Refactore alle API-Calls in src/api/ zu async/await"

Claude wird:

1. Alle relevanten Dateien finden
2. Einen Plan erstellen
3. Nach Bestätigung alle Dateien ändern

Git-Integration nutzen

# Änderungen reviewen lassen
claude "Review meine staged changes und erstelle eine Commit-Message"

# Merge-Konflikte lösen
claude "Löse die Merge-Konflikte in src/components/"

# Interaktives Rebase vorbereiten
claude "Erkläre mir die letzten 5 Commits und schlage eine Rebase-Strategie vor"

Pipe-Input verwenden

# Fehlerlog analysieren
cat error.log | claude "Analysiere diese Fehler und schlage Fixes vor"

# Code aus Clipboard
pbpaste | claude "Optimiere diesen Code"

# Diff analysieren
git diff | claude "Erstelle eine detaillierte Commit-Message"

Environment-Variablen

# Modell für Session festlegen
ANTHROPIC_MODEL=claude-opus-4 claude

# Debug-Output aktivieren
CLAUDE_DEBUG=1 claude

# Eigenes Config-Verzeichnis
CLAUDE_CONFIG_DIR=~/my-config claude

Hooks für Automatisierung

In settings.json kannst du Hooks definieren, die bei bestimmten Events ausgeführt werden:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint --fix"
          }
        ]
      }
    ]
  }
}

Verfügbare Hook-Events:

Event	Auslöser
PreToolUse	Vor Tool-Ausführung
PostToolUse	Nach Tool-Ausführung
SessionStart	Session startet
SessionEnd	Session endet
UserPromptSubmit	Vor Prompt-Verarbeitung

Modell-Auswahl je nach Aufgabe

Aufgabe	Empfohlenes Modell
Komplexe Architektur	Opus
Standard-Entwicklung	Sonnet
Schnelle Suche/Analyse	Haiku
Code-Review	Sonnet
Debugging	Opus

# Für diese Session Opus nutzen
claude --model opus "Designe die Architektur für ein Event-System"

# Schnelle Frage mit Haiku
claude --model haiku "Wo ist die main() Funktion?"

---

Sicherheitshinweise

Grundprinzipien

Wichtig: Claude Code hat Zugriff auf dein Dateisystem und kann Shell-Befehle ausführen. Behandle es wie einen neuen Mitarbeiter mit Admin-Rechten - vertraue, aber verifiziere.

Sensitive Daten schützen

Niemals in CLAUDE.md oder Prompts:

• Passwörter
• API-Keys
• Private Keys
• Tokens
• Persönliche Daten

Deny-Rules für kritische Dateien:

{
  "permissions": {
    "deny": [
      "Read(~/.ssh/**)",
      "Read(~/.gnupg/**)",
      "Read(~/.aws/**)",
      "Read(~/.kube/config)",
      "Read(~/.docker/config.json)",
      "Read(**/.env)",
      "Read(**/.env.*)",
      "Read(**/.env.local)",
      "Read(**/secrets/**)",
      "Read(**/*secret*)",
      "Read(**/*credential*)",
      "Read(**/*password*)",
      "Read(**/*.pem)",
      "Read(**/*.key)",
      "Read(**/*token*)"
    ]
  }
}

Gefährliche Befehle blockieren

{
  "permissions": {
    "deny": [
      "Bash(rm -rf:*)",
      "Bash(rm -r:*)",
      "Bash(sudo rm:*)",
      "Bash(chmod 777:*)",
      "Bash(curl:* | bash)",
      "Bash(wget:* | bash)",
      "Bash(eval:*)",
      "Bash(> /dev/sda:*)",
      "Bash(dd if=:*)",
      "Bash(mkfs:*)",
      "Bash(:(){ :|:& };:)",
      "Bash(sudo su:*)",
      "Bash(passwd:*)"
    ]
  }
}

Netzwerk-Sicherheit

{
  "permissions": {
    "deny": [
      "Bash(nc -l:*)",
      "Bash(netcat:*)",
      "Bash(nmap:*)",
      "Bash(ssh-keygen:*)",
      "Bash(scp:* @*:*)"
    ],
    "ask": [
      "Bash(curl:*)",
      "Bash(wget:*)",
      "Bash(ssh:*)",
      "WebFetch",
      "WebSearch"
    ]
  }
}

Git-Sicherheit

{
  "permissions": {
    "deny": [
      "Bash(git push --force:*)",
      "Bash(git push -f:*)",
      "Bash(git reset --hard:*)",
      "Bash(git clean -fd:*)",
      "Bash(git checkout -- .)"
    ],
    "ask": [
      "Bash(git push:*)",
      "Bash(git commit:*)",
      "Bash(git rebase:*)"
    ]
  }
}

Umgebungs-Isolation

Für besonders sensible Projekte:

# Separates Config-Verzeichnis für sensible Projekte
mkdir -p ~/secure-claude-config
CLAUDE_CONFIG_DIR=~/secure-claude-config claude

{
  "permissions": {
    "defaultMode": "plan",
    "allow": [],
    "deny": ["Bash(*)", "Write(*)", "Edit(*)"]
  }
}

Audit-Trail führen

Claude Code speichert Konversationen in ~/.claude/history.jsonl. Für sicherheitskritische Umgebungen:

# History regelmäßig prüfen
tail -100 ~/.claude/history.jsonl | jq '.tool_calls[]?'

# Alte Sessions aufräumen
find ~/.claude/projects -name "*.jsonl" -mtime +30 -delete

Checkliste vor dem Produktiveinsatz

• Deny-Rules für alle sensitiven Dateien definiert
• Gefährliche Bash-Befehle blockiert
• Git-Force-Push verhindert
• defaultMode: "plan" für kritische Projekte
• .claude/settings.local.json in .gitignore
• Keine Secrets in CLAUDE.md
• Regelmäßige Review der erlaubten Befehle

Was Claude NICHT sehen sollte

Kategorie	Beispiele
Authentifizierung	SSH-Keys, API-Keys, Tokens, Passwörter
Infrastruktur	Kubeconfig, AWS Credentials, Cloud-Zugänge
Persönliche Daten	E-Mails, Kontakte, private Dokumente
Geschäftsdaten	Kundendaten, Finanzdaten, interne Docs
Kryptografie	Private Keys, Zertifikate, Keystores

Incident Response

Falls Claude unbeabsichtigt auf sensitive Daten zugegriffen hat:

1. Session beenden: Ctrl+D
2. Logs prüfen: ~/.claude/history.jsonl
3. Credentials rotieren: Falls Secrets exponiert
4. Deny-Rules erweitern: Lücke schließen
5. History bereinigen: Betroffene Einträge entfernen

# Letzte Einträge der History prüfen
tail -50 ~/.claude/history.jsonl | grep -i "secret\|password\|key\|token"

Tipp: Starte mit restriktiven Berechtigungen und erweitere sie nur bei Bedarf. Es ist einfacher, Berechtigungen hinzuzufügen als versehentlich exponierte Daten wieder einzufangen.

---

Fazit

Claude Code ist mehr als ein Chat-Bot - es ist ein vollwertiger Entwicklungsassistent, der direkt in deinem Terminal arbeitet. Mit der richtigen Konfiguration wird er zu einem unverzichtbaren Werkzeug für:

• Routine-Aufgaben automatisieren - Tests, Deployments, Git-Workflows
• Code verstehen - Schneller Einstieg in fremde Codebases
• Entwicklung beschleunigen - Von der Idee zum Code in Minuten

Die wichtigsten Punkte:

1. CLAUDE.md ist dein Hauptwerkzeug - halte sie kurz und relevant
2. settings.json schützt dich - definiere klare Berechtigungen
3. Projekt-Konfiguration macht Claude zum Team-Mitglied
4. Iterativ verbessern - Passe die Konfiguration an deine Workflows an

Starte mit einer einfachen Konfiguration und erweitere sie Schritt für Schritt. Nach einer Woche wirst du dich fragen, wie du je ohne Claude Code entwickelt hast.

---

Ressourcen

• Claude Code Dokumentation - Offizielle Docs
• Anthropic Console - API-Key Management
• Model Context Protocol - MCP-Server entwickeln
• Claude Code GitHub - Issues und Releases