# Claude Code Cheat Sheet — Deutsch

**Kompakte Referenz für professionelle KI-gestützte Entwicklung mit Claude Code**

Dieses Cheat Sheet richtet sich an Entwickler, die Claude Code (das offizielle CLI-Tool von Anthropic) produktiv einsetzen möchten. Es fasst die wichtigsten Befehle, Prompt-Muster, Projekt-Konfiguration und Best Practices zusammen.

**Erstellt von der FlowKI-Community** — https://flowki-club.de

---

## 1. Wichtigste CLI-Befehle & Slash-Commands

### Session-Management
- `/help` — Zeigt verfügbare Slash-Commands und Skills
- `/clear` — Löscht die aktuelle Konversation (Kontext zurücksetzen)
- `/compact` — Komprimiert den Kontext (entfernt überflüssige Historie)
- `/config` — Öffnet Einstellungen (Modell, Theme, Permissions)

### Agents & Skills
- `/agents` — Zeigt verfügbare spezialisierte Subagents (falls konfiguriert)
- `/<skill-name>` — Ruft einen installierten Skill auf (z.B. `/code-review`, `/test-driven-development`)
- Skills sind wiederverwendbare Mini-Workflows für häufige Aufgaben

### Arbeits-Modi
- **Plan-Modus:** "Erstelle einen Plan für [Feature/Refactoring], aber implementiere noch nicht"
  - Verhindert vorschnelle Implementierung, wenn Architektur-Entscheidungen noch unklar sind
- **Review-Modus:** "Reviewe nur die Datei [path], ändere nichts"
  - Nützlich für Code-Audits ohne direkte Eingriffe

### Kontext & Permissions
- Claude Code arbeitet standardmäßig im interaktiven Modus (fragt bei riskanten Operationen)
- `CLAUDE.md` im Projektroot definiert projektspezifische Regeln und Permissions
- `.claude/settings.json` erlaubt Allowlists für häufige Read-Only-Befehle (weniger Prompts)

---

## 2. Prompt-Muster für Coding-Agenten

### Grundprinzip: Role → Context → Task → Format

**Schlecht:**
```
Mach die Login-Funktion.
```

**Gut:**
```
Du bist ein Backend-Entwickler mit FastAPI-Expertise.

Context: Wir haben eine REST-API mit JWT-Auth (access + refresh tokens).
Die User-Daten liegen in PostgreSQL (SQLAlchemy ORM).

Task: Implementiere einen POST /auth/login Endpoint:
- Input: Pydantic-Schema (email, password)
- Validierung: bcrypt-Hash-Vergleich
- Output: access_token + refresh_token (15min / 7d)
- Error-Handling: 401 bei falschen Credentials, 422 bei invalider Email

Format: Production-ready Code, kein Stub. Unit-Tests für happy path + 401 + 422.
Gates: pytest grün, mypy --strict ohne Fehler.
```

### Schrittweise Verifikation erzwingen
```
Implementiere [Feature] in kleinen Schritten:
1. Zuerst nur das Pydantic-Schema + Test dafür
2. Dann die Service-Logik + Integration-Test
3. Dann den Endpoint + E2E-Test

Stoppe nach jedem Schritt und zeige mir pytest-Output.
Erst bei grünem Test weitermachen.
```

### Explizite Verbote setzen
```
Implementiere [Feature].

VERBOTE:
- Kein `pass`, `TODO`, `...` in Production-Code
- Keine ungepinnten Dependencies (kein ^, ~)
- Kein console.log/print() — nutze strukturiertes Logging
- Keine Secrets im Code — nur Env-Variablen

Definition of Done:
- Tests grün (zeig mir pytest-Output)
- Lint grün (zeig mir ruff/eslint-Output)
- Typcheck grün (zeig mir mypy/tsc-Output)
```

---

## 3. CLAUDE.md — Projektspezifische Regeln

Die `CLAUDE.md`-Datei im Projektroot ist der zentrale Ort für projektspezifische Anweisungen, die Claude Code bei jeder Session automatisch lädt.

### Grundgerüst (Beispiel)

