subagent-driven-development

Dispatch fresh subagents per task with code reviews between tasks.

Updated Oct 22, 2025
One-click install
npx skills add https://github.com/franroa/chezmoi --skill subagent-driven-development-franroa
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: subagent-driven-development
Source: https://github.com/franroa/chezmoi/tree/main/dot_opencode/superpowers/skills/subagent-driven-development
Command: npx skills add https://github.com/franroa/chezmoi --skill subagent-driven-development-franroa

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill optimizes the execution of implementation plans by dispatching fresh AI subagents for each task, with a code review after every task. This approach ensures high quality, prevents context pollution, and enables fast iteration within the current session.

Core Features & Use Cases

  • Fresh Subagent Per Task: Dispatches a new subagent for each task, preventing context pollution and ensuring focused execution.
  • Continuous Code Review: Integrates a mandatory code review after each task, catching issues early before they compound.
  • Fast Iteration: Enables rapid progress within the same session, with quality gates built into the workflow.
  • Use Case: When you have an implementation plan with independent tasks and want to stay in the current session for continuous progress, use this Skill. For example, after loading a plan, this Skill will dispatch a subagent to implement Task 1, then request a code review, fix any issues, and move to Task 2.

Quick Start

Announce skill usage

I'm using the subagent-driven-development skill to execute this plan.

Example: Dispatching a subagent for Task 1

Task tool (general-purpose): description: "Implement Task 1: Hook installation script" prompt: | You are implementing Task 1 from [plan-file]. # ... (rest of prompt) ...

Frequently Asked Questions about subagent-driven-development

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I prevent context pollution when executing multiple implementation tasks in a single session?

Context pollution occurs when task history accumulates in a single agent's memory, degrading focus and quality. Subagent-driven development dispatches a fresh AI agent for each task, isolating context and ensuring each task receives undivided attention without prior task artifacts interfering.

What's the best way to integrate code review gates into task execution workflows?

Enforce mandatory code review after every task completes. This catches issues early before they compound into later tasks, maintains quality throughout implementation, and enables rapid iteration by catching defects at task boundaries rather than at final review.

How do I execute an implementation plan with independent tasks while staying in the current session?

Use subagent-driven development to dispatch a dedicated subagent per task, request code review after each task, apply fixes, then move to the next task. This workflow keeps all execution within one session while maintaining quality gates and preventing context degradation.

Can I use subagent-driven development for tasks that depend on each other?

Subagent-driven development optimizes plan execution when tasks are largely independent. For tightly coupled or sequential tasks with heavy dependencies, a single continuous agent may be more efficient, as fresh subagent dispatch adds overhead without context reuse benefit.

What are the prerequisites before dispatching subagents for task execution?

You need a loaded implementation plan that breaks work into discrete, largely independent tasks. The plan should define task scope, success criteria, and any shared context or outputs tasks reference, allowing subagents to execute with minimal cross-task coordination.

Why does dispatching a fresh subagent for each task improve code quality?

Fresh subagents eliminate accumulated context drift and fatigue that degrades decision-making in long sessions. Paired with mandatory code review between tasks, this separation ensures each task receives focused reasoning and early defect detection before issues cascade downstream.