# Claude Code Leitfaden: Einrichtung für agentisches Programmieren (für Einsteiger)

> Ein umfassender praktischer Leitfaden zur Einrichtung von Claude Code: CLI-Installation, Konfiguration von CLAUDE.md und settings.json, Berechtigungsregeln, automatische Hooks, benutzerdefinierter /truth-Befehl und Subagenten.

## 1. Installation von Claude Code und Vorbereitung der Umgebung

Claude Code wird als eigenständige Befehlszeilenschnittstelle (CLI) installiert, um über agentische Modelle von Anthropic mit Code zu interagieren. Im Gegensatz zu herkömmlichen Chatbots greift Claude Code direkt auf das Dateisystem zu, führt Terminalbefehle aus, analysiert den Projektbaum und nimmt atomare Änderungen vor.

### 1.1. CLI-Installationsmethoden: natives Skript vs. npm

Die von Entwicklern empfohlene Installationsmethode ist ein natives Systemskript, das die Binärdatei und die Laufzeitumgebung automatisch konfiguriert. Als Alternative für Workstations mit vorhandenem Node.js-Toolchain kann das globale npm-Paket verwendet werden:

```bash
# macOS, Linux або WSL
curl -fsSL https://claude.ai/install.sh | bash

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

# Альтернативне встановлення через npm
npm install -g @anthropic-ai/claude-code
```

Nach Abschluss der Installation überprüfen Sie die Funktionsfähigkeit des Befehls, indem Sie `claude --version` in Ihrem Terminal ausführen.

### 1.2. Bindung an das Projektverzeichnis und Authentifizierung

Vor dem ersten Start ist es entscheidend, direkt in den Stammordner Ihres Arbeitsprojekts zu wechseln:

```bash
cd your-project-directory
claude
```

> 💡 **Warum das wichtig ist:** Claude Code bindet Langzeitgedächtnis, lokale Regeln und Berechtigungen strikt an das aktuelle Arbeitsverzeichnis. Ein Start vom Home-Ordner (`~`) oder Desktop führt zum Verlust des architektonischen Kontexts Ihres Repositorys.

Beim ersten Start bietet das Tool an, die Authentifizierung durchzuführen:
- **OAuth-Login über den Browser**, wenn ein aktives Claude-Abo (Pro, Max oder Team) vorhanden ist.
- **Anthropic Console API-Schlüssel** für direkte sekundengenaue Token-Abrechnung gemäß API-Tarifen.

Neben dem reinen Terminal unterstützt Claude Code die Nutzung über die offizielle VS Code-Erweiterung, das JetBrains-Plugin, eine Desktop-Anwendung sowie die Web-Oberfläche auf claude.ai. Alle diese Schnittstellen nutzen eine gemeinsame Konfigurationsstruktur `.claude/`, sodass alle Regeln unabhängig von der gewählten Arbeitsumgebung unverändert bleiben.

## 2. Drei Konfigurationsdateien: Architektur des Gedächtnisses und der Einstellungen

Claude Code nutzt eine zweistufige Konfigurationshierarchie: das Projektverzeichnis `.claude/` (zusammen mit der Datei `CLAUDE.md` im Root) und das globale Verzeichnis `~/.claude/` im Home-Ordner des Benutzers. Globale Einstellungen gelten für alle Sitzungen auf der Maschine, während lokale Vorrang für das aktuelle Repository haben.

### 2.1. CLAUDE.md und Regeln des Repository-Gedächtnisses

`CLAUDE.md` ist das persistente Projektgedächtnis, das der Agent zu Beginn jeder Arbeitssitzung liest. Hier werden architektonische Orientierungspunkte, Test-Befehle, Code-Stil-Regeln und der Tech-Stack festgehalten.

| Mechanismus | Speicherort | Zweck |
| --- | --- | --- |
| **Root-Leitfaden** | `CLAUDE.md` | Hauptanweisungen und Stack-Beschreibung (empfohlen bis 2500 Tokens). |
| **Modulregeln** | `.claude/rules/*.md` | Spezifische Anweisungen, gebunden an bestimmte Pfade und Dateien. |
| **Gedächtnis-Generator** | Befehl `/init` | Automatischer Analyse des Codebases und Erstellung der Startdatei. |
| **Gedächtnis-Editor** | Befehl `/memory` | Schnelles interaktives Bearbeiten der gespeicherten Regeln. |

