221 lines
7.5 KiB
Markdown
221 lines
7.5 KiB
Markdown
---
|
|
description: Execute tasks in parallel waves with optimal agent selection and review
|
|
argument-hint: <task list or "from todo">
|
|
allowed-tools: Task, Read, Write, Edit, Glob, Grep, Bash, TodoWrite
|
|
---
|
|
|
|
Execute these tasks in parallel waves with proper review: $ARGUMENTS
|
|
|
|
## Instructions
|
|
|
|
Load the `orchestrated-execution` skill, then:
|
|
|
|
### Philosophy: Do It Right
|
|
|
|
**Take your time. No shortcuts.** Every implementation should be:
|
|
|
|
- **Clean** - Readable, well-named, minimal complexity
|
|
- **Maintainable** - Future developers can understand and modify it
|
|
- **Extensible** - Easy to add features without rewriting
|
|
- **Refactored** - If existing code is messy, clean it up as you go
|
|
|
|
When you encounter code that could be better:
|
|
- Refactor it. Don't work around bad patterns.
|
|
- Extract helpers, rename unclear variables, simplify nesting
|
|
- Leave the codebase better than you found it
|
|
|
|
**Prefer proper solutions over quick fixes.** A 50-line clean implementation beats a 10-line hack.
|
|
|
|
### Phase 1: Parse & Analyze
|
|
|
|
1. **Parse tasks** - From todo list or provided
|
|
2. **Analyze dependencies** - Which tasks depend on which
|
|
3. **Group into waves** - Tasks without mutual dependencies go in same wave
|
|
|
|
### Phase 2: Wave Planning
|
|
|
|
For each wave, determine:
|
|
|
|
```markdown
|
|
## Wave [N]
|
|
|
|
| Task | Implementer | Why | Reviewer | Why |
|
|
|------|-------------|-----|----------|-----|
|
|
| [Name] | [Agent] | [domain match] | [Agent] | [risk match] |
|
|
|
|
**Parallelizable because:** [No dependencies between these tasks]
|
|
**Blocked until:** [Wave N-1 complete] or [Nothing]
|
|
```
|
|
|
|
Present the wave plan to user before executing.
|
|
|
|
### Phase 3: Execute Each Wave
|
|
|
|
```
|
|
Wave N:
|
|
┌─────────────────────────────────────────────┐
|
|
│ 1. LAUNCH ALL IMPLEMENTERS (parallel) │
|
|
│ │
|
|
│ Task(agent1, task1) ──┐ │
|
|
│ Task(agent2, task2) ──┼── concurrent │
|
|
│ Task(agent3, task3) ──┘ │
|
|
└─────────────────────────────────────────────┘
|
|
│
|
|
▼
|
|
┌─────────────────────────────────────────────┐
|
|
│ 2. COLLECT RESULTS │
|
|
│ Wait for all to complete │
|
|
│ Gather implementation outputs │
|
|
└─────────────────────────────────────────────┘
|
|
│
|
|
▼
|
|
┌─────────────────────────────────────────────┐
|
|
│ 3. LAUNCH ALL REVIEWERS (parallel) │
|
|
│ │
|
|
│ Task(reviewer1, review1) ──┐ │
|
|
│ Task(reviewer2, review2) ──┼── concurrent│
|
|
│ Task(reviewer3, review3) ──┘ │
|
|
└─────────────────────────────────────────────┘
|
|
│
|
|
▼
|
|
┌─────────────────────────────────────────────┐
|
|
│ 4. PROCESS REVIEW RESULTS │
|
|
│ │
|
|
│ PASS → mark complete │
|
|
│ NEEDS_FIX → fix loop (can parallelize) │
|
|
│ BLOCK → escalate immediately │
|
|
└─────────────────────────────────────────────┘
|
|
│
|
|
▼
|
|
┌─────────────────────────────────────────────┐
|
|
│ 5. VERIFY WAVE COMPLETE │
|
|
│ All tasks in wave done? │
|
|
│ Any conflicts from parallel execution? │
|
|
└─────────────────────────────────────────────┘
|
|
│
|
|
▼
|
|
Continue to Wave N+1
|
|
```
|
|
|
|
### Phase 4: Loose Ends (Critical for Parallel)
|
|
|
|
After all waves, explicitly check:
|
|
|
|
1. **File conflicts** - Did parallel tasks modify same files?
|
|
2. **Integration gaps** - Do the pieces work together?
|
|
3. **Merge issues** - Any conflicting changes to resolve?
|
|
4. **Cross-cutting** - Consistent patterns across all tasks?
|
|
5. **Quality gate** - Full build, test, lint
|
|
|
|
### Phase 5: Final Report
|
|
|
|
```markdown
|
|
## Parallel Execution Complete
|
|
|
|
### Wave Summary
|
|
| Wave | Tasks | Parallel Time | Status |
|
|
|------|-------|---------------|--------|
|
|
| 1 | 3 | ~2min | ✓ |
|
|
| 2 | 2 | ~1min | ✓ |
|
|
| 3 | 1 | ~1min | ✓ |
|
|
|
|
### Task Details
|
|
| Task | Wave | Implementer | Reviewer | Issues Fixed | Status |
|
|
|------|------|-------------|----------|--------------|--------|
|
|
|
|
### Loose Ends Resolved
|
|
- [Conflicts fixed]
|
|
- [Integration issues addressed]
|
|
|
|
### Quality Gate
|
|
- Build: PASS
|
|
- Tests: PASS
|
|
- Lint: PASS
|
|
```
|
|
|
|
## Dependency Detection
|
|
|
|
Tasks depend on each other when:
|
|
|
|
```
|
|
Task A: "Create User model"
|
|
Task B: "Add validation to User model" ← Depends on A
|
|
|
|
Task A: "Implement auth backend"
|
|
Task B: "Write auth tests" ← Depends on A
|
|
|
|
Task A: "Update config schema"
|
|
Task B: "Migrate existing configs" ← Depends on A
|
|
```
|
|
|
|
Tasks are independent when:
|
|
|
|
```
|
|
Task A: "Add logging to ingestion"
|
|
Task B: "Add metrics to query" ← Different modules, independent
|
|
|
|
Task A: "Write User docs"
|
|
Task B: "Write Config docs" ← Different files, independent
|
|
```
|
|
|
|
## Agent Selection
|
|
|
|
### Implementers
|
|
| Task Type | Agent |
|
|
|-----------|-------|
|
|
| Go code, features | `go-specialist` |
|
|
| Tests | `testing-strategist` |
|
|
| API design | `api-designer` |
|
|
| Database | `database-architect` |
|
|
| K8s, deployment | `worker-specialist` |
|
|
| Security, auth | `security-architect` |
|
|
| Architecture | `hexagonal-architect` |
|
|
| Docs | `librarian` |
|
|
|
|
### Reviewers
|
|
| Risk Type | Reviewer |
|
|
|-----------|----------|
|
|
| Code quality | `quality-engineer` |
|
|
| Security | `security-architect` |
|
|
| Architecture | `hexagonal-architect` |
|
|
| Test coverage | `testing-strategist` |
|
|
|
|
## Wave Progress Format
|
|
|
|
```markdown
|
|
## Wave 2 Progress
|
|
|
|
### Implementing (parallel)
|
|
→ Task 4: auth-backend - go-specialist
|
|
→ Task 5: rate-limiter - security-architect
|
|
→ Task 6: metrics - go-specialist
|
|
|
|
### Wave 1 Complete
|
|
✓ Task 1: user-model - go-specialist ✓ quality-engineer
|
|
✓ Task 2: config-schema - go-specialist ✓ quality-engineer
|
|
✓ Task 3: docs-update - librarian ✓ librarian
|
|
```
|
|
|
|
## Critical Rules
|
|
|
|
- NEVER put dependent tasks in same wave
|
|
- ALWAYS review even in parallel mode
|
|
- ALWAYS check for conflicts after parallel execution
|
|
- ALWAYS run quality gate at the end
|
|
- ANNOUNCE wave plan before executing
|
|
- MAX 3 fix cycles per task, then escalate
|
|
|
|
## Step Back: Before Each Wave
|
|
|
|
1. **Dependencies verified?** Wave N-1 complete?
|
|
2. **No conflicts anticipated?** Parallel tasks won't clash?
|
|
3. **Right agents selected?** Re-check before launching
|
|
4. **Rollback plan?** If wave fails, how do we recover?
|
|
|
|
## Step Back: After Each Wave
|
|
|
|
1. **All tasks actually complete?** Not just "launched"
|
|
2. **Reviews actually done?** Not skipped for speed
|
|
3. **Issues actually fixed?** Not deferred
|
|
4. **No file conflicts?** From parallel writes
|