subagent-driven-development
Execute implementation plans by dispatching a fresh subagent per task with two-stage review (spec compliance then code quality). Use when you have an implementation plan with mostly independent tasks and want high-quality, fast iteration within a single session.
How do I install this agent skill?
npx skills add https://skills.volces.com --skill subagent-driven-developmentIs this agent skill safe to install?
- Socketpass
No alerts
What does this agent skill do?
Subagent-Driven Development
Execute a plan by dispatching a fresh subagent per task, with two-stage review after each — spec compliance first, then code quality.
Core principle: Fresh subagent per task + two-stage review = no context pollution, high quality, fast iteration.
Installation
OpenClaw / Moltbot / Clawbot
npx clawhub@latest install subagent-driven-development
When to Use This Skill
- You have an implementation plan with discrete, mostly independent tasks
- You want to execute the plan within a single session (no human-in-the-loop between tasks)
- Tasks can be implemented and reviewed sequentially without tight coupling
| Condition | This Skill | Alternative |
|---|---|---|
| Have a plan, same session | Yes | — |
| Have a plan, parallel session | No | executing-plans |
| No plan yet | No | Write a plan first |
| Tasks tightly coupled | No | Manual execution or decompose more |
The Process
┌─────────────────────────────────────────────────────┐
│ 1. Read plan, extract ALL tasks with full text │
│ 2. Note shared context (arch, deps, conventions) │
│ 3. Create TodoWrite with all tasks │
└──────────────────────┬──────────────────────────────┘
▼
┌────── Per Task ──────┐
│ │
│ Dispatch Implementer (references/implementer-prompt.md)
│ │ │
│ ▼ │
│ Questions?──yes──► Answer, re-dispatch│
│ │no │
│ ▼ │
│ Implement + test + commit + self-review│
│ │ │
│ ▼ │
│ Dispatch Spec Reviewer (references/spec-reviewer-prompt.md)
│ │ │
│ ▼ │
│ Compliant?──no──► Implementer fixes──┘
│ │yes then re-review
│ ▼
│ Dispatch Code Reviewer (references/code-quality-reviewer-prompt.md)
│ │
│ ▼
│ Approved?──no──► Implementer fixes, re-review
│ │yes
│ ▼
│ Mark task complete
└───────┬──────────────┘
▼
More tasks? ──yes──► next task
│no
▼
Final cross-task code review
▼
Finish development branch
Prompt Templates
Three reference prompts are provided for the subagent roles:
| Role | File | Purpose |
|---|---|---|
| Implementer | references/implementer-prompt.md | Implement, test, commit, self-review |
| Spec reviewer | references/spec-reviewer-prompt.md | Verify code matches spec exactly |
| Code reviewer | references/code-quality-reviewer-prompt.md | Verify code is clean and maintainable |
Example Workflow
Controller: Reading plan — 5 tasks extracted, TodoWrite created.
─── Task 1: Hook installation script ───
[Dispatch implementer with full task text + context]
Implementer: "Should the hook be installed at user or system level?"
Controller: "User level (~/.config/hooks/)"
Implementer: ✅ Implemented install-hook command
- Added tests (5/5 passing)
- Self-review: missed --force flag, added it
- Committed
[Dispatch spec reviewer]
Spec reviewer: ✅ Spec compliant — all requirements met
[Dispatch code reviewer with git SHAs]
Code reviewer: ✅ Approved — clean, good coverage
[Mark Task 1 complete]
─── Task 2: Recovery modes ───
[Dispatch implementer]
Implementer: ✅ Added verify/repair modes (8/8 tests passing)
[Dispatch spec reviewer]
Spec reviewer: ❌ Issues:
- Missing: progress reporting ("report every 100 items")
- Extra: added --json flag (not in spec)
[Implementer fixes: remove --json, add progress reporting]
Spec reviewer: ✅ Spec compliant
[Dispatch code reviewer]
Code reviewer: Important — magic number 100, extract constant
[Implementer fixes: extract PROGRESS_INTERVAL]
Code reviewer: ✅ Approved
[Mark Task 2 complete]
... (tasks 3-5) ...
[Final cross-task code review]
Final reviewer: ✅ All requirements met, ready to merge
Controller Responsibilities
The controller (you) orchestrates the flow. Key duties:
| Responsibility | Detail |
|---|---|
| Extract tasks upfront | Read plan once, extract all task text — subagents never read the plan file |
| Provide full context | Give each subagent the complete task text + architectural context |
| Answer questions | Respond clearly and completely before letting subagent proceed |
| Enforce review order | Spec compliance first, code quality second — never reversed |
| Track progress | Update TodoWrite after each task completes |
| Dispatch sequentially | One implementation subagent at a time to avoid conflicts |
Quality Gates
Each task passes through three quality checks:
| Gate | Who | What |
|---|---|---|
| Self-review | Implementer | Completeness, naming, YAGNI, test quality |
| Spec review | Spec reviewer | Matches requirements exactly — nothing more, less |
| Code review | Code reviewer | Clean code, maintainability, test coverage |
Advantages
vs. manual execution:
- Fresh context per task (no confusion from accumulated state)
- Subagents follow TDD naturally
- Questions surfaced before work begins, not after
vs. parallel-session plans:
- No handoff overhead
- Continuous progress
- Review checkpoints are automatic
Cost trade-off: More subagent invocations (implementer + 2 reviewers per task), but catches issues early — cheaper than debugging later.
NEVER Do
- Skip either review — both spec compliance and code quality are mandatory
- Start code review before spec review passes — wrong order wastes effort on code that doesn't meet spec
- Dispatch multiple implementers in parallel — causes merge conflicts and context corruption
- Make subagents read the plan file — provide full task text directly
- Skip scene-setting context — subagent needs to understand where the task fits architecturally
- Ignore subagent questions — answer fully before they proceed
- Accept "close enough" on spec compliance — if the reviewer found issues, it's not done
- Skip re-review after fixes — reviewer found issues → implementer fixes → reviewer reviews again
- Let self-review replace actual review — self-review is a first pass, not a substitute
- Move to next task with open review issues — current task must be fully approved first
- Fix issues manually instead of through a subagent — manual fixes pollute controller context
Handling Failures
| Situation | Response |
|---|---|
| Subagent asks questions | Answer clearly, provide additional context if needed |
| Reviewer finds issues | Same implementer subagent fixes, reviewer re-reviews |
| Subagent fails task entirely | Dispatch a new fix subagent with specific instructions |
| Task blocked by dependency | Reorder remaining tasks or resolve dependency first |
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/skills.volces.com/subagent-driven-development">View subagent-driven-development on skillZs</a>