subagent-driven-development
Autonomous plan execution - fresh subagent per task with automated code reviewbetween tasks. No human-in-loop, high throughput with quality gates.
When & Why to Use This Skill
The Subagent-Driven Development skill enables autonomous, high-throughput software engineering by orchestrating specialized subagents for individual tasks. It eliminates context pollution by using fresh subagents for every task and ensures production-grade quality through a parallel triple-reviewer system (Code, Business Logic, and Security). By integrating Test-Driven Development (TDD) and automated quality gates, it allows for continuous progress on complex coding plans without requiring constant human intervention.
Use Cases
- Autonomous Feature Implementation: Execute multi-step development plans where each task is handled by a fresh subagent to maintain high code quality and prevent context drift.
- Automated Quality Gates: Perform simultaneous security, logic, and code reviews on every task, automatically dispatching fix-agents for any critical or high-severity issues identified.
- Scalable Codebase Refactoring: Systematically update or refactor large projects by breaking the work into independent modules that are implemented, tested, and verified autonomously.
- Continuous Development Workflows: Maintain high development velocity in a single session by automating the transition from plan creation to task execution and final verification.
| name | ring:subagent-driven-development |
|---|---|
| description | | |
| trigger | | |
| skip_when | | |
| - Need human review between tasks → use ring | executing-plans |
| after | [ring:writing-plans, ring:pre-dev-task-breakdown] |
| similar | [ring:executing-plans] |
Subagent-Driven Development
Execute plan by dispatching fresh subagent per task, with code review after each.
Core principle: Fresh subagent per task + review between tasks = high quality, fast iteration
Overview
vs. Executing Plans (parallel session):
- Same session (no context switch)
- Fresh subagent per task (no context pollution)
- Code review after each task (catch issues early)
- Faster iteration (no human-in-loop between tasks)
When to use:
- Staying in this session
- Tasks are mostly independent
- Want continuous progress with quality gates
When NOT to use:
- Need to review plan first (use ring:executing-plans)
- Tasks are tightly coupled (manual execution better)
- Plan needs revision (brainstorm first)
The Process
1. Load Plan
Read plan file, create TodoWrite with all tasks.
2. Execute Task with Subagent
Dispatch: Task tool (general-purpose) with: Task N from [plan-file], instructions (implement, test with TDD, verify, commit, report back), working directory. Subagent reports summary.
3. Review Subagent's Work (Parallel Execution)
CRITICAL: Single message with 3 Task tool calls - all reviewers execute simultaneously.
| Reviewer | Model | Context |
|---|---|---|
ring:code-reviewer |
opus | WHAT_WAS_IMPLEMENTED, PLAN, BASE_SHA, HEAD_SHA |
ring:business-logic-reviewer |
opus | Same context |
ring:security-reviewer |
opus | Same context |
Each returns: Strengths, Issues (Critical/High/Medium/Low/Cosmetic), Assessment (PASS/FAIL)
4. Aggregate and Handle Review Feedback
Aggregate all issues by severity across all 3 reviewers.
| Severity | Action |
|---|---|
| Critical/High/Medium | Dispatch fix subagent → Re-run all 3 reviewers → Repeat until clear |
| Low | Add # TODO(review): [issue] - reviewer, date, Severity: Low |
| Cosmetic | Add # FIXME(nitpick): [issue] - reviewer, date, Severity: Cosmetic |
Commit TODO/FIXME comments with fixes.
5. Mark Complete, Next Task
After all Critical/High/Medium issues resolved for current task:
- Mark task as completed in TodoWrite
- Commit all changes (including TODO/FIXME comments)
- Move to next task
- Repeat steps 2-5
6. Final Review (After All Tasks)
Same pattern as Step 3 but reviewing entire implementation (all tasks, full BASE_SHA→HEAD_SHA range). Aggregate, fix, re-run until all 3 PASS.
7. Complete Development
After final review passes:
- Announce: "I'm using the finishing-a-development-branch skill to complete this work."
- REQUIRED SUB-SKILL: Use finishing-a-development-branch
- Follow that skill to verify tests, present options, execute choice
Example Workflow
Task 1: Implement → All 3 reviewers PASS → Mark complete.
Task 2: Implement → Review finds: Critical (hardcoded secret), High (missing password reset, no rate limiting), Low (extract token logic) → Dispatch fix subagent → Re-run reviewers → All PASS → Add TODO for Low → Mark complete.
Final: All 3 reviewers PASS entire implementation → Done.
Why parallel: 3x faster, all feedback at once, TODO/FIXME tracks tech debt.
Advantages
| vs. | Benefits |
|---|---|
| Manual execution | Fresh context per task, TDD enforced, parallel-safe |
| Executing Plans | Same session (no handoff), continuous progress, automatic review |
Cost: More invocations, but catches issues early (cheaper than debugging later).
Red Flags
Never:
- Skip code review between tasks
- Proceed with unfixed Critical/High/Medium issues
- Dispatch reviewers sequentially (use parallel - 3x faster!)
- Dispatch multiple implementation subagents in parallel (conflicts)
- Implement without reading plan task
- Forget to add TODO/FIXME comments for Low/Cosmetic issues
Always:
- Launch all 3 reviewers in single message with 3 Task calls
- Specify
model: "opus"for each reviewer - Wait for all reviewers before aggregating findings
- Fix Critical/High/Medium immediately
- Add TODO for Low, FIXME for Cosmetic
- Re-run all 3 reviewers after fixes
If subagent fails task:
- Dispatch fix subagent with specific instructions
- Don't try to fix manually (context pollution)
Integration
Required workflow skills:
- ring:writing-plans - REQUIRED: Creates the plan that this skill executes
- ring:requesting-code-review - REQUIRED: Review after each task (see Step 3)
- ring:finishing-a-development-branch - REQUIRED: Complete development after all tasks (see Step 7)
Subagents must use:
- ring:test-driven-development - Subagents follow TDD for each task
Alternative workflow:
- ring:executing-plans - Use for parallel session instead of same-session execution
See reviewer agent definitions: ring:code-reviewer (agents/code-reviewer.md), ring:security-reviewer (agents/security-reviewer.md), ring:business-logic-reviewer (agents/business-logic-reviewer.md)