subagent-driven-development

Dispatch subagents to implement tasks with two-stage spec and code quality reviews.

Updated Apr 11, 2026
One-click install
npx skills add https://github.com/musical-basics/hermes-build-2 --skill subagent-driven-development-musical-basics
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: subagent-driven-development
Source: https://github.com/musical-basics/hermes-build-2/tree/main/skills/software-development/subagent-driven-development
Command: npx skills add https://github.com/musical-basics/hermes-build-2 --skill subagent-driven-development-musical-basics

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill removes inconsistent, ad-hoc implementations by orchestrating focused, fresh subagents per task and enforcing a mandatory two-stage review (spec compliance then code quality) so work is consistent, verifiable, and integrates cleanly.

Core Features & Use Cases

  • Per-task subagents: Launch a fresh implementer for each small task to avoid context pollution and maintain clear accountability.
  • Two-stage review loop: Automatically run a spec compliance review followed by a code quality review, with fix-and-recheck cycles until approval.
  • TDD and integration: Embed test-driven development steps into each task and perform final integration review and full test suite verification before merge.
  • Use Case: Execute an implementation plan composed of independent tasks (models, endpoints, utilities) where each task must pass spec checks and code quality gates before continuation.

Quick Start

Dispatch the skill to run a plan by creating per-task subagents that implement tasks following TDD, verify spec compliance, perform code quality review, and finalize integration.

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 code review for independent tasks in a TDD workflow?

Automated code review in a TDD workflow is handled by dispatching a fresh subagent per task, then enforcing a mandatory two-stage review loop that checks spec compliance and code quality with fix-and-recheck cycles until approval.

What is subagent-driven development for parallel implementation plans?

Subagent-driven development is a parallel task orchestration method that launches isolated subagents for independent implementation tasks, providing per-task context isolation to avoid context pollution and maintain clear accountability.

How do I enforce spec compliance before code quality checks during implementation?

Spec compliance is enforced before code quality checks by running an automated two-stage review loop, where a spec compliance review executes first, followed by a code quality review, with fix-and-recheck cycles until both stages pass.

Does subagent-driven development work for plans with dependent tasks?

Subagent-driven development applies to implementation plans with mostly independent tasks. It dispatches fresh subagents per task, so plans with heavy task dependencies may not suit the per-task context isolation and parallel execution model.

How do I run integration testing after parallel subagent task implementations?

Integration testing after parallel subagent implementations is performed by running a final integration review and full test suite verification before merge, ensuring all independently implemented tasks integrate cleanly and pass terminal and file toolset checks.

Why should I use fresh subagents for each task instead of a single agent?

Fresh subagents for each task remove inconsistent, ad-hoc implementations by providing per-task context isolation, preventing context pollution across tasks, and maintaining clear accountability throughout the implementation plan.