> ⚠️ **Hauptprinzip des Gedächtnisses:** Anweisungen, die einfach im Chat gegeben werden, gehen bei der Kontextkompression in langen Sitzungen unvermeidlich verloren. Jede Regel, die zwischen Sitzungen bestehen soll, muss explizit in `CLAUDE.md` geschrieben werden.

### 2.2. settings.json und der Auto-Memory-Mechanismus

Die Konfigurationsdatei `settings.json` (platziert in `.claude/settings.json` für das Projekt oder `~/.claude/settings.json` für die globale Ebene) definiert Sicherheitsberechtigungen, System-Hooks, Umgebungsvariablen und das Standardmodell.

Der **Auto memory**-Mechanismus ermöglicht es Claude Code, Arbeitsbeobachtungen automatisch zwischen Sitzungen ohne direkten Eingriff des Entwicklers aufzuzeichnen. Dieses Verhalten kann über den Parameter `"autoMemoryEnabled": false` oder die Umgebungsvariable `CLAUDE_CODE_DISABLE_AUTO_MEMORY=1` gesteuert werden, wenn Sie ausschließlich transparente manuelle Kontrolle über `CLAUDE.md` bevorzugen.

## 3. Vorab-Konfiguration von Berechtigungen und Hooks

Um Sicherheit zu gewährleisten und unnötige Bestätigungsanfragen zu eliminieren, bietet Claude Code ein System interaktiver Modi und granularer Regeln in der Konfiguration.

### 3.1. Interaktive Berechtigungsmodi und die Allow/Ask/Deny-Matrix

Das schnelle Umschalten der Ausführungsmodi erfolgt über die Tastenkombination `Shift+Tab`:
- **Default** – fragt die Benutzerbestätigung vor jeder potenziell gefährlichen Operation oder Dateiänderung ab.
- **Auto-Accept Edits** – wendet Dateiänderungen automatisch an und fragt nur bei Systembefehlen nach Bestätigung.
- **Plan Mode** – Lesemodus ohne Möglichkeit zur Codeänderung oder Ausführung von bash-Befehlen, bis der Gesamtplan genehmigt wurde.

Zur Beseitigung routinemäßiger Bestätigungen wird in `.claude/settings.json` eine deklarative Regelmatrix konfiguriert:

```json
{
  "permissions": {
    "allow": [
      "Bash(npm test:*)",
      "Bash(npm run lint:*)",
      "Read(**)"
    ],
    "ask": [
      "Bash(git push:*)"
    ],
    "deny": [
      "Bash(rm -rf /*)",
      "Bash(sudo:*)",
      "Read(.env)"
    ]
  }
}
```

Die `deny`-Regel hat immer höchste Priorität: Selbst wenn die Maske `Read(**)` das Lesen von Dateien erlaubt, garantiert das explizite Verbot `Read(.env)`, dass sensible Umgebungsvariablen niemals in den Modellkontext gelangen.

### 3.2. Automatisierung über PostToolUse- und PreToolUse-Hooks

Hooks ermöglichen die Ausführung lokaler Skripte vor oder nach dem Aufruf integrierter Agent-Tools.

Zum Beispiel formatiert der **PostToolUse**-Hook automatisch bearbeitete Dateien über Prettier:

```json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$CLAUDE_TOOL_INPUT_FILE_PATH\""
          }
        ]
      }
    ]
  }
}
```

Und der **PreToolUse**-Hook erlaubt das programmatische Abfangen und Blockieren gefährlicher bash-Befehle auf Python-Skript-Ebene, bevor sie tatsächlich an die Shell übergeben werden:

