subagent-driven-development

Execute implementation plans by dispatching a fresh subagent per task with two-stage review.

8|Updated Mar 8, 2026

Search Tags:#workflow #implementation #review #execution #subagent #code production

Ready to run

npx skills add https://github.com/SufficientDaikon/omniskill --skill subagent-driven-development-sufficientdaikon

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: subagent-driven-development
Source: https://github.com/SufficientDaikon/omniskill/tree/main/skills/subagent-driven-development
Command: npx skills add https://github.com/SufficientDaikon/omniskill --skill subagent-driven-development-sufficientdaikon

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a structured and disciplined process for executing complex implementation plans by breaking them down into independent tasks, each handled by a fresh subagent with a rigorous two-stage review process.

Core Features & Use Cases

Task Decomposition: Executes plans by dispatching a dedicated subagent for each independent task.
Two-Stage Review: Implements a mandatory spec compliance review followed by a code quality review for each task.
Context Isolation: Ensures each subagent operates with a clean context, preventing pollution from previous tasks.
Use Case: Use this skill to manage the development of a new feature, where the implementation plan is broken into distinct tasks like 'create database schema', 'build API endpoint', and 'develop frontend component', with each task being executed and reviewed independently.

Quick Start

Use the subagent-driven-development skill to execute the provided implementation plan, ensuring each task is reviewed by both spec and code quality agents.

Frequently Asked Questions about subagent-driven-development

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

FAQPage Schema

How do I execute an implementation plan with independent subagents?▼

Executing an implementation plan with independent subagents involves dispatching a fresh subagent per task to ensure context isolation, followed by a mandatory two-stage review for spec compliance and code quality. This process ensures independent task execution and rigorous quality control.

What is the two-stage review process for subagent-driven development?▼

The two-stage review process for subagent-driven development requires each task to undergo a spec compliance review followed by a code quality review. This mandatory process ensures that every subagent's execution meets the implementation plan specifications and maintains high code production standards.

How do I manage feature development tasks like database schemas and API endpoints independently?▼

Managing feature development tasks independently requires decomposing the implementation plan into distinct tasks such as creating a database schema or building an API endpoint. A dedicated subagent executes each task with a clean context to prevent pollution from previous tasks, followed by a two-stage review.

Do I need subagents available to use subagent-driven development?▼

Yes, you need subagents to be available to use subagent-driven development, as the skill dispatches a fresh subagent for each independent task. Additionally, the implementation plan must contain independent tasks to ensure proper context isolation and execution.

Why does context isolation matter when dispatching subagents for code production?▼

Context isolation matters when dispatching subagents for code production because it ensures each subagent operates with a clean context, preventing pollution from previous tasks. This approach maintains the independence of each task execution and supports rigorous quality control during the two-stage review.

When should I not use subagent-driven development for implementation plans?▼

You should not use subagent-driven development when subagents are unavailable or when the implementation plan lacks independent tasks. The execution engine requires both available subagents and a plan decomposed into independent tasks to properly perform task execution and the mandatory two-stage review.