Subagents 101: Spezialisieren Sie Ihren Claude Code Workflow

Wenn Sie Claude Code für ein komplexes Projekt verwenden, bitten Sie eine KI, Experte für alles zu sein: Datenbankdesign, API-Entwicklung, Frontend-Komponenten, Testing, Dokumentation, Sicherheitsreview. Das ist viel verlangt.

Subagents bieten einen anderen Ansatz: spezialisierte KI-Assistenten, die jeweils spezifische Domänen behandeln. Der Hauptagent orchestriert, während Subagents in ihren Fachgebieten ausführen.

Lassen Sie mich zeigen, wie das funktioniert und warum es wichtig ist.

Was sind Subagents?

Ein Subagent ist eine Claude Code-Instanz, die für eine spezifische Aufgabe oder Domäne konfiguriert ist. Anstatt einer generalistischen KI, die alles macht, haben Sie:

• Einen Hauptorchestrator, der das Gesamtprojekt versteht und die Arbeit koordiniert
• Spezialisierte Subagents, die spezifische Aufgaben mit fokussierter Expertise behandeln

Denken Sie daran wie ein Software-Team. Sie haben einen Architekten, der das System entwirft, aber Sie haben auch Datenbank-Spezialisten, Frontend-Entwickler, Sicherheitsingenieure. Jeder bringt tiefe Expertise in seine Domäne.

Warum Subagents wichtig sind

Kontextmanagement

Claude Codes Kontextfenster ist gross (200K Token), aber nicht unendlich. Komplexe Projekte können es schnell erschöpfen, wenn Sie versuchen, die gesamte Codebasis im Kontext zu halten.

Subagents helfen durch Kompartimentierung. Der Datenbank-Subagent muss nur Schema-Dateien und Migrationscode sehen. Der Frontend-Subagent braucht nur Komponenten-Code und API-Verträge. Jeder arbeitet in einem fokussierten Kontext.

Domänenexpertise

Ein generalistischer Prompt funktioniert für die meisten Aufgaben vernünftig gut. Aber ein Prompt, der für Datenbankarbeit optimiert ist—mit Wissen über Indexierungsstrategien, Normalisierungsregeln, Query-Optimierung—produziert bessere Ergebnisse für Datenbankaufgaben.

Subagents ermöglichen es Ihnen, spezialisierte Prompts für jede Domäne zu erstellen.

Parallele Ausführung

Wenn Aufgaben unabhängig sind, können Subagents gleichzeitig arbeiten. Während der Datenbank-Subagent Migrationen erstellt, kann der Frontend-Subagent Komponenten bauen. Der Hauptorchestrator führt die Ergebnisse zusammen.

Grundlegende Subagent-Architektur

Hier ist ein einfaches Subagent-Setup:

Hauptorchestrator
├── Datenbank-Subagent
│   └── Schema-Design, Migrationen, Queries
├── API-Subagent
│   └── Endpoint-Implementierung, Validierung
├── Frontend-Subagent
│   └── Komponenten, State-Management
└── Test-Subagent
    └── Unit-Tests, Integrationstests

Der Orchestrator

Der Hauptagent liest die Spec, zerlegt Arbeit in domänenspezifische Aufgaben und delegiert:

claude --print "
Du bist der Projekt-Orchestrator. Lies docs/spec.md.

Für jede Anforderung:
1. Identifiziere, zu welcher Domäne sie gehört (Datenbank, API, Frontend, Test)
2. Erstelle eine Aufgabendatei in tasks/[domain]/[task-id].md
3. Füge allen Kontext ein, den der Subagent braucht
4. Tracke Aufgabenabhängigkeiten

Implementiere nichts selbst. Dein Job ist Koordination.
"

Der Subagent

Jeder Subagent läuft mit einem domänenspezifischen Prompt:

# Datenbank-Subagent
claude --print "
Du bist ein Datenbank-Spezialist. Deine Expertise:
- PostgreSQL Schema-Design
- Migrationsstrategien
- Query-Optimierung
- Index-Auswahl

Lies deine Aufgabe von tasks/database/current.md
Implementiere sie in src/db/
Führe Validierung mit 'npm run db:validate' aus
Wenn erledigt, schreibe Status nach tasks/database/current.status
"

Praktische Subagent-Konfigurationen

