Claude Code meistern – Teil 2: Skills, Hooks, Sub-Agents und Worktrees

Teil 1 hat CLAUDE.md, den Research-Plan-Implement-Workflow und Kontextmanagement behandelt. Hier geht es um die fortgeschrittene Ebene: die vier Features, die aus Claude Code einen echten Orchestrator machen — und die die meisten Nutzer entweder gar nicht kennen oder falsch verstehen.

---

Skills: wiederverwendbare Workflows als Slash-Commands

Wichtiger Hinweis vorab: Das alte .claude/commands/-Format funktioniert noch, ist aber Legacy. Das aktuelle Format laut Dokumentation sind Skills in .claude/skills/<name>/SKILL.md. Der Unterschied ist nicht trivial: Skills unterstützen YAML-Frontmatter, können von Claude autonom geladen werden und lassen sich direkt mit Sub-Agents verknüpfen.

Struktur einer Skill-Datei:

.claude/skills/
  security-scan/
    SKILL.md
  pr-summary/
    SKILL.md

Beispiel: .claude/skills/security-scan/SKILL.md

---
name: security-scan
description: Run a security vulnerability scan on the codebase. Use when the user asks about security, CVEs, or before a production deploy.
allowed-tools: Read, Grep, Glob
model: claude-opus-4-6
---
Analyze the codebase for security vulnerabilities including:
- SQL injection risks
- XSS vulnerabilities
- Exposed credentials in code or config files
- Insecure configurations

Report findings grouped by severity: Critical / High / Medium / Low.

Aufruf: /security-scan — oder Claude lädt den Skill autonom, sobald die description zur aktuellen Aufgabe passt.

Das $ARGUMENTS-Platzhalter-Feature funktioniert in beiden Formaten: /security-scan src/api/ übergibt src/api/ als Argument.

Wichtig: Bestimmte Namen sind intern reserviert. Die vollständige Liste der Built-in Commands steht in der Slash Commands Referenz.

Skills mit context: fork — isolierte Ausführung

Das mächtigste Frontmatter-Feld: context: fork startet den Skill in einem eigenen Sub-Agent. Der Skill läuft isoliert — kein Zugriff auf die aktuelle Konversationshistorie, aber der Parent-Agent bekommt das Ergebnis zurück.

---
name: deep-research
description: Research a topic thoroughly in the codebase
context: fork
agent: Explore
---
Research $ARGUMENTS thoroughly:
1. Find relevant files using Glob and Grep
2. Read and analyze the code
3. Summarize findings with specific file references

Der agent: Explore-Wert gibt an, welcher Sub-Agent-Typ verwendet wird. Explore ist ein Built-in, der auf Read-only-Tools optimiert ist — kein versehentliches Schreiben während der Recherche.

---

Hooks: deterministische Kontrolle über den Agent-Lifecycle

Hooks sind Shell-Skripte, die Claude Code an definierten Punkten im Lifecycle ausführt. Konfiguriert werden sie in ~/.claude/settings.json (global) oder .claude/settings.json (Projekt).

Die vollständige Hooks-Referenz listet alle Events — hier die wichtigsten:

Event	Wann	Besonderheit
PreToolUse	Vor jedem Tool-Aufruf	Kann Tool blockieren oder erlauben
PostToolUse	Nach jedem Tool-Aufruf	Kann Feedback an Claude schicken
UserPromptSubmit	Wenn User Prompt submitted	stdout wird Claude als Kontext injiziert
Stop	Wenn Claude fertig ist	Kann Claude zwingen weiterzumachen
SubagentStop	Wenn Sub-Agent fertig ist	Wie Stop, aber für Agents
WorktreeCreate	Wenn Worktree erstellt wird	Ersetzt die Default-Worktree-Logik
SessionStart	Beim Session-Start	Kontext injizieren

Kommunikationskanal: Claude Code übergibt JSON-Daten via stdin an das Skript. Das Skript kommuniziert zurück über Exit-Code und stdout/stderr:

• Exit 0 + kein JSON: alles normal
• Exit 2: blockieren, Nachricht aus stderr geht an Claude
• Exit 0 + JSON-Objekt: feingranulare Steuerung

Praktisches Beispiel — Formatter-Hook:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit|MultiEdit",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs -I{} sh -c 'echo {} | grep -q .rs$ && cargo fmt -- {} || true'"
          }
        ]
      }
    ]
  }
}

Jedes Mal wenn Claude eine .rs-Datei schreibt, läuft automatisch cargo fmt. Claude sieht den Output und kann darauf reagieren.

Kontextinjektion mit UserPromptSubmit:

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo "Current git branch: $(git branch --show-current). Last commit: $(git log -1 --oneline)""
          }
        ]
      }
    ]
  }
}

Bei UserPromptSubmit ist stdout der Sonderfall: Exit 0 + stdout → der Text wird Claude als Kontext injiziert. Claude weiß damit bei jedem Prompt automatisch, auf welchem Branch du arbeitest.

Gefährliche Befehle blockieren:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "jq -e '.tool_input.command | test("rm -rf|git push --force|git reset --hard")' && exit 2 || exit 0",
            "timeout": 5
          }
        ]
      }
    ]
  }
}

Exit 2 blockiert den Tool-Call. Die stderr-Nachricht geht als Feedback an Claude — es kann dann einen anderen Weg wählen.

---

Sub-Agents: spezialisierte Assistenten mit eigenem Kontext

Sub-Agents sind in .claude/agents/ als Markdown-Dateien definiert. Jeder Agent hat einen eigenen Kontext-Window und kann auf spezifische Tools eingeschränkt werden. Die Subagents-Dokumentation erklärt das System vollständig.

Beispiel: .claude/agents/test-runner.md

---
name: test-runner
description: Use proactively when tests need to be run or when test failures need to be fixed. Runs tests and iterates until they pass.
tools: Bash, Read, Edit
---
You are a test automation expert. Your only job is running tests and fixing failures.

When invoked:
1. Run the full test suite: `cargo nextest run`
2. Analyze failures
3. Fix the root cause (not the test)
4. Re-run until green
5. Report what you changed

Claude kann diesen Agent autonom aufrufen (wenn die description passt) oder du rufst ihn explizit auf: "Use the test-runner agent to fix the failing tests".

Wichtig für Tool-Sicherheit: Wenn tools weggelassen wird, erbt der Agent alle Tools. Wer einen Read-only-Analysten will, muss das explizit einschränken:

---
name: doc-reviewer
description: Review documentation for accuracy and completeness
tools: Read, Grep, Glob
---

Sub-Agents und Kontext: Ein Sub-Agent startet mit einem leeren Kontext. Die einzige Verbindung zum Parent ist der Prompt-String beim Aufruf. Alles was der Agent wissen muss — Dateipfade, Fehlermeldungen, Entscheidungen — muss explizit in diesem Prompt mitgegeben werden.

Das /agents-Kommando in Claude Code bietet ein interaktives Interface zum Erstellen und Verwalten von Agents, inkl. MCP-Tool-Auswahl.

---

Git Worktrees: parallele Sessions ohne Kollisionen

Claude Code hat nativen Worktree-Support via --worktree / -w Flag — kein manuelles git worktree add nötig:

# Erstellt .claude/worktrees/feature-auth/ mit neuem Branch
claude --worktree feature-auth

# Zweite Session parallel
claude --worktree bugfix-123

# Name automatisch generiert
claude --worktree

Laut Common Workflows Doku handhabt Claude Code das Cleanup selbst: Kein Commit → Worktree und Branch werden beim Beenden automatisch entfernt. Mit Commits → Branch bleibt erhalten.

Manueller Worktree für bestehende Branches:

# Existing branch auschecken
git worktree add ../project-bugfix bugfix-123

# Neue Branch in spezifischem Verzeichnis
git worktree add ../project-feature-a -b feature-a

cd ../project-feature-a && claude

Sub-Agents mit Worktree-Isolation:

Sub-Agents können über das Frontmatter automatisch in eigene Worktrees laufen:

---
name: parallel-refactor
description: Refactor a module in isolation
isolation: worktree
---
Refactor $ARGUMENTS following the project conventions in CLAUDE.md.
Work in isolation. Do not modify files outside the target module.

Jeder Agent-Aufruf bekommt seinen eigenen Worktree — automatisch angelegt und nach Abschluss aufgeräumt. Das bedeutet: mehrere Refactoring-Agents können gleichzeitig laufen, ohne sich gegenseitig zu blockieren.

WorktreeCreate Hook für volle Kontrolle:

{
  "hooks": {
    "WorktreeCreate": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/worktree-setup.sh"
          }
        ]
      }
    ]
  }
}

Der Hook ersetzt Claudes Default-Worktree-Logik komplett — nützlich wenn du immer von einem bestimmten Remote-Branch branchen oder zusätzliche Setup-Schritte ausführen willst.

---

Das Zusammenspiel

Alle vier Konzepte greifen ineinander:

Skill (context: fork)
  → spawnt Sub-Agent (agent: Explore)
    → Sub-Agent läuft in eigenem Worktree (isolation: worktree)
      → Hooks laufen bei jedem Tool-Aufruf (PostToolUse formatter)

Ein konkretes Setup für ein Rust-Projekt:

1. Skill /pre-commit — führt Linting, Tests und Security-Scan durch, bevor ein Commit erlaubt wird
2. Hook PostToolUse auf Write|Edit — cargo fmt automatisch
3. Hook PreToolUse auf Bash — blockiert git push --force
4. Sub-Agent test-runner — läuft autonom nach Implementierungsränderungen
5. Worktree per Feature — claude --worktree feature-x

Das ist kein Overhead — das ist einmalige Konfiguration, die danach unsichtbar im Hintergrund läuft.

---

Teil 1: Claude Code meistern: Was die Top-Nutzer anders machen