```python
#!/usr/bin/env python3
# .claude/hooks/block-dangerous-bash.py
import json
import re
import sys

DANGEROUS_PATTERNS = [
    r'\brm\s+.*-[a-z]*r[a-z]*f',
    r'sudo\s+rm',
    r'chmod\s+777',
    r'git\s+push\s+--force.*main',
]

input_data = json.load(sys.stdin)
if input_data.get('tool_name') == 'Bash':
    command = input_data.get('tool_input', {}).get('command', '')
    for pattern in DANGEROUS_PATTERNS:
        if re.search(pattern, command, re.IGNORECASE):
            print("BLOCKED: command matches dangerous security pattern", file=sys.stderr)
            sys.exit(2)
sys.exit(0)
```

Der Rückgabecode `2` signalisiert Claude Code eine Notfallblockierung des Aufrufs ohne Ausführung des Befehls im System.

## 4. Befehle, die man zuerst lernen sollte

Die eingebaute Bibliothek von Claude Code enthält über sechzig Slash-Befehle, aber für produktive tägliche Arbeit reicht ein Basis-Kern aus.

### 4.1. Übersichtstabelle der wichtigsten und fortgeschrittenen Slash-Befehle

Unten finden Sie einen strukturierten Leitfaden der wichtigsten CLI-Befehle:

| Befehl | Kategorie | Zweck und Verhalten |
| --- | --- | --- |
| `/init` | Konfiguration | Scannt das Projekt und erstellt die primäre `CLAUDE.md`. |
| `/memory` | Konfiguration | Öffnet die Projektgedächtnisdatei zur direkten Bearbeitung. |
| `/clear` | Kontext | Setzt die aktuelle Unterhaltung zurück, behält aber das Projektgedächtnis. |
| `/compact [focus]` | Kontext | Komprimiert die Sitzungshistorie unter Beibehaltung angegebener Schlüsselaspekte. |
| `/context` | Kontext | Zeigt den detaillierten Füllstand des Kontextfensters. |
| `/plan` | Planung | Schaltet die CLI in den Nur-Lese- und Schrittplanungsmodus. |
| `/diff` | Überprüfung | Zeigt eine interaktive Vorschau aller Änderungen der aktuellen Sitzung. |
| `/code-review [--fix]` | Überprüfung | Analysiert nicht committete Änderungen auf logische Fehler. |
| `/security-review` | Überprüfung | Spezialisiertes Code-Audit auf Schwachstellen. |
| `/resume [session]` | Navigation | Stellt eine vorherige Sitzung anhand ihrer ID oder ihres Namens wieder her. |
| `/branch [name]` | Navigation | Erstellt einen separaten Gesprächszweig ohne Neustart der Sitzung. |
| `/rewind` | Navigation | Rollt den Datei- oder Dialogzustand auf einen früheren Checkpoint zurück. |
| `/model` | Produktivität | Wechselt das Arbeitsmodell (Sonnet, Haiku, Opus) mitten im Gespräch. |
| `/effort` | Produktivität | Reguliert die Tiefe der Reasoning-Kette des Modells (von low bis max). |
| `/cost` | Produktivität | Gibt Statistiken zu Token-Kosten und Sitzungsbalance aus. |
| `/agents` | Delegation | Verwaltet spezialisierte Sub-Agenten und Hintergrundtasks. |
| `/permissions` | Konfiguration | Interaktives Menü zur Anzeige und Änderung der Berechtigungsliste. |
| `/hooks` | Konfiguration | Diagnose-Panel für registrierte System-Hooks. |
| `/doctor` | Diagnostik | Umfassende Prüfung der Umgebung, Netzwerkverbindung und Systemkeys. |

![Überblick und Navigation der eingebauten Slash-Befehle in Claude Code](/api/guides-media/automation/claude-code-agentic-programming-setup-guide/images/claude-code-agentic-programming-setup-guide-extra-01.webp)

### 4.2. Die Triade der täglichen Produktivität: /compact, /plan und /diff

