Communitygithub.com

am-will/swarms: Co-Design Parallel-Aufgabenausführer mit Design…

Nur durch explizite /co-design-Befehle auslösbar. Paralleler Aufgabenausführer, der Frontend-/Design-Aufgaben an den Claude CLI Print-Modus weiterleitet, um überlegene Designergebnisse zu erzielen.

Was ist swarms: Co-Design Parallel-Aufgabenausführer mit Design…?

Diese Fertigkeit (Skill) implementiert einen Orchestrator für parallele Subagenten, der Entwicklungspläne ausführt, indem er Aufgaben basierend auf ihren Abhängigkeiten in Wellen startet. Der entscheidende Unterschied zu einem einfachen parallelen Aufgaben Tool ist die intelligente Aufgabenklassifizierung: 'Design'-Aufgaben (z.B. CSS, HTML, UI-Komponenten) werden über `claude -p` im Hintergrund-Shell-Modus ausgeführt, was dem Agenten volle CLI-Fähigkeiten und Tool-Zugriff gibt. 'Standard'-Aufgaben (Backend, Logik, Tests) nutzen das normale Task-Tool. Die Fertigkeit liest eine Markdown-Plan-Datei, extrahiert Aufgaben mit ihren Abhängigkeiten, klassifiziert jede Aufgabe und startet alle unblockierten Aufgaben parallel. Während Standard-Aufgaben direkt Ergebnisse liefern, werden Design-Agenten überwacht, indem ihre Ausgabe-Logs gelesen werden. Nach Abschluss jeder Welle werden Ergebnisse validiert, Aufgaben committet und der Plan aktualisiert. Der Zyklus wiederholt sich, bis alle Aufgaben erledigt sind.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/am-will/swarms/tree/HEAD/skills/co-design

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Co-Design: Paralleler Aufgabenausführer mit Design-Modus-Routing

Du bist ein Orchestrator für Subagenten. Verwende den Orchestrierungsmodus, um Plan-Dateien zu parsen und Aufgaben parallel an Subagenten zu delegieren, unter Verwendung von Aufgabenabhängigkeiten, in einer Schleife, bis alle Aufgaben abgeschlossen sind.

Wesentlicher Unterschied zum Standard-Parallelaufgaben: Wenn eine Aufgabe Frontend-Design, Styling, UI oder visuelle Arbeit umfasst, startest du sie über claude -p (Print-Modus) in einer Hintergrund-Shell, anstatt das Task-Tool zu verwenden. Dies gibt dem Design-Agenten volle CLI-Fähigkeiten und Tool-Zugriff. Alle anderen Aufgaben verwenden normale Task-Tool-Subagenten.

Aufgabenklassifizierung

Bevor du eine Aufgabe startest, klassifiziere sie als Design oder Standard:

Design-Aufgaben (Weiterleitung an claude -p)

Eine Aufgabe ist eine Design-Aufgabe, wenn sie in erster Linie IRGENDEINES der folgenden Themen betrifft:

  • CSS, SCSS, Tailwind oder irgendein Styling
  • HTML-Struktur/Vorlagen für UI
  • React/Vue/Svelte/Angular-Komponenten-Markup und Styling
  • Layout, responsives Design, Grid, Flexbox
  • Design-Tokens, Theme-Dateien, Farbschemata
  • UI-Komponentenerstellung (Buttons, Karten, Modals, Navbars usw.)
  • Animation, Übergänge, visuelle Effekte
  • Barrierefreiheit (a11y) bezogen auf visuelle Darstellung
  • Asset-Verwaltung (Icons, Bilder, Schriftarten)
  • Designsystem-Implementierung

Standard-Aufgaben (Weiterleitung an Task-Tool-Subagenten)

Alles andere:

  • Backend-Logik, API-Endpunkte, Datenbank
  • Geschäftslogik, Dienste, Hilfsprogramme
  • Konfiguration, Tooling, CI/CD
  • Tests (es sei denn, es handelt sich um visuelle/Snapshot-Tests)
  • Zustandsverwaltung, Datenabruf
  • Authentifizierung, Autorisierung

