playbooks

home / skills / zpankz / mcp-skillset / subagent-driven-development

subagent-driven-development skill

/subagent-driven-development

This skill creates and executes tasks by dispatching fresh subagents with per-task reviews to ensure fast, high-quality iteration.

npx playbooks add skill zpankz/mcp-skillset --skill subagent-driven-development

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
1.9 KB
---
name: subagent-driven-development
description: Use when executing implementation plans with independent tasks in the current session or facing 3+ independent issues that can be investigated without shared state or dependencies - dispatches fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates
---

# Subagent-Driven Development

Create and execute plan by dispatching fresh subagent per task or issue, with code and output review after each or batch of tasks.

**Core principle:** Fresh subagent per task + review between or after tasks = high quality, fast iteration.

## Overview

Executing Plans through agents:

- Same session (no context switch)
- Fresh subagent per task (no context pollution)
- Code review after each or batch of task (catch issues early)
- Faster iteration (no human-in-loop between tasks)

## Supported Types of Execution

### Sequential Execution

When tasks are tightly coupled and need to be executed in order.

- Dispatch one agent per task or issue
- Let it work sequentially
- Review the output and code after each task or issue

### Parallel Execution

When you have multiple unrelated tasks (different files, different subsystems, different bugs).

- Dispatch one agent per independent problem domain
- Let them work concurrently
- Overall review after all tasks are completed

### Parallel Investigation

Special case for multiple unrelated failures that can be investigated without shared state or dependencies.

## Progressive Loading

**L2 Content** (loaded when sequential execution process needed):
- See: [references/sequential-process.md](./references/sequential-process.md)

**L3 Content** (loaded when parallel execution or investigation needed):
- See: [references/parallel-process.md](./references/parallel-process.md)
- See: [references/parallel-investigation.md](./references/parallel-investigation.md)

Overview

This skill enables executing implementation plans by dispatching a fresh subagent for each independent task or issue, with automated code and output review between tasks. It is designed for sessions that contain three or more independent problems or workflows that do not share state, enabling fast iteration while preserving quality gates.

How this skill works

For each task or issue, the system spawns a fresh subagent that works in isolation to avoid context pollution. After each task or after a batch, the originating controller performs automated code review and output validation, then decides to accept, request revisions, or spawn follow-up tasks. The skill supports both sequential and parallel dispatch patterns depending on task coupling.

When to use it

  • Executing an implementation plan with many independent tasks within the same session
  • Handling 3+ unrelated bugs or issues that can be investigated without shared state
  • When you want faster iteration but need code-level quality gates between steps
  • Parallelizing work across different files, modules, or subsystems
  • Sequential workflows where each step must be reviewed before the next runs

Best practices

  • Define clear, independent task boundaries so each subagent can operate without shared state
  • Use automated code and output checks as mandatory gates after each task or batch
  • Prefer parallel dispatch for unrelated tasks and sequential dispatch for tightly coupled steps
  • Limit subagent responsibilities to short, focused goals to keep reviews fast
  • Collect standardized artifacts (diffs, tests, logs) from each subagent to streamline reviews

Example use cases

  • Fixing multiple independent bugs across different modules by dispatching one subagent per bug and reviewing each patch
  • Implementing a multi-file feature where each file is updated by a dedicated subagent, reviewed in sequence
  • Investigating several unrelated CI failures concurrently with parallel investigation subagents
  • Refactoring several utility functions in parallel, with a central review step to ensure API stability

FAQ

Do subagents share memory or state?

No. Each subagent is spawned fresh and operates in isolation to prevent context pollution and ensure reproducible outputs.

When should I choose sequential over parallel execution?

Choose sequential when tasks are tightly coupled or when an earlier result influences the next step. Use parallel when tasks are independent and can be validated separately.