Datenbank-Subagent

# Datenbank-Subagent Konfiguration

## Expertise
- PostgreSQL Schema-Design und Migrationen
- Prisma ORM Operationen
- Query-Optimierung und Indexierung
- Datenintegritäts-Constraints

## Verfügbare Befehle
- npm run db:migrate -- Migration erstellen
- npm run db:push -- Schema-Änderungen pushen
- npm run db:seed -- Testdaten einfügen
- npm run db:validate -- Schema validieren

## Konventionen
- Migrationen in prisma/migrations/
- Immer Rollback-Strategie einschliessen
- UUID für Primary Keys verwenden
- Soft Delete (deletedAt) statt Hard Delete

## Kontextdateien
- prisma/schema.prisma
- src/db/queries/
- docs/data-model.md

API-Subagent

# API-Subagent Konfiguration

## Expertise
- Express.js Route Handler
- Request-Validierung mit Zod
- Fehlerbehandlungs-Muster
- Authentifizierungs-Middleware

## Verfügbare Befehle
- npm run dev -- Dev-Server starten
- npm run test:api -- API-Tests ausführen
- npm run lint -- Code-Stil prüfen

## Konventionen
- Routes in src/routes/
- Validierungs-Schemas in src/validation/
- Fehler-Responses folgen RFC 7807
- Alle Endpoints erfordern Authentifizierung, sofern nicht als public markiert

## Kontextdateien
- src/routes/
- src/middleware/
- src/validation/
- docs/api-spec.md

Frontend-Subagent

# Frontend-Subagent Konfiguration

## Expertise
- React 18+ mit Hooks
- TypeScript Strict Mode
- Tailwind CSS Styling
- React Query für Datenabruf

## Verfügbare Befehle
- npm run dev -- Dev-Server starten
- npm run test -- Komponententests ausführen
- npm run storybook -- Komponenten-Viewer starten

## Konventionen
- Komponenten in src/components/
- Eine Komponente pro Datei
- Nur Function Components verwenden
- Props-Interface über der Komponente definiert

## Kontextdateien
- src/components/
- src/hooks/
- src/styles/
- docs/design-system.md

Orchestrierungsmuster

Sequenzielle Ausführung

Wenn Aufgaben Abhängigkeiten haben:

#!/bin/bash

# 1. Datenbank zuerst
echo "Führe Datenbank-Subagent aus..."
claude --prompt "$(cat prompts/db-subagent.md)" \
  --context "task: User-Schema erstellen"

# 2. API hängt von Datenbank ab
echo "Führe API-Subagent aus..."
claude --prompt "$(cat prompts/api-subagent.md)" \
  --context "task: User-Endpoints erstellen"

# 3. Frontend hängt von API ab
echo "Führe Frontend-Subagent aus..."
claude --prompt "$(cat prompts/frontend-subagent.md)" \
  --context "task: User-Komponenten erstellen"

# 4. Tests hängen von Implementierung ab
echo "Führe Test-Subagent aus..."
claude --prompt "$(cat prompts/test-subagent.md)" \
  --context "task: User-Funktionalität testen"

Parallele Ausführung

Wenn Aufgaben unabhängig sind:

#!/bin/bash

# Unabhängige Subagents parallel ausführen
claude --prompt "$(cat prompts/db-subagent.md)" \
  --context "task: Analytics-Schema erstellen" &
PID_DB=$!

claude --prompt "$(cat prompts/api-subagent.md)" \
  --context "task: Auth-Middleware erstellen" &
PID_API=$!

# Auf beide warten
wait $PID_DB $PID_API

# Mit abhängigen Aufgaben fortfahren
echo "Parallele Aufgaben erledigt, fahre fort..."

Cross-Model Review

Verschiedene Modelle nutzen, um gegenseitig die Arbeit zu prüfen:

# Implementierung mit Claude
claude --prompt "$(cat prompts/implement.md)"

# Review mit anderer Perspektive
claude --prompt "
Prüfe den Code in src/auth/.
Suche nach:
- Sicherheitslücken
- Nicht behandelte Grenzfälle
- Performance-Probleme

Sei kritisch. Finde Probleme.
"

Praxisbeispiel: Ein E-Commerce-Feature bauen