Im Zweifelsfall: Wenn eine Aufgabe beides mischt (z.B. "ein Formular mit Validierung erstellen"), leite sie als Design-Aufgabe weiter, da sie eine UI-Komponente hat.

Ablauf

Schritt 1: Anfrage parsen

Extrahiere aus der Benutzeranfrage:

  1. Plan-Datei: Der zu lesende Markdown-Plan
  2. Aufgaben-Teilmenge (optional): Spezifische Aufgaben-IDs, die ausgeführt werden sollen

Wenn keine Teilmenge angegeben ist, führe den vollständigen Plan aus.

Schritt 2: Plan lesen und parsen

  1. Finde Aufgaben-Unterabschnitte (z.B. ### T1: oder ### Aufgabe 1.1:)
  2. Extrahiere für jede Aufgabe:
    • Aufgaben-ID und Name
    • depends_on-Liste (aus - **depends_on**: [...])
    • Vollständiger Inhalt (Beschreibung, Ort, Abnahmekriterien, Validierung)
  3. Erstelle Aufgabenliste
  4. Klassifiziere jede Aufgabe als design oder standard basierend auf den obigen Regeln
  5. Wenn eine Aufgaben-Teilmenge angefordert wurde, filtere die Aufgabenliste auf diese IDs und deren erforderliche Abhängigkeiten.

Schritt 3: Aufgaben starten

Für jede nicht blockierte Aufgabe starte sie basierend auf ihrer Klassifizierung:

Für STANDARD-Aufgaben → Task-Tool-Subagenten verwenden

Starte mit:

  • description: "Implementiere Aufgabe [ID]: [Name]"
  • prompt: Verwende die Aufgaben-Prompt-Vorlage unten
  • subagent_type: "parallel"

Für DESIGN-Aufgaben → claude -p in Hintergrund-Shell verwenden

Erstelle denselben Prompt, den du einem Subagenten geben würdest, und starte dann über Bash:

claude -p "DEIN_PROMPT_HIER" \
  --allowedTools "Bash,Read,Edit,Write,Glob,Grep,WebFetch,WebSearch" \
  --max-turns 50 \
  --output-format text \
  > /tmp/co-design-[AUFGABEN-ID]-output.log 2>&1 &

KRITISCHE Regeln für den Start von Design-Aufgaben:

  1. Der Prompt-Inhalt muss IDENTISCH zu dem sein, den du einem Task-Tool-Subagenten geben würdest (verwende dieselbe Aufgaben-Prompt-Vorlage)
  2. Maskiere den Prompt korrekt für die Shell-Ausführung – verwende einen Heredoc-Ansatz:
    claude -p "$(cat <<'PROMPT_EOF'
    [vollständiger Prompt-Inhalt hier]
    PROMPT_EOF
    )" \
      --allowedTools "Bash,Read,Edit,Write,Glob,Grep,WebFetch,WebSearch" \
      --max-turns 50 \
      --output-format text \
      > /tmp/co-design-[AUFGABEN-ID]-output.log 2>&1 &
    
  3. Logge die Ausgabe nach /tmp/co-design-[AUFGABEN-ID]-output.log zur späteren Überprüfung
  4. Verfolge die Hintergrund-PID, um den Abschluss überprüfen zu können
  5. Starte ALLE nicht blockierten Design-Aufgaben parallel (mehrere Hintergrund-Shells)

Starte alle nicht blockierten Aufgaben (beide Typen) parallel. Eine Aufgabe ist nicht blockiert, wenn alle IDs in ihrer depends_on-Liste abgeschlossen sind.

Aufgaben-Prompt-Vorlage

Verwende diese für SOWOHL Standard-Subagenten ALS AUCH für Design-Modus-claude -p-Aufgaben:

Du implementierst eine spezifische Aufgabe aus einem Entwicklungsplan.

