File size: 5,848 Bytes

5134cea

# Hermes — Harness Tutorial

> Pipeline-Rolle: **Output bauen** (Wave 2, Implementierung)
> Hermes ist das guenstigste und anpassungsfahigste Arbeits-Harness. Hier entsteht der meiste Code.

---

## 1. Quick Start

```bash
cd ~/Projekte/MeinProjekt     # KRITISCH: IMMER im Projektordner starten
                              # NICHT in ~/.hermes/ oder irgendwo anders

hermes chat                   # interaktive Session
# oder mit spezifischem Modell:
hermes chat --model minimax/minimax-text-01
```

Erste 2 Minuten:

```
> [Tasksheet aus harness-tasksheets/ einfuegen]
> Bestatige: In welchem Verzeichnis arbeitest du gerade?
> Welche Dateien wirst du anlegen/aendern?
```

Den zweiten und dritten Schritt IMMER machen — Hermes driftet sonst
in `~/.hermes/` oder baut an der falschen Stelle.

---

## 2. Typischer Workflow

**Hermes ist fuer iteratives Arbeiten gemacht — nicht fuer Einmal-Outputs.**

1. **Tasksheet einfuegen** — Scope, Output-Pfad, Constraints klar definieren.
2. **Verzeichnis-Check** — Bestaetigen lassen wo Hermes gerade ist.
3. **Ersten Output** — Hermes baut. Warten, bis Output erscheint (kann kurz still sein).
4. **Feedback geben** — Konkret und priazise. Hermes nimmt Korrekturen gut an.
5. **Iterieren** — 2-4 Iterationen bis Ergebnis passt.
6. **Summary** — "Fasse zusammen was du geaendert hast" — fuer Handoff an Codex.

Beispiel-Flow:

```
> [Tasksheet einfuegen]
> Implementiere src/api.py mit dem /health Endpunkt.
[Output abwarten]
> Gut. Jetzt fuege /api/status hinzu, der {"agents": [], "status": "ok"} zurueckgibt.
[Output abwarten]
> Die agents-Liste soll aus config.yaml geladen werden. Hier ist der Pfad: config/agents.yaml
[Output abwarten]
> Fasse zusammen: Welche Dateien hast du veraendert und was hast du gemacht?
```

---

## 3. Starken nutzen

**Beste Feedback-Annahme:** Hermes akzeptiert Korrekturen ohne zu diskutieren.
Fehler direkt benennen — Hermes baut sofort weiter:

```
> Das ist falsch. src/api.py Zeile 23: status_code muss 200 sein, nicht 404.
  Korrigiere nur diese Zeile.
```

**Iteratives Arbeiten:** Ideal fuer Aufgaben die mehrere Runden brauchen.
Feature by Feature vorgehen statt alles auf einmal beauftragen.

```
# Statt:
> Implementiere das komplette Dashboard mit allen Endpunkten

# Besser:
> Implementiere nur /health
[fertig]
> Implementiere /api/agents
[fertig]
> Implementiere /api/status
```

**Guenstig fuer taeagliche Arbeit:** Mit MiniMax ~150x guenstiger als Opus.
Hermes fuer alle Routineaufgaben nutzen, Claude Code nur fuer Planung.

**Parallele unabhaengige Tasks mit --worktree:**

```bash
# Zwei unabhaengige Features parallel:
hermes chat --worktree feature-health-endpoint
hermes chat --worktree feature-agent-list
```

---

## 4. Schwachen kompensieren

**Scope-Drift: Hermes groesstes Problem.**
Ohne expliziten Output-Pfad baut Hermes in `~/.hermes/` statt im Projektordner.

IMMER im Tasksheet angeben:

```
Output-Pfad: /home/smlflg/Projekte/MeinProjekt/src/
Verzeichnis: /home/smlflg/Projekte/MeinProjekt/
NICHT: ~/.hermes/ oder relative Pfade
```

**Langsamer Start:** Hermes ist kurz still bevor Output kommt.
Das ist normal — nicht abbrechen und neu starten.
Nach ~10-15 Sekunden Stille: einmal Enter druecken.

**Output-Qualitaet mittel:** Hermes schreibt funktionalen aber
nicht eleganten Code. Fuer finales Polishing → Codex.

```
# Hermes-Output ist funktional:
def get_agents():
    with open("config.yaml") as f:
        return yaml.safe_load(f)["agents"]

# Codex macht daraus sauberen Code mit Error-Handling, Types, Docstrings
```

**Was passiert dann plotzlich Output:** Hermes denkt intern — der Output
kommt manchmal in einem Block. Das ist kein Fehler.

---

## 5. Handoff-Muster

**Von OpenCode zu Hermes:**

```
> Lies src/ — OpenCode hat das Geruest angelegt.
  Deine Aufgabe: Implementiere die Logik in src/api.py.
  Scope: Nur src/api.py und src/services/agent_service.py.
  Keine neuen Dateien anlegen.
```

**Von Hermes zu Codex (Polishing):**

```bash
# Hermes gibt Summary:
> Fasse zusammen: Welche Dateien hast du geaendert? Was hast du implementiert?
  Was fehlt noch? Was ist TODO?

# Summary in Tasksheet schreiben:
cat > ~/Projekte/harness-tasksheets/task-codex-polish.md << 'EOF'
Hermes hat implementiert:
- src/api.py: /health, /api/agents, /api/status
- src/services/agent_service.py: AgentService mit load_agents()

Aufgabe fuer Codex:
- Code-Review und Polishing
- Type Hints hinzufuegen
- Error Handling verbessern
- README.md aktualisieren
EOF
```

**--worktree fuer parallele Tasks:**

```bash
# Unabhaengige Features parallel:
hermes chat --worktree frontend    # baut src/templates/
hermes chat --worktree backend     # baut src/api.py
# Am Ende: git merge
```

---

## 6. Kosten-Tipps

**Guenstigstes Harness fuer iterative Arbeit.** MiniMax nutzen:

```bash
hermes chat --model minimax/minimax-text-01
```

**Tasksheet verhindert Scope-Drift = verhindert Token-Verschwendung:**
Drift bedeutet Hermes baut das Falsche → Session wegwerfen → neu starten.
Ein gutes Tasksheet kostet 2 Minuten aber spart eine komplette Re-Session.

**Feature by Feature ist guenstiger als Big-Bang:**

```
# Teuer (wenn ein Feature falsch → alles nochmal):
> Implementiere alle 8 Endpunkte

# Guenstiger (jeder Schritt kann frueh korrigiert werden):
> Implementiere /health
> [Feedback] Gut. Jetzt /api/agents.
```

**Iteration ist guenstig:** Eine Korrektur-Runde kostet <10% einer
neuen Session. Hermes iterieren lassen statt neu starten.

**Verzeichnis-Check ist kostenlos:** 2 Sekunden fragen wo Hermes arbeitet
verhindert eine weggeworfene Session wegen falschem Pfad.

**Faustregeln:**
- Einfache Funktion implementieren: ~$0.01-0.03
- Vollstaendiger Endpunkt mit Tests: ~$0.05-0.10
- Feature-Iteration (3-4 Runden): ~$0.10-0.20
- Re-Session wegen Scope-Drift: gleiche Kosten nochmal