subagent-driven-development-2（子 Agent 驱动开发 2）

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

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:

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:

Quality Gates

Each task passes through three quality checks:

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