Subagent-Driven Development
Execute plan by dispatching fresh subagent per task, with two-stage review after each: spec compliance review first, then code quality review.
Core principle: Fresh subagent per task + two-stage review (spec then quality) = high quality, fast iteration
When to Use
Use when:
- Have implementation plan
- Tasks are mostly independent
- Want to stay in current session
- Want fast iteration with review checkpoints
vs. Executing Plans (parallel session):
- Same session (no context switch)
- Fresh subagent per task (no context pollution)
- Two-stage review after each task: spec compliance first, then code quality
- Faster iteration (no human-in-loop between tasks)
The Process
Setup
- Read plan, extract all tasks with full text and context
- Create TodoWrite with all tasks
Per Task
- Dispatch implementer subagent with full task text + context
- If subagent asks questions - Answer, provide context
- Implementer implements, tests, commits, self-reviews
- Dispatch spec reviewer subagent - Verify code matches spec
- If spec issues - Implementer fixes, reviewer re-reviews
- Dispatch code quality reviewer subagent - Review for quality
- If quality issues - Implementer fixes, reviewer re-reviews
- Mark task complete in TodoWrite
After All Tasks
- Dispatch final code reviewer for entire implementation
- Use ltk:finishing-a-development-branch to complete
Two-Stage Review
Stage 1: Spec Compliance
- Does implementation match spec EXACTLY?
- Nothing missing?
- Nothing extra (over-building)?
Stage 2: Code Quality (only after spec passes)
- Clean code?
- Good test coverage?
- Maintainable?
Advantages
vs. Manual execution:
- Subagents follow TDD naturally
- Fresh context per task (no confusion)
- Parallel-safe (subagents don't interfere)
- Subagent can ask questions (before AND during work)
Quality gates:
- Self-review catches issues before handoff
- Two-stage review: spec compliance, then code quality
- Review loops ensure fixes actually work
Red Flags
Never:
- Skip reviews (spec compliance OR code quality)
- Proceed with unfixed issues
- Dispatch multiple implementation subagents in parallel (conflicts)
- Make subagent read plan file (provide full text instead)
- Skip scene-setting context
- Ignore subagent questions
- Accept "close enough" on spec compliance
- Skip review loops
- Start code quality review before spec compliance passes
- Move to next task while either review has open issues
If subagent asks questions:
- Answer clearly and completely
- Provide additional context if needed
- Don't rush them into implementation
If reviewer finds issues:
- Implementer (same subagent) fixes them
- Reviewer reviews again
- Repeat until approved
Integration
Required workflow skills:
- ltk:writing-plans - Creates the plan this skill executes
- ltk:requesting-code-review - Code review template for reviewer subagents
- ltk:finishing-a-development-branch - Complete development after all tasks
Subagents should use:
- ltk:test-driven-development - Subagents follow TDD for each task
Alternative workflow:
- ltk:executing-plans - Use for parallel session instead of same-session execution