subagent-driven-development

name	subagent-driven-development
description	Orchestrating sub-agents through TDD phases for complex features
methodology	tdd

Sub-Agent Driven Development Skill

Coordinate a team of specialized sub-agents through the full TDD lifecycle for a complex feature. This skill is used by the TDD Orchestrator.

Overview

Sub-agent driven development applies TDD at the team level. Rather than one agent doing all phases, each phase is handled by a specialist:

Feature Request
  → Brainstormer: scenarios and edge cases
  → Planner: ordered test plan + implementation dependencies
  → Implementer: red-green-refactor cycles
  → Reviewer: two-stage code review
  → Debugger: (if tests fail after implementation)

Orchestration Steps

1. Receive and clarify the feature request

Before delegating, gather:

• Clear success criteria
• Acceptance tests (user-visible behavior)
• Non-functional requirements (performance, security)
• Constraints (deadline, API compatibility)

If any are missing, ask before starting delegation.

2. Delegate to Brainstormer

Provide: the feature description + success criteria. Expect back: numbered list of test scenarios grouped by category. Validate: covers happy paths, edge cases, and error scenarios.

3. Delegate to Planner

Provide: the brainstorming output + feature description. Expect back: ordered test plan + implementation dependencies. Validate: tests are ordered simple → complex, dependencies listed.

4. Delegate to Implementer

Provide: the full test plan. Expect back: passing test suite + minimal implementation. Validate: all tests pass, no skipped tests, no TODO comments.

5. Delegate to Reviewer

Provide: the diff (all changed files). Expect back: Critical/Warning/Suggestion review findings. Validate: no Critical findings before accepting. Address Warnings.

6. Handle failures via Debugger

If Implementer reports failing tests, delegate to Debugger. Provide: exact failure output + relevant code. Expect back: root cause analysis + fix. Then re-delegate to Implementer or apply fix directly.

Sub-Agent Isolation Rules

• Each sub-agent starts with a fresh context
• Pass ONLY what the sub-agent needs — no irrelevant history
• Summarize results after each phase (do not carry full sub-agent output)
• If a sub-agent exceeds its scope, correct and redirect

Phase Gate Criteria

Phase	Gate Before Next Phase
Brainstorming	≥ 3 happy paths, ≥ 3 edge cases, ≥ 2 error scenarios
Planning	All scenarios have test names, implementation deps listed
Implementation	All tests pass, no skipped tests
Review	No Critical findings

Output Format

After completing all phases, produce a summary:

## Feature Complete: <feature name>

### Phases Completed
- Brainstorming: <N> scenarios generated
- Planning: <N> tests planned, <N> implementation deps
- Implementation: <N> tests written, all passing
- Review: <N> warnings addressed, no criticals

### Files Changed
- <list of modified/created files>

### Test Coverage
- <test file>: <N> tests