| name | developer |
| description | Orchestrates coder agents to execute phase tasks. Analyzes progress.json to determine parallel execution. Usage: /developer [phase] - if no phase specified, asks user. Spawns multiple agents for independent tasks. Triggers on: develop, developer, start phase, execute phase, build phase. |
Developer Skill
Orchestrate coder agents to execute tasks for a specific phase. Analyzes task dependencies to spawn agents in parallel when possible.
CRITICAL: You Must Spawn Agents
This skill REQUIRES spawning coder agents using the Task tool.
Task tool call:
subagent_type: "developer"
description: "Execute task X.X"
prompt: "Execute task X.X from docs/progress.json..."
For parallel execution, send MULTIPLE Task tool calls in ONE message.
Usage
/developer 1 → Develop Phase 1
/developer 2 → Develop Phase 2
/developer → Ask which phase to develop
Workflow
/developer [phase?]
│
▼
┌──────────────────────────────────────────────────────────────┐
│ 1. VALIDATE: Check docs/progress.json exists │
└──────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────┐
│ 2. PHASE: Get phase from args OR ask user │
└──────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────┐
│ 3. ANALYZE: Read phase tasks, find parallelizable groups │
└──────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────┐
│ 4. SPAWN: Launch coder agents (parallel if possible) │
│ │
│ Independent tasks? → Spawn multiple agents │
│ Sequential tasks? → Spawn one agent │
└──────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────┐
│ 5. REPORT: Summary of completed tasks │
└──────────────────────────────────────────────────────────────┘
Step 1: Validate Plans
Check required files exist:
Glob: docs/progress.json
Glob: docs/dev-plan.md
If missing:
Report: "No plans found. Run /plan-project first."
STOP
Step 2: Get Phase
If phase provided in args:
User: /developer 1
→ phase = 1
→ Proceed to Step 3
If NO phase provided:
User: /developer
Read: docs/progress.json
→ Extract available phases
→ Show progress per phase
→ Ask user which phase
Ask Question:
AskUserQuestion:
question: "Which phase do you want to develop?"
header: "Phase"
options:
- label: "Phase 0: Foundation (X/Y done)"
description: "Setup, config, design tokens"
- label: "Phase 1: Backend Core (X/Y done)"
description: "Schema, migrations, RLS"
- label: "Phase 2: UI Components (X/Y done)"
description: "Shared components, layouts"
- label: "Phase 3: Features (X/Y done)"
description: "Feature implementations"
Step 3: Analyze Phase Tasks
Read progress.json and extract phase tasks:
Read: docs/progress.json
Find phase by ID (e.g., "phase-1")
Extract all tasks with passed: false
Analyze dependencies (blockedBy)
Dependency Analysis
Build task groups for parallel execution:
Group 1: Tasks with NO dependencies (can run parallel)
Group 2: Tasks depending on Group 1 (run after Group 1)
Group 3: Tasks depending on Group 2 (run after Group 2)
...
Example:
Phase 1 Tasks:
- 1.1: Setup Supabase (no deps) → Group 1
- 1.2: Create users table (deps: 1.1) → Group 2
- 1.3: Create posts table (deps: 1.1) → Group 2
- 1.4: Create RLS policies (deps: 1.2, 1.3) → Group 3
Execution:
Wave 1: [1.1] - 1 agent
Wave 2: [1.2, 1.3] - 2 agents parallel
Wave 3: [1.4] - 1 agent
Step 4: Spawn Developer Agents
Parallel Spawning Rules
| Scenario | Agents to Spawn |
|---|
| 1 independent task | 1 agent |
| 2 independent tasks | 2 agents parallel |
| 3+ independent tasks | 3 agents parallel (max) |
| All sequential | 1 agent for all tasks |
CRITICAL: Use Task Tool to Spawn Agents
You MUST use the Task tool with subagent_type="developer" to spawn agents.
Wave 1: Single Task Example
[Task Tool Call]
subagent_type: coder
description: "Execute task 1.1"
prompt: "Execute task 1.1 from docs/progress.json. Update passed: true when done."
Wave 2: Two Tasks Parallel Example
[Single message with 2 Task tool calls - PARALLEL]
[Task Tool Call 1]
subagent_type: coder
description: "Execute task 1.2"
prompt: "Execute task 1.2 from docs/progress.json. Update passed: true when done."
[Task Tool Call 2]
subagent_type: coder
description: "Execute task 1.3"
prompt: "Execute task 1.3 from docs/progress.json. Update passed: true when done."
Wave 3: Three Tasks Parallel Example
[Single message with 3 Task tool calls - PARALLEL]
[Task Tool Call 1]
subagent_type: coder
description: "Execute task 2.1"
prompt: "Execute task 2.1 from docs/progress.json. Update passed: true when done."
[Task Tool Call 2]
subagent_type: coder
description: "Execute task 2.2"
prompt: "Execute task 2.2 from docs/progress.json. Update passed: true when done."
[Task Tool Call 3]
subagent_type: coder
description: "Execute tasks 2.3, 2.4"
prompt: "Execute tasks 2.3, 2.4 from docs/progress.json. Update each to passed: true when done."
Sequential Tasks (One Agent)
[Task Tool Call]
subagent_type: coder
description: "Execute phase 1 tasks"
prompt: "Execute these tasks in order: 1.1, 1.2, 1.3, 1.4 from docs/progress.json. Update each to passed: true when done."
Step 5: Report Completion
## Phase {X} Development Complete
### Execution Summary
- **Wave 1:** 1 agent → Task 1.1 ✓
- **Wave 2:** 2 agents → Tasks 1.2, 1.3 ✓
- **Wave 3:** 1 agent → Task 1.4 ✓
### Tasks Completed
| ID | Name | Status |
|----|------|--------|
| 1.1 | Setup Supabase | ✓ passed |
| 1.2 | Create users table | ✓ passed |
| 1.3 | Create posts table | ✓ passed |
| 1.4 | Create RLS policies | ✓ passed |
### Progress Update
- **Phase 1:** 4/4 complete (100%)
- **Overall:** 8/20 complete (40%)
### Next Steps
Run `/developer 2` to develop Phase 2
Parallel Execution Examples
Example 1: All Independent Tasks
Phase 0 Tasks:
- 0.1: Setup project (no deps)
- 0.2: Install dependencies (no deps)
- 0.3: Configure ESLint (no deps)
Analysis: All independent → Spawn 3 agents parallel
[Task Call 1: developer] → Task 0.1
[Task Call 2: developer] → Task 0.2
[Task Call 3: developer] → Task 0.3
Example 2: Mixed Dependencies
Phase 2 Tasks:
- 2.1: Design tokens (no deps)
- 2.2: Button component (deps: 2.1)
- 2.3: Card component (deps: 2.1)
- 2.4: Form component (deps: 2.2)
Analysis:
Wave 1: [2.1] → 1 agent
Wave 2: [2.2, 2.3] → 2 agents parallel
Wave 3: [2.4] → 1 agent
Example 3: Fully Sequential
Phase 1 Tasks:
- 1.1: Create migration (no deps)
- 1.2: Run migration (deps: 1.1)
- 1.3: Create RLS (deps: 1.2)
- 1.4: Test queries (deps: 1.3)
Analysis: All sequential → 1 agent per wave (or 1 agent for all)
Option A: 4 waves, 1 agent each
Option B: 1 agent handles all sequentially
Prefer Option B for fewer spawns
The Job: How to Execute This Skill
FOLLOW THESE STEPS EXACTLY:
Step A: Validate & Get Phase
1. Read docs/progress.json
2. If no phase arg → AskUserQuestion for phase
3. Extract pending tasks for that phase
Step B: Analyze Dependencies
1. Group tasks by dependencies
2. Wave 1 = no dependencies
3. Wave 2 = depends on Wave 1
4. etc.
Step C: Spawn Agents (THE CRITICAL PART)
FOR EACH WAVE, USE TASK TOOL TO SPAWN DEVELOPER AGENTS:
Wave with 1 task:
→ 1 Task tool call with subagent_type="developer"
Wave with 2 tasks:
→ 2 Task tool calls in SAME message (parallel)
Wave with 3+ tasks:
→ 3 Task tool calls in SAME message (parallel)
EXAMPLE - Wave with 2 parallel tasks:
You MUST send this as a single message with multiple tool calls:
<example_spawn>
I'll spawn 2 coder agents in parallel for Wave 2:
[Task Tool Call 1]
subagent_type: coder
description: "Execute task 1.2"
prompt: "Execute task 1.2 from docs/progress.json. Update passed: true when done."
[Task Tool Call 2]
subagent_type: coder
description: "Execute task 1.3"
prompt: "Execute task 1.3 from docs/progress.json. Update passed: true when done."
</example_spawn>
Step D: Wait & Continue
1. Wait for all agents in current wave
2. Proceed to next wave
3. Repeat Step C for next wave
Step E: Report
1. Show completed tasks
2. Show progress percentage
3. Suggest next phase
Agent Prompts
Single Task Prompt
coder agent:
"Phase {phase}: Execute task {id} - {name}.
Read docs/progress.json for details.
Follow docs/{source} for implementation.
Update progress.json when done."
Multiple Tasks Prompt (Sequential)
coder agent:
"Phase {phase}: Execute these tasks in order:
- {id1}: {name1}
- {id2}: {name2}
- {id3}: {name3}
Read docs/progress.json for details.
Update each task to passed: true when complete."
Error Handling
No Pending Tasks
All tasks in Phase X are already passed: true.
→ Report: "Phase X already complete. Run /developer Y for next phase."
Dependencies Not Met
Task depends on tasks from previous phase that aren't done.
→ Report: "Phase X has unmet dependencies. Complete Phase Y first."
→ Suggest: "Run /developer Y"
Agent Fails
Developer agent reports failure.
→ Report which task failed
→ Keep task as passed: false
→ Ask user how to proceed
Rules
-
Always ask if no phase specified
- Show phase progress in question
- Let user choose
-
Analyze before spawning
- Read progress.json
- Build dependency waves
- Optimize for parallelism
-
Max 3 parallel agents
- More than 3 adds overhead
- Group remaining tasks
-
Wave-based execution
- Complete one wave before next
- Respect dependencies
-
Minimal prompts
- Only pass task IDs
- Agent reads files itself
-
Report progress
- Show what completed
- Update overall progress
- Suggest next phase
Quick Reference
/developer → Ask which phase
/developer 0 → Phase 0: Foundation
/developer 1 → Phase 1: Backend Core
/developer 2 → Phase 2: UI Components
/developer 3 → Phase 3: Features
/developer 4 → Phase 4: Integration
/developer 5 → Phase 5: Polish
Checklist