```markdown
# Projekt: [Name]

## Stack
- Backend: FastAPI 0.115, Python 3.12, PostgreSQL 16
- Frontend: Next.js 15, React 19, TypeScript 5.6
- Testing: pytest, Playwright
- Deployment: Docker Compose

## Kritische Regeln

### Vor jeder Session (Startup-Protokoll)
[ ] CLAUDE.md lesen
[ ] Projektstand lesen (✅ / 🚧 / 🐛 Blöcke)
[ ] Aktive Bugs prüfen
[ ] Nächster Schritt bestätigen

### Definition of Done (DoD)
Jedes Feature ist erst fertig wenn:
[ ] Tests grün (`pytest`, `npm test`)
[ ] Lint grün (`ruff`, `eslint`)
[ ] Typcheck grün (`mypy --strict`, `tsc --noEmit`)
[ ] Manuell getestet (curl/Browser-Screenshot gezeigt)
[ ] Projektstand aktualisiert

### Verbote
❌ Kein Stub-Code (`pass`, `TODO`, `...`)
❌ Keine ungepinnten Dependencies
❌ Kein Auto-Retry bei Paid APIs ohne Rückfrage
❌ Keine Secrets in Git

## Standard-Befehle
```bash
# Development
make dev / docker compose up
make test / pytest -v
make lint / ruff check .
make migrate / alembic upgrade head

# Vor jedem Commit
make pre-commit  # = lint + typcheck + test
```

## Projektstand

### ✅ Fertig
- User-Auth (JWT, bcrypt)
- CRUD-Endpoints für Items

### 🚧 In Arbeit
- Payment-Integration (Stripe)

### 🐛 Bugs
- Keine bekannt
```

### Best Practices für CLAUDE.md
- **Kurz halten:** 200–500 Zeilen, nicht 2000 (sonst ignoriert der Agent Details)
- **Projektstand pflegen:** Nach jedem Feature ✅/🚧/🐛 aktualisieren
- **Importe nutzen:** `@docs/architecture.md` statt alles inline
- **Gates definieren:** Klare Erfolgskriterien (Tests grün, Lint grün, manuelle Verifikation)

---

## 4. MCP-Integration (Model Context Protocol)

MCP-Server erweitern Claude Code um Zugriff auf externe Tools und Datenquellen.

### Was ist MCP?
Das Model Context Protocol ist ein offener Standard für die Verbindung von LLMs mit externen Datenquellen, Tools und APIs. Ein MCP-Server stellt Tools (Functions) und Ressourcen (Read-Only-Daten) bereit, die Claude Code nutzen kann.

### Beispiele für MCP-Server
- **Filesystem:** Zugriff auf Dateien außerhalb des Projekts
- **Databases:** Direkter DB-Zugriff (PostgreSQL, MongoDB)
- **Browser:** Playwright-gesteuerte Browser-Automation
- **APIs:** GitHub, Jira, Slack, Discord
- **Memory:** Persistente Wissensdatenbank über Sessions hinweg

### Integration (konzeptionell)
1. MCP-Server installieren (z.B. `npm install -g @modelcontextprotocol/server-github`)
2. Server in `~/.claude/config.json` registrieren (Server-Befehl + Argumente)
3. Claude Code startet Server automatisch und nutzt dessen Tools

### Wichtig
- MCP-Server laufen lokal (localhost) — keine Cloud-Abhängigkeit
- Permissions gelten auch für MCP-Tools (Claude fragt bei sensiblen Operationen)
- Eigene MCP-Server können in Python/Node.js geschrieben werden (SDK vorhanden)

---

## 5. Hooks & Skills

### Hooks
Hooks automatisieren wiederkehrende Aktionen bei bestimmten Events (Session-Start, Code-Änderung, Fehler).

**Konzept:**
```json
{
  "hooks": {
    "onSessionStart": "Lies CLAUDE.md und zeige Projektstand",
    "beforeCommit": "Führe make pre-commit aus und zeige Ergebnis",
    "onTestFailure": "Analysiere Stack Trace, identifiziere Root Cause"
  }
}
```

Hooks werden in `.claude/settings.json` konfiguriert (projektspezifisch oder global).

### Skills
Skills sind wiederverwendbare Mini-Workflows (Markdown-Dateien unter `.claude/skills/`).

**Beispiel-Skill: `/fix-tests`**
```markdown
# fix-tests
Debugge fehlgeschlagene Tests:
1. Führe `pytest -v` aus und lies kompletten Output
2. Identifiziere erste fehlgeschlagene Test-Datei + Zeile
3. Lies Test-Code + getesteten Code
4. Analysiere Root Cause (nicht Symptom!)
5. Implementiere Fix
6. Führe `pytest [test-file] -v` aus und zeige Output
7. Erst bei grün: Frage ob weitere Tests gefixt werden sollen
```

