subagent-driven-development

Coordinates per-task subagents to execute plans with strict spec and quality validation.

437|13|Updated Feb 25, 2026
One-click install
npx skills add https://github.com/derHaken/SuperAntigravity --skill subagent-driven-development-derhaken
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: subagent-driven-development
Source: https://github.com/derHaken/SuperAntigravity/tree/main/skills/subagent-driven-development
Command: npx skills add https://github.com/derHaken/SuperAntigravity --skill subagent-driven-development-derhaken

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill enables end-to-end execution of implementation plans by dispatching fresh subagents per task, with a two-stage review after each: spec compliance review first, then code quality review.

Core Features & Use Cases

  • Fresh per-task subagents to isolate context and reduce cross-task contamination.
  • Two-stage review loop: first ensure the implementation matches the spec, then verify code quality and completeness.
  • Flexible workflow: supports both inline same-session execution and sequential task handoffs within a single session.
  • Real-world use case: run a plan with multiple independent tasks, validating each task before proceeding to the next.

Quick Start

Start by reading the plan, dispatch an implementer subagent for each task, and run the two-stage review loop.

Frequently Asked Questions about subagent-driven-development

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

FAQPage Schema
How do I automate plan execution with subagents to ensure spec compliance?

Automate plan execution by dispatching fresh subagents per task to isolate context, then applying a two-stage review loop that first checks spec compliance and then verifies code quality before proceeding to the next task.

What is a two-stage review process in plan-driven development?

A two-stage review process validates completed tasks sequentially: the first stage ensures the implementation matches the specification, while the second stage verifies overall code quality and completeness before moving forward.

How do I prevent cross-task context contamination when executing multiple development tasks?

Prevent cross-task contamination by dispatching fresh subagents for each individual task item, which isolates the execution context and ensures prior task outputs do not interfere with ongoing implementation work.

Can I run independent tasks sequentially within a single development session?

Yes, you can run independent tasks sequentially within a single session using inline same-session execution, validating each task through the two-stage review loop before handing off to the next.

Do I need a final integration step when orchestrating tasks with subagents?

Yes, a final integration step is required to finish development after all per-task subagents complete their work, ensuring the individually validated tasks merge into a cohesive software delivery output.

When should I use subagent-driven development for software delivery?

Use subagent-driven development when working with plan-driven tasks decomposed into discrete work items that require strict validation, parallel-safe execution, and high-quality code review before final integration.