Für schnelles Onboarding empfiehlt es sich, drei Pflichtwerkzeuge zu verinnerlichen:
1. **`/plan`** – starten Sie dies immer am Anfang einer komplexen Aufgabe. Dies eliminiert chaotische, unkontrollierte Code-Edits ohne klares Verständnis der Konsequenzen.
2. **`/compact`** – verwenden Sie dies alle 20–30 Minuten aktiven Dialogs oder nach Abschluss einer Teilaufgabe, um Geschwindigkeitsverluste und Aufmerksamkeitsmangel des Modells zu verhindern.
3. **`/diff`** – öffnen Sie dies vor jedem Commit zur schrittweisen visuellen Verifikation des generierten Codes.

## 5. Erstellung eines eigenen /truth-Befehls

Der Befehl `/truth` ist nicht Teil des Standard-Lieferumfangs von Claude Code, löst aber ein fundamentales Problem des agentischen Programmierings – die Tendenz des Modells, Erfolg zu melden, ohne die Ergebnisse tatsächlich im Dateisystem überprüft zu haben.

### 5.1. Konzept der Faktenverifikation gegen die Codebasis

Wenn der Agent behauptet: *„Ich habe den Typ in Datei X aktualisiert und die Imports in Datei Y überprüft“*, stützt er sich oft auf seine eigenen Zwischenabsichten aus dem Kontext. Das Konzept des `/truth`-Befehls besteht darin, reale Dateien zwangsweise vom Disk neu zu laden und jede Aussage mit `git diff` abzugleichen.

![Interaktives Management von Kontext, Sitzungen und Claude Code-Befehlen](/api/guides-media/automation/claude-code-agentic-programming-setup-guide/images/claude-code-agentic-programming-setup-guide-extra-02.webp)

### 5.2. Implementierung des Skills .claude/skills/truth/SKILL.md

Benutzerdefinierte Befehle werden als Skills (Fähigkeiten) gestaltet. Erstellen Sie die Datei `.claude/skills/truth/SKILL.md` in Ihrem Projekt:

```markdown
---
description: "Verify Claude's most recent claims and edits against the actual codebase"
allowed-tools: ["Read", "Grep", "Glob", "Bash(git diff:*)"]
---

Re-examine everything you just told me in this conversation against what actually exists in the codebase right now. Specifically:

1. For every file you claim to have edited, read it again and confirm the change is actually present and matches what you described.
2. For every claim about existing code (a function's behavior, a config value, an import, a dependency version), verify it against the real file rather than your memory of reading it earlier in the session.
3. Run `git diff` and compare the actual diff against what you described changing.
4. Report back plainly: which claims checked out, which didn't, and exactly what the discrepancy was for anything that failed. Do not soften or hedge a discrepancy you find, state it directly.
```

Dank der Isolation in `allowed-tools` hat der Befehl physisch keine Berechtigung, Dateien zu ändern – er fungiert ausschließlich als unabhängiger Auditor.

## 6. Sub-Agenten und parallele Arbeit

Bei der Arbeit an großen Projekten entsteht das Problem der Kontextüberlastung: Das Lesen dutzender Dateien und das Ausführen schwerer Tests füllen das verfügbare Kontextfenster schnell.

### 6.1. Kontextisolierung und spezialisierte Sub-Agenten (/agents)

Ein Sub-Agent ist eine separate Instanz von Claude Code mit eigenem isoliertem Kontext, Toolset und eng gefasstem Systemprompt. Er löst die zugewiesene Teilaufgabe autonom und gibt in die Hauptsitzung nur eine knappe Zusammenfassung zurück.

```bash
# Відкрити інтерактивне меню субагентів усередині сесії
/agents
```

Sie können auch einen permanenten Sub-Agenten deklarativ in der Datei `.claude/agents/code-reviewer.md` beschreiben:
- Gewähren Sie ihm nur Lesezugriff (`Read`, `Grep`, `Glob`).
- Weisen Sie ihm ein schnelles und sparsames Modell zu.
- Verbieten Sie ihm eigene Codeänderungen, um ihn zu einem zuverlässigen Reviewer zu machen.

### 6.2. Skalierung von Aufgaben über Worktree und Batch-Ausführung (/batch)

Für die parallele Ausführung mehrerer unabhängiger Aufgaben unterstützt Claude Code den Git Worktree-Modus und den `/batch`-Befehl:
- **Parallele Bäume (`--worktree`):** Mehrere Agenten arbeiten in separaten, isolierten Arbeitskopien des Repositorys ohne Konflikte durch Dateisperrungen.
- **Batch-Modus (`/batch`):** Ausführung ähnlicher Refactoring- oder Dokumentationsaufgaben im Hintergrundthread.

## 7. Fertiges Template für CLAUDE.md und settings.json

Hier sind praxiserprobte Konfigurationsdateien, die Sie in Ihr Projekt-Repository committen sollten, um eine stabile Produktionsumgebung zu schaffen.

### 7.1. Basis-Template für das Gedächtnis CLAUDE.md

Speichern Sie den folgenden Inhalt in der Datei `CLAUDE.md` im Root Ihres Repositorys:

```markdown
# Project Context

### Stack
- Language/Framework: [Node.js, TypeScript, Next.js / Python, FastAPI]
- Styling: [Tailwind CSS]
- Database: [PostgreSQL / SQLite via Drizzle ORM]

### Commands
- Dev server: `npm run dev`
- Build: `npm run build`
- Test: `npm test`
- Lint: `npm run lint`

### Conventions
- Strict TypeScript typing without `any`
- Functional React components with named exports
- Keep business logic in services or hooks, not inside UI components

### Before finishing any task
- Run test suite and confirm 100% pass rate
- Run `/truth` if the task involved modifying multiple files
```

### 7.2. Produktions-Config .claude/settings.json mit Hooks

Speichern Sie die Konfiguration in `.claude/settings.json`:

```json
{
  "permissions": {
    "allow": [
      "Bash(npm test:*)",
      "Bash(npm run lint:*)",
      "Read(**)"
    ],
    "ask": [
      "Bash(git push:*)"
    ],
    "deny": [
      "Bash(rm -rf /*)",
      "Bash(sudo:*)",
      "Read(.env)"
    ]
  },
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "python3 .claude/hooks/block-dangerous-bash.py"
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$CLAUDE_TOOL_INPUT_FILE_PATH\""
          }
        ]
      }
    ]
  }
}
```

Verwenden Sie für lokale, maschinenspezifische Einstellungen `.claude/settings.local.json` und fügen Sie diese zur `.gitignore` hinzu.

## 8. Fazit und Ready-Checkliste

Eine hochwertige Umgebung für agentisches Programmieren unterscheidet sich vom chaotischen Chat durch die Vorab-Konfiguration von Schutzmechanismen, Gedächtnisregeln und klaren Prüfprotokollen.

### 8.1. Schlüsselprinzipien des agentischen Programmierens

1. **Kontext muss sauber sein:** Nutzen Sie regelmäßig `/compact` und lagern Sie lange Aufgaben in Sub-Agenten aus.
2. **Gedächtnis muss geschrieben sein:** Wenn eine Regel wichtig ist – fixieren Sie sie in `CLAUDE.md`, statt sie in Nachrichten zu wiederholen.
3. **Aktionen müssen überprüft werden:** Aktivieren Sie `/truth` und `/diff`, bevor Sie Änderungen im Version Control System fixieren.

### 8.2. Checkliste für die Erstkonfiguration des Workspace

| Phase | Aktion | Status der Bereitschaft |
| --- | --- | --- |
| **Installation** | Nativer Claude Code CLI installiert und Authentifizierung durchlaufen | `Pflicht` |
| **Projektgedächtnis** | `CLAUDE.md` erstellt mit Beschreibung des Stacks, Befehle und Konventionen | `Pflicht` |
| **Berechtigungen** | Listen `allow`, `ask` und `deny` in `settings.json` formuliert | `Pflicht` |
| **Formatierungs-Hook** | `PostToolUse` für automatischen Prettier-Aufruf konfiguriert | `Empfohlen` |
| **Sicherheits-Skript** | `block-dangerous-bash.py` via `PreToolUse` verbunden | `Empfohlen` |
| **Custom Skill** | Verifikationsbefehl `.claude/skills/truth/SKILL.md` erstellt | `Empfohlen` |