**Aufruf:** Einfach `/fix-tests` in der Session eingeben.

---

## 6. Arbeits-Gates — Qualitätssicherung

### Vor der Implementierung
```
[ ] Projektstand gelesen
[ ] Aufgabe in kleinste Einheit zerlegt
[ ] Betroffene Dateien identifiziert
[ ] Testplan definiert (happy path + Fehlerfälle)
[ ] Bei Unklarheit: NACHFRAGEN, nicht raten
```

### Während der Implementierung
```
[ ] Eine Einheit auf einmal (ein Endpoint, eine Komponente)
[ ] Zuerst Test schreiben (TDD wenn möglich)
[ ] Dann Implementierung
[ ] Kein Stub-Code (pass, TODO, ...)
[ ] Nach jeder Datei: mentaler DoD-Check
```

### Nach der Implementierung (Beweis-Protokoll)
```
[ ] `make test` → vollständige Ausgabe zeigen
[ ] `make lint` → vollständige Ausgabe zeigen
[ ] `make typcheck` → vollständige Ausgabe zeigen
[ ] Manueller Test: curl-Output ODER Screenshot zeigen
[ ] Projektstand aktualisieren
[ ] Erst dann nächste Einheit
```

### Debugging-Protokoll
```
[ ] Komplette Fehlermeldung + Stack Trace lesen
[ ] Datei + Zeilennummer identifizieren
[ ] Root Cause finden (nicht symptomatisch patchen)
[ ] Fix implementieren
[ ] Reproduktionstest schreiben (vorher rot, nachher grün)
[ ] `make test` → alle grün
[ ] Projektstand aktualisieren
```

---

## 7. Häufige Anti-Patterns vermeiden

### ❌ Vage Aufträge
"Mach die App schneller."
→ **Besser:** "Analysiere `/api/items` — aktuell 2.3s Latenz. Vermutung: N+1 Query. Zeige mir EXPLAIN ANALYZE, dann optimiere."

### ❌ Implizite Annahmen
"Implementiere User-Login."
→ **Besser:** "Implementiere User-Login mit JWT (nicht Session-Cookies), bcrypt, PostgreSQL. Access-Token 15min, Refresh 7d."

### ❌ "Sollte funktionieren"
Agent behauptet Code ist fertig, zeigt aber keine Test-Ausgabe.
→ **Nachhaken:** "Zeig mir `pytest -v` Output. Erst bei grün weitermachen."

### ❌ Mehrere Features gleichzeitig
"Implementiere Login + Payment + Admin-Dashboard."
→ **Besser:** "Erst nur Login (DoD: Tests grün + curl-Beweis). Dann Payment. Dann Dashboard."

---

## 8. Quick-Tipps

### Kontext optimieren
- Nutze `/compact` wenn Session >50k Tokens (langsam wird)
- Lösche irrelevante Code-Blöcke aus dem Chatverlauf
- Zeige nur betroffene Dateien, nicht ganzes Repo

### Kosten sparen
- Nutze Subagents für parallele Arbeit (Backend + Frontend gleichzeitig)
- Aber: Sequentielle Tasks in einer Session (4× Token-Overhead bei Teams)
- Plan-Modus für unsichere Architekturen (verhindert teures Wegwerf-Coding)

### Sicherheit
- Secrets niemals direkt in Prompts (nutze Platzhalter: `[DEIN_API_KEY]`)
- Für sensible Daten: `.claude/settings.json` Allowlists statt jedes Mal tippen
- Bei Prod-DB-Zugriff: explizit "Lies nur, ändere nichts" sagen

### Effizienz
- Wiederverwendbare Prompts als Skills ablegen (`.claude/skills/`)
- Standard-Gates in `CLAUDE.md` definieren (DoD, Lint-Befehle)
- Hooks für Routineaufgaben (SessionStart → Projektstand lesen)

---

## 9. Ressourcen

- **Offizielle Docs:** https://docs.anthropic.com/claude/docs
- **MCP-Specs:** https://modelcontextprotocol.io
- **FlowKI-Community:** https://flowki-club.de — Deutschsprachige KI-Entwickler-Community mit Pentesting-Fokus

---

**Lizenz:** CC BY 4.0 — Frei nutzbar mit Quellenangabe (FlowKI-Community)
**Version:** 1.0 (2026-08-03)