# Claude Code — Harness Tutorial

> Pipeline-Rolle: **Richtung geben** (Wave 1 Scout)
> Claude Code entscheidet wo es lang geht. Die anderen Harnesses bauen.

---

## 1. Quick Start

```bash
cd ~/Projekte/MeinProjekt
claude                        # interaktive Session starten
# oder direkt in Plan Mode:
claude --plan                 # Architektur-Modus, kein Code wird geschrieben
```

Erste 3 Befehle in jeder Session:

```
> /status                    # Was ist offen? Welche Tasks?
> git status                 # Sauberer Working Tree?
> Lies BACKLOG.md            # Was steht an?
```

Dann Plan Mode aktivieren für Architektur-Entscheidungen:

```
> Plan Mode: Wie baue ich Feature X?
```

---

## 2. Typischer Workflow

**Reihenfolge einhalten — nicht improvisieren:**

1. **Plan Mode** — Erst denken, dann bauen. Architektur skizzieren lassen.
2. **Subagents spawnen** — Recherche parallel delegieren (`run_in_background: true`).
3. **Entscheidung treffen** — Samuel entscheidet zwischen Optionen, Claude Code schlägt vor.
4. **Tasksheet schreiben** — Ergebnis als Briefing fuer das naechste Harness exportieren.

Beispiel-Flow:

```
> Plan: Ich brauche ein Dashboard fuer AgentArena. Was sind meine Optionen?
[Plan Mode Output lesen]
> Spawne einen Subagent um FastAPI vs Flask zu vergleichen.
[Ergebnis abwarten]
> Entscheidung: FastAPI. Schreib ein Tasksheet fuer Hermes.
```

Tasksheet-Template liegt in `~/Projekte/harness-tasksheets/`.

---

## 3. Starken nutzen

**Orchestrierung:** Claude Code ist der einzige Harness der Subagents sauber koordiniert.
Parallel-Spawning nutzen wann immer Teilaufgaben unabhaengig sind.

```
> Spawne 3 Subagents parallel:
  - Agent 1: Lies src/api.py und fasse die Endpunkte zusammen
  - Agent 2: Recherchiere FastAPI WebSocket Best Practices
  - Agent 3: Pruefe ob tests/ aktuell sind
```

**Codebase-Analyse:** Grosse Codebases (100+ Dateien) — Claude Code liest
schneller und vollstaendiger als alle anderen Harnesses.

**CLAUDE.md als Verhaltenssteuerung:** Projektspezifische Regeln in
`~/Projekte/MeinProjekt/CLAUDE.md` schreiben. Claude Code haelt sich daran.

**Skills und Slash-Commands:** `/research`, `/status`, `/plan` — nutzen statt
manuell briefe formulieren.

---

## 4. Schwachen kompensieren

**Kosten:** Opus kostet ~$15/1M Tokens. Jede unnoetige Aktion verbrennt Geld.
- Nie Opus fuer Recherche nutzen — Sonnet-Subagent reicht
- Nie `cat grosse_datei.py` — Read-Tool mit Limit nutzen
- Explorationen begrenzen: nach 1 fehlgeschlagenen Ansatz STOPP, Samuel fragen

**Over-Engineering:** Claude Code neigt dazu mehr zu bauen als beauftragt.
- Scope explizit eingrenzen: "Nur Funktion X, nicht das ganze Modul"
- Nach Plan Mode pruefen: Ist das was geplant wurde was ich wollte?

**Session Hoarding:** Lange Sessions akkumulieren Context. Nach ~45 Minuten:
- `/compact` ausfuehren oder neue Session starten
- Wichtige Entscheidungen in Dateien schreiben, nicht im Chat lassen

**Nicht fuer Implementierung:** Claude Code plant und orchestriert.
Implementierung gehoert in Hermes oder OpenCode.

---

## 5. Handoff-Muster

**Von Claude Code zu OpenCode (Reality-Check):**

```bash
# Architektur-Doc exportieren
> Schreib ARCHITECTURE.md mit dem Plan den wir gerade erarbeitet haben
# Dann OpenCode briefen:
opencode run "Lies ARCHITECTURE.md und erstelle einen Gegenentwurf"
```

**Von Claude Code zu Hermes (Implementierung):**

```bash
# Tasksheet ausfullen
> Schreib ein Tasksheet fuer Hermes: Feature X, Scope Y, Output-Pfad Z
# Datei speichern als:
~/Projekte/harness-tasksheets/task-feature-x.md
# Hermes starten mit:
hermes chat
> [Tasksheet einfuegen]
```

**Kontext-Export fuer jedes Harness:**
- Entscheidungen → `ARCHITECTURE.md` oder `DECISIONS.md`
- Offene Tasks → `BACKLOG.md`
- Naechster Schritt → Tasksheet in `harness-tasksheets/`

---

## 6. Kosten-Tipps

**Wellenmodus respektieren:** Claude Code ist Wave 1 Scout. Nicht Wave 2 (Implementierung) oder Wave 3 (Polishing) ubernehmen.

```
Wave 1: Claude Code → Plan, Architektur, Briefing
Wave 2: OpenCode + Hermes → Implementierung, Reality-Check
Wave 3: Codex → Polishing, Docs, Ship
```

**Sonnet-Subagents statt Opus direkt:**

```
# Teuer:
> Recherchiere WebSocket-Patterns in Python
# Guenstig:
> Spawne Sonnet-Subagent: Recherchiere WebSocket-Patterns in Python
```

**Max 2 aktive Sessions:** Mehr als 2 parallele Claude Code Sessions = Context-Chaos und doppelte Kosten.

**Lesen vor Spawn:** Immer erst relevante Dateien lesen bevor ein Subagent gestartet wird. Verhindert dass der Subagent Dinge nochmal herausfindet die schon bekannt sind.

**Plan Mode vor allem anderen:** Plan Mode generiert keinen Code, kostet aber fast gleich viel. Trotzdem sinnvoll weil ein schlechter Plan = viel mehr Tokens fuer Korrekturen.

**Faustregeln:**
- Kurze Analyse: <$0.05
- Vollstaendige Codebase-Analyse: ~$0.20-0.50
- Subagent-Wave mit 3 Agents: ~$0.10-0.30
- Session ohne Fokus (>1h): $1-3+ → abbrechen