Claude Code Aufgabenverteilung

Problem: Größere Projekte in Claude Code werden durch sequentielle Ausführung ausgebremst. Du sitzt da und schaust zu, wie Claude eine Sache nach der anderen erledigt, obwohl dieselbe Arbeit auf mehrere Agenten verteilt werden könnte. Die Entwicklungsgeschwindigkeit sinkt auf das Tempo des langsamsten seriellen Schritts.

Schneller Gewinn: Füge dieses Delegationsmuster in deine CLAUDE.md ein und verweise darauf, wenn du nach einem komplexen Feature fragst:

# Feature Implementation Pattern
When implementing features, use 7-parallel-Task distribution:
1. **Component**: Create main component file
2. **Styles**: Create component CSS/styling
3. **Tests**: Create test files
4. **Types**: Create TypeScript definitions
5. **Hooks**: Create custom hooks/utilities
6. **Integration**: Update routing and imports
7. **Config**: Update docs and package.json

Fordere ein Feature an und Claude liest die CLAUDE.md-Anweisung, startet dann mehrere Task-Agenten parallel statt sie nacheinander in die Warteschlange zu stellen.

Wie Task-Orchestrierung wirklich funktioniert

Das Task-Tool ist der Mechanismus hinter der parallelen Ausführung in Claude Code. Das Aufrufen des Task-Tools startet einen unabhängigen Sub-Agenten mit eigenem Kontextfenster. Der Haupt-Claude-Agent hat interaktiven Overhead. Er wartet auf menschliche Antworten, wechselt zwischen Operationen und hält den Gesprächsstatus aufrecht. Task-Sub-Agenten reduzieren diese Kosten, indem sie spezialisierte Arbeit parallel erledigen.

Standardmäßig behandelt Claude Dateilesen, Suchen und Inhaltsabrufe über dedizierte Tools (Read, Grep, Glob) im Haupt-Thread. Task ist für das Starten von Sub-Agenten reserviert. Ohne explizite Delegationsanweisungen startet Claude selten parallele Agenten und bevorzugt sequentielle Ausführung. Die CLAUDE.md-Anweisung ändert diesen Standard.

Die Multithreading-Denkweise

Denk wie ein Programmierer, der Threads verwaltet. Claude kann mehrere spezialisierte Agenten gleichzeitig koordinieren, aber nur wenn die Delegation klar definiert ist. Ohne Aufgabengrenzen fällt Claude jedes Mal auf serielle Arbeit zurück.

Grundlegende Koordinationsprinzipien:

• Grenzdefinition: Jeder Agent besitzt bestimmte Dateitypen oder Operationen
• Konfliktvermeidung: Zwei Agenten schreiben nie in dieselbe Ressource
• Kontext-Optimierung: Unnötige Details vor der Delegation entfernen
• Logische Gruppierung: Kleine verwandte Aufgaben bündeln, um Überfragmentierung zu vermeiden

Das manuelle Routing für jede Anfrage richtig hinzubekommen ist die schwierige Seite. Ein komplexitätsbasierter Klassifikator kann Jobs automatisch sortieren: triviale Fixes gehen direkt an einen Spezialisten, moderate Aufgaben bekommen einen einzelnen Sub-Agenten, und komplexe Mehrphasen-Arbeit läuft durch eine Planungspipeline, bevor die parallelen Agenten gestartet werden. Einmal einrichten und das Routing ist keine manuelle Entscheidung mehr.

Parallele Verteilungsmuster

Das 7-Agenten-Feature-Muster

Füge das zur CLAUDE.md hinzu, um automatische parallele Verteilung einzuschalten:

## Parallel Feature Implementation Workflow
 
When implementing features, spawn 7 parallel Task agents:
 
1. **Component**: Create main component file
2. **Styles**: Create component styles/CSS
3. **Tests**: Create test files
4. **Types**: Create type definitions
5. **Hooks**: Create custom hooks/utilities
6. **Integration**: Update routing, imports, exports
7. **Remaining**: Update package.json, docs, config files
 
### Context Optimization Rules
 
- Strip comments when reading code files for analysis
- Each Task handles ONLY specified files or file types
- Task 7 combines small config/doc updates to avoid over-fragmentation

Feature-Builds werden deutlich schneller, weil serielle Engpässe verschwinden. Claude liest die Anweisung und verteilt die Arbeit auf Task-Agenten, ohne dass du es jedes Mal neu sagen musst.

Rollenbasierte Delegation

Für Code-Reviews und Analysen sagst du Claude, dass es spezialisierte Task-Agenten starten soll:

Analyze this codebase using parallel Task agents with these roles:
- Senior engineer: Architecture and performance
- Security expert: Vulnerability assessment
- QA tester: Edge cases and validation
- Frontend specialist: UI/UX optimization
- DevOps engineer: Deployment considerations

Jede Rolle neigt standardmäßig zu verschiedenen Tools und Blickwinkeln, sodass die kombinierte Ausgabe gründlicher ist als ein einzelner Agent jemals sein könnte.

Domain-spezifische Verteilung

Für Backend-Arbeit verwendest du eine explizite parallele Struktur im Prompt:

Implement user authentication system using parallel Task agents:
1. Database schema and migrations
2. Auth middleware and JWT handling
3. User model and validation
4. API routes and controllers
5. Integration tests
6. Documentation updates

Erfolgsprüfung: Claude ruft das Task-Tool mehrmals in einer Antwort auf und erstellt Agenten, die gleichzeitig laufen. Features, die im seriellen Modus lange dauern, werden erheblich schneller fertig, sobald die Arbeit parallelisiert ist.

Koordinationsregeln

Token-Kosten vs. Performance: Mehr Task-Agenten ist nicht immer besser. Jeder Task-Aufruf zahlt Einrichtungskosten für den Kontext. Verwandte Operationen zu gruppieren schlägt oft das Starten eines neuen Agenten für jeden kleinen Job.

Kontexterhaltung: Wenn Claude delegiert, entscheidet es, welchen Kontext jeder Agent bekommt. Schreibe deine Anweisungen so, dass jeder Agent die domänenspezifischen Informationen sieht, die er braucht, ohne den Rest des Projekts mitzuschleppen.

Konfliktlösung: Gestalte Aufgabengrenzen so, dass Schreibkollisionen verhindert werden. Teile nach Datei- oder Feature-Linien auf, niemals nach einzelnen Zeilen innerhalb einer Datei. Zwei Agenten, die in dieselbe Datei schreiben, erzeugen Merge-Konflikte.

Feedback-Integration: Task-Agenten übergeben ihre Ergebnisse zurück an die Hauptsitzung. Plane, wie Ausgaben zusammengeführt werden. Denke während der Orchestrierungsphase über Abhängigkeiten zwischen parallelen Aufgaben nach, nicht danach.

Erweiterte Verteilungsmuster

Diese Muster gehen über einfache Parallelität hinaus. Sie beheben Koordinationsprobleme, die auftreten, sobald du 5+ Agenten auf echten Features betreibst.

Validierungsketten

Das häufigste Qualitätsmuster trennt Aufbau und Verifizierung. Implementierungsagenten laufen parallel, du wartest bis alle fertig sind, dann laufen Validierungsagenten sequentiell gegen die kombinierte Ausgabe. Validierung muss sequentiell sein, weil Validatoren den finalen Zustand jeder Datei sehen müssen, nicht den Zwischenstand, dem sie zugewiesen wurden.

# Implementation phase (parallel Task agents)
Tasks 1-5: Core feature development

# Validation phase (sequential, after implementation)
Task 6: Integration testing
Task 7: Security review
Task 8: Performance verification

Ohne die zweiphasige Struktur prüfen Validierungsagenten Dateien, während andere Agenten noch hineinschreiben. Du bekommst falsche Positive und verpasste Probleme. Mehr zum Pairen von Spezialisten mit Validatoren findest du in den Sub-Agenten-Designmustern.

Forschungskoordination

Forschungsaufgaben parallelisieren gut, weil sie nur lesend sind. Kein Agent schreibt in geteilte Dateien, also ist das Konfliktrisiko null. Das macht Forschung zum sichersten Einstieg für die Aufgabenverteilung.

Research user dashboard implementations using parallel Tasks:
1. **Technical**: React dashboard libraries and patterns
2. **Design**: Modern dashboard UI/UX examples
3. **Performance**: Optimization strategies for data-heavy UIs
4. **Accessibility**: WCAG compliance for dashboard interfaces

Jeder Agent gibt eine strukturierte Zusammenfassung zurück. Der Orchestrator fügt die vier Berichte zu einer Empfehlung zusammen. Das ist schneller als einen Agenten zu bitten, alle vier Dimensionen nacheinander zu recherchieren, und die isolierten Kontexte verhindern, dass ein Forschungsthread einen anderen beeinflusst.

Domänenübergreifende Projekte

Full-Stack-Features berühren Frontend, Backend und Infrastruktur gleichzeitig. Der Wasserfall-Ansatz (erst Backend bauen, dann Frontend, dann Infra) ist sicher aber langsam. Parallele domänenübergreifende Verteilung ist schneller, aber sie erfordert strikte Dateigrenzen.

Die Regel: jeder Agent besitzt ein Verzeichnis, niemals eine einzelne Datei, die mit einem anderen Agenten geteilt wird. Der Backend-Agent besitzt src/api/, der Frontend-Agent besitzt src/components/, und der Infrastruktur-Agent besitzt infra/. Der gemeinsame Vertrag zwischen ihnen ist eine TypeScript-Interface-Datei oder ein API-Schema, das ein Agent zuerst (sequentiell) schreibt, bevor die parallele Phase beginnt. Für einen tieferen Blick auf die Strukturierung dieser Art von Multi-Domain-Koordination, sieh dir die Team-Orchestrierungsmuster an.

Häufige Verteilungsfehler

Überfragmentierung. Für jeden kleinen Vorgang einen neuen Task-Agenten zu starten verbrennt Token für die Einrichtung, ohne die Geschwindigkeit zu steigern. Prompts, die 12 Agenten für ein Feature starten, das 4 Dateien berührt, sind häufig. Jeder Agent braucht Initialisierungskontext (CLAUDE.md laden, Aufgabe verstehen), sodass 12 Agenten 12-mal Overhead zahlen, bevor echte Arbeit beginnt. Die Lösung: verwandte Mikro-Aufgaben bündeln. Ein Agent, der "Typen, Interfaces und Validierungsschemata" übernimmt, ist günstiger und schneller als drei Agenten, die je eine Datei bearbeiten.

Unterspecifikation. Vage Delegation zwingt Agenten zu raten. Sag einem Agenten "mach das Frontend" und er könnte dein Routing umschreiben, Komponenten refaktorieren, die du nie angefasst hast, und Bibliotheken einziehen, um die du nicht gebeten hast. Der parallele Ablauf bricht, weil die anderen Agenten die bestehende Komponenten-API erwartet haben. Gute Delegation nennt die genauen Dateien, die erstellt oder geändert werden sollen, die erwarteten Funktionssignaturen und das Ausgabeformat.

Ressourcenkonflikte. Das ist der zerstörerischste Fehler, weil er Code produziert, der vollständig aussieht und still kaputt ist. Zwei Agenten, die in dieselbe index.ts-Barrel-Datei schreiben, überschreiben gegenseitig ihre Exporte. Der letzte Schreiber gewinnt. Die Exporte des anderen Agenten verschwinden. Der Build könnte noch bestehen, wenn noch nichts die fehlenden Exporte importiert. Du findest das Problem erst später, wenn du das Feature benutzen willst. Weise Dateibesitz auf Agenten-Ebene zu, niemals auf Funktions-Ebene.

Kontext-Duplizierung. Eine überfüllte CLAUDE.md wird an jeden gestarteten Agenten übergeben. 400 Zeilen CLAUDE.md über 7 Agenten bedeutet 7 Kopien von 400 Zeilen, die in separate Kontexte geladen werden. Halte CLAUDE.md auf operative Regeln fokussiert statt auf enzyklopädische Projektdokumentation, und lass Agenten spezifische Dateien lesen, die sie brauchen, statt von Anfang an alles zu erben.

Was passiert, wenn die Verteilung schiefläuft

Hier ist ein echter Fehlerfall. Ein Entwickler hat ein Benutzereinstellungen-Feature auf 5 Agenten aufgeteilt: einer für die Datenbankmigration, einer für die API-Route, einer für die React-Formularkomponente, einer für Tests und einer für TypeScript-Typen. Klingt vernünftig. Das Problem: der Typen-Agent und der API-Agent mussten sich auf die Form des UserSettings-Interface einigen, liefen aber parallel ohne gemeinsamen Vertrag.

Der Typen-Agent erstellte UserSettings mit einem preferences-Feld als flaches Objekt. Der API-Agent baute die Route und erwartete preferences als verschachtelte Struktur mit theme- und notifications-Sub-Objekten. Der React-Formular-Agent nahm noch eine andere Form an, weil seine Anweisungen einfach sagten "Bau ein Einstellungsformular". Alle drei Agenten wurden erfolgreich fertig. Der Build schlug mit 14 Typ-Fehlern fehl.

Die Lösung war im Nachhinein offensichtlich: erst den Typen-Agenten sequentiell ausführen, dann die restlichen Agenten parallel starten. Dieser 30-sekündige sequentielle Schritt hätte 20 Minuten Debugging verhindert. Die Lektion: gemeinsame Interfaces sind Abhängigkeiten, und Abhängigkeiten müssen vor den Aufgaben laufen, die sie konsumieren. Deshalb existiert das oben beschriebene Validierungskettenmuster.

Nächste Schritte

Starte mit dem 7-Agenten-Feature-Muster bei der nächsten komplexen Implementierung. Füge die CLAUDE.md-Konfiguration ein und fordere dann ein Feature an. Mehrere Task-Tool-Aufrufe sollten in Claudes Antwort erscheinen.

Gewöhne dich an parallele Aufgabenverteilung, indem du zusammen mit dem Sub-Agent Design-Leitfaden übst, und skaliere dann zu erweiterter Koordination mit Agent Fundamentals.

Für die Entscheidung zwischen paralleler, sequentieller und Hintergrundausführung sieh dir den Sub-Agenten Best Practices-Leitfaden an.

Für spezifische Implementierungsmuster schau dir Custom Agents an und baue spezialisierte Task-Distributoren für deinen Workflow.

Beobachte deine Aufgabenabschluss-Geschwindigkeit. Ein richtig verteilter Durchlauf sollte deutlich schnellere Ergebnisse liefern als serielle Ausführung. Tracke die Metrik. Lass sie beeinflussen, wie du die nächste Arbeitsrunde dimensionierst und aufteilst.