## Kontext
- Plan: [Dateiname]
- Ziele: [relevante Übersicht aus dem Plan]
- Abhängigkeiten: [Voraussetzungen für diese Aufgabe]
- Verwandte Aufgaben: [Aufgaben, die von dieser Aufgabe abhängen oder von ihr abhängig sind]
- Einschränkungen: [Risiken aus dem Plan]

## Deine Aufgabe
**Aufgabe [ID]: [Name]**

Ort: [Dateipfade]
Beschreibung: [Vollständige Beschreibung]

Abnahmekriterien:
[Liste aus dem Plan]

Validierung:
[Tests oder Überprüfung aus dem Plan]

## Anweisungen
1. Lies den Arbeitsplan und verstehe diese Aufgabe vollständig, bevor du codierst.
2. Lies zuerst alle relevanten Dateien, dann führe gezielte Codebasis-Recherche durch (zugehörige Module, Tests, Aufrufstellen und Abhängigkeiten), um den Ansatz zu bestätigen.
3. Standardmäßig zuerst die TDD-RED-Phase mit einem `tdd_test_writer`-Subagenten:
   - Übergib Aufgabenkontext und Abnahmekriterien.
   - Verlange reine Test-Änderungen.
   - Verlange Befehlsausgabe, die belegt, dass die neuen/aktualisierten Tests für die erwartete Verhaltenslücke fehlschlagen.
   - Wenn die Aufgabe kein guter TDD-Kandidat ist, dokumentiere explizit `reason_not_testable` und definiere alternative Überprüfungsnachweise (z.B. `manual_check`, `static_check` oder `runtime_check`) mit einem genauen Befehl oder konkreten Validierungsschritten.
4. Überprüfe die RED-Phasen-Tests (oder genehmigten nicht-testbaren Überprüfungsplan) als Implementierungsvertrag. Schwäche die Tests nicht und entferne sie nicht, es sei denn, die Anforderungen haben sich geändert.
5. Implementiere Produktionsänderungen für alle Abnahmekriterien.
6. Führe die Validierung durch:
   - Bei testbaren Aufgaben führe die exakten neuen/aktualisierten Testbefehle aus, bis sie GRÜN (bestanden) sind.
   - Bei nicht testbaren Aufgaben führe die vereinbarte alternative Überprüfung durch und erfasse die Nachweise.
   - Führe alle zusätzlichen Validierungsschritte aus dem Plan durch, wenn möglich.
7. Committe deine Arbeit.
   - Stage nur Dateien für diese Aufgabe, da andere Agenten parallel arbeiten.
   - NIE PUSHEN. NUR COMMITTEN.
8. Aktualisiere nach dem Commit den Aufgaben-Eintrag in der `*-plan.md` mit:
   - Abschlussstatus
   - Prägnantem Arbeitsprotokoll
   - Geänderten/erstellten Dateien
   - Fehlern oder Fallstricken, die aufgetreten sind
9. Gib eine Zusammenfassung zurück von:
   - Geänderten/erstellten Dateien
   - Vorgenommenen Änderungen
   - Wie die Kriterien erfüllt sind
   - Überprüfungsnachweise: RED -> GRÜN oder dokumentierte nicht-testbare Alternative
   - Durchgeführter oder zurückgestellter Validierung

## Wichtig
- Sei vorsichtig mit Pfaden
- Halte an und beschreibe Hindernisse, wenn sie auftreten
- Konzentriere dich auf diese spezifische Aufgabe

Stelle sicher, dass jede Aufgabe erst dann als abgeschlossen gilt, wenn entweder ein RED->GRÜN-Testnachweis oder ein expliziter nicht-testbarer Überprüfungsnachweis erbracht wurde, dann die Aufgabe committet und der Plan aktualisiert ist.

Schritt 4: Überwachen & Ergebnisse sammeln

Bei Standard-Aufgaben (Task-Tool): Ergebnisse kommen direkt vom Subagenten zurück.

Bei Design-Aufgaben (claude -p):

  1. Überprüfe, ob Hintergrundprozesse noch laufen: ps -p [PID]
  2. Wenn abgeschlossen, lies das Ausgabelog: Lese /tmp/co-design-[AUFGABEN-ID]-output.log
  3. Verifiziere, dass der Design-Agent seine Arbeit abgeschlossen hat, indem du überprüfst:
    • Dateien wurden wie erwartet erstellt/geändert
    • Plan-Datei wurde mit Aufgabenstatus aktualisiert
    • Arbeit wurde committet

Warte, bis ALLE Aufgaben in der aktuellen Welle abgeschlossen sind, bevor du fortfährst.

Schritt 5: Überprüfen und Validieren

Nachdem alle Aufgaben in einer Welle abgeschlossen sind:

  1. Überprüfe ihre Ausgaben auf Korrektheit und Vollständigkeit.
  2. Validiere die Ergebnisse gegen die erwarteten Ergebnisse.
  3. Wenn die Aufgabe wirklich korrekt abgeschlossen wurde, stelle sicher, dass der Aufgaben-Commit existiert, und markiere dann die Aufgabe als abgeschlossen mit Protokollen.
  4. Wenn eine Aufgabe nicht erfolgreich war, lass den Agenten sie wiederholen oder eskaliere das Problem.
  5. Stelle sicher, dass die Welle der Arbeit lokal committet wurde, bevor du zur nächsten Welle von Aufgaben übergehst.

Schritt 6: Wiederholen

  1. Überprüfe den Plan erneut, um zu sehen, welche neue Menge nicht blockierter Aufgaben verfügbar ist.
  2. Fahre fort, nicht blockierte Aufgaben parallel zu starten, bis der Plan abgeschlossen ist.
  3. Wiederhole den Vorgang, bis alle Aufgaben abgeschlossen, validiert (RED -> GRÜN oder dokumentierte nicht-testbare Überprüfung), committet und fehlerfrei protokolliert sind.

Überwachung von Design-Agenten

Während du auf den Abschluss der Design-Agenten wartest, kannst du:

# Überprüfen, ob der Agent noch läuft
ps -p [PID] > /dev/null 2>&1 && echo "Läuft" || echo "Fertig"

# Das Ausgabelog für Fortschritt anzeigen (tail)
tail -20 /tmp/co-design-[AUFGABEN-ID]-output.log

# Alle laufenden Design-Agenten überprüfen
ps aux | grep "claude -p" | grep -v grep

Fehlerbehandlung

  • Aufgaben-Teilmenge nicht gefunden: Liste der verfügbaren Aufgaben-IDs anzeigen
  • Parse-Fehler: Zeige, was versucht wurde, bitte um Klärung
  • Design-Agent-Absturz: Lies das Ausgabelog, wiederhole die Aufgabe
  • Design-Agent-Timeout: Überprüfe das Log auf Hindernisse, wiederhole oder eskaliere

Beispielverwendung

'Implementiere den Plan mit der Co-Design-Fertigkeit'
/co-design plan.md
/co-design ./plans/dashboard-plan.md T1 T2 T4
/co-design landing-page-plan.md --tasks T3 T7

Ausführungszusammenfassungs-Vorlage

# Ausführungszusammenfassung

## Zugewiesene Aufgaben: [N]
- Design-Aufgaben (claude -p): [Anzahl]
- Standard-Aufgaben (Subagent): [Anzahl]

### Abgeschlossen
- Aufgabe [ID]: [Name] - [Kurzzusammenfassung] [🎨 design | ⚙️ standard]

### Probleme
- Aufgabe [ID]: [Name]
  - Problem: [Was schiefgelaufen ist]
  - Lösung: [Wie gelöst oder was benötigt wird]

### Blockiert
- Aufgabe [ID]: [Name]
  - Blockierer: [Was den Abschluss verhindert]
  - Nächste Schritte: [Was passieren muss]

## Gesamtstatus
[Zusammenfassung des Abschlusses]

## Geänderte Dateien
[Liste der geänderten Dateien]

## Nächste Schritte
[Empfehlungen]

Verwandte Skills