Lassen Sie mich ein echtes Beispiel durchgehen: Hinzufügen eines Produktkatalogs zu einer E-Commerce-Site.

Schritt 1: Orchestrator erstellt Aufgaben

claude --print "
Lies docs/specs/product-catalog.md

Erstelle Aufgaben für jeden Subagent:
- Datenbank: Produkt-Schema, Kategorien, Bilder
- API: Produkt-CRUD, Suche, Filterung
- Frontend: Produktliste, Detailansicht, Such-UI
- Test: Gesamte Testabdeckung

Schreibe Aufgaben nach tasks/[subagent]/
"

Schritt 2: Datenbank-Subagent führt aus

claude --print "
Du bist der Datenbank-Spezialist.

Lies tasks/database/product-schema.md

Implementiere:
1. Produkt-Tabelle mit allen Feldern
2. Kategorie-Tabelle mit Hierarchie
3. Produkt-Kategorie Many-to-Many
4. Bild-Speicher-Referenzen
5. Geeignete Indexes für Suche

Validiere mit 'npm run db:validate'
Schreibe Status nach tasks/database/product-schema.status
"

Schritt 3: API-Subagent führt aus

claude --print "
Du bist der API-Spezialist.

Lies tasks/api/product-endpoints.md
Lies das Datenbank-Schema von prisma/schema.prisma

Implementiere:
1. GET /products (mit Filterung, Paginierung)
2. GET /products/:id
3. POST /products (nur Admin)
4. PUT /products/:id (nur Admin)
5. DELETE /products/:id (nur Admin)

Teste mit 'npm run test:api'
Schreibe Status nach tasks/api/product-endpoints.status
"

Schritt 4: Ergebnisse zusammengeführt

Der Orchestrator liest alle Status-Dateien und verifiziert, dass die Integration End-to-End funktioniert.

Ressourcen

Awesome Claude Code Subagents

Die Community hat eine Bibliothek spezialisierter Subagents für häufige Aufgaben aufgebaut:

awesome-claude-code-subagents

Kategorien umfassen:

• Datenbank-Spezialisten (PostgreSQL, MongoDB, Redis)
• Framework-Experten (Next.js, FastAPI, Django)
• Sprach-Spezialisten (TypeScript, Python, Rust)
• Domänen-Experten (Sicherheit, Performance, Barrierefreiheit)

Eigene bauen

Starten Sie mit diesen Fragen:

1. Welche Domänen existieren in Ihrem Projekt?
2. Welche Expertise erfordert jede Domäne?
3. Welche Dateien berührt jede Domäne?
4. Welche Befehle verwendet jede Domäne?

Bauen Sie eine Prompt-Datei für jede Domäne. Starten Sie einfach und verfeinern Sie basierend auf Ergebnissen.

Wann Subagents verwenden

Gut geeignet

• Grosse Projekte mit mehreren Domänen
• Teams mit etablierten Konventionen pro Domäne
• Projekte, die spezialisierte Expertise erfordern
• Möglichkeiten für parallele Arbeit

Übertrieben

• Kleine Projekte (nutzen Sie einfach eine Claude Code Instanz)
• Arbeit in einer einzelnen Domäne
• Erkundungs-/Prototyping-Phase
• Wenn der Kontext bequem in eine Instanz passt

Das grössere Bild

Subagents repräsentieren einen Wandel in der Art, wie wir über KI-gestützte Entwicklung denken. Anstatt einer allwissenden KI haben wir ein Team von Spezialisten, koordiniert von einem Orchestrator.

Das spiegelt wider, wie menschliche Teams arbeiten. Und während KI-Fähigkeiten wachsen, skaliert das Subagent-Muster: mehr spezialisierte Agenten, bessere Koordination, komplexe Projekte in handhabbare Teile zerlegt.

Bei sightful verwende ich Subagent-Muster für grössere Kundenprojekte. Der Orchestrator bin ich—Anforderungen verstehen, Arbeit aufteilen, Ergebnisse validieren. Die Subagents übernehmen die Implementierung in ihren Domänen.

Es ist ein mächtiges Modell, um Software effizient zu bauen.

---

Bereit zu erkunden, wie Subagent-Architektur für Ihr Projekt funktionieren könnte? Buchen Sie ein kostenloses Gespräch und lassen Sie uns Ihre spezifischen Bedürfnisse besprechen.