subagent-driven-development

Execute multi-task implementation plans with fresh subagents and two-stage reviews.

247|22|Updated Dec 11, 2024
One-click install
npx skills add https://github.com/graniet/kheish --skill subagent-driven-development-graniet
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: subagent-driven-development
Source: https://github.com/graniet/kheish/tree/main/skills/software-development/subagent-driven-development
Command: npx skills add https://github.com/graniet/kheish --skill subagent-driven-development-graniet

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Manually executing multi-task implementation plans leads to context pollution from accumulated state, inconsistent code quality, and missed spec or quality issues that compound across tasks, requiring costly rework and delaying delivery.

Core Features & Use Cases

  • Fresh Subagent Per Task: Dispatches a new, focused subagent for each independent task to eliminate context confusion from prior work and ensure clean, targeted implementation.
  • Mandatory Two-Stage Review: Enforces spec compliance review followed by code quality review for every task, catching under/over-building and code defects before they propagate to later tasks.
  • End-to-End Workflow Integration: Natively integrates with planning skills like writing-plans, test-driven development practices, and systematic debugging tools to automate the full implementation lifecycle from plan to committed, tested code.
  • Use Case: A software engineering team implementing a new payment processing feature with 6 independent tasks (payment model, transaction logging, endpoint creation, etc.) can use this skill to automate implementation, ensure every task matches the original plan requirements, and validate code quality before integration, reducing post-integration bugs by over 50%.

Quick Start

Use the subagent-driven-development skill to execute the implementation plan stored at docs/plans/payment-feature.md, automatically dispatching fresh subagents for each task with built-in spec compliance and code quality reviews.

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 multi-task software implementation without context pollution?

Automating multi-task implementation without context pollution requires dispatching a fresh subagent for each independent task. This approach ensures clean, targeted execution by isolating state, preventing accumulated context confusion from prior work.

How does two-stage review work for code quality and spec compliance?

Two-stage review enforces spec compliance validation followed by code quality validation for every completed task. This mandatory sequence catches under-building, over-building, and code defects before they propagate to later tasks or integration.

What is the best way to execute a payment processing feature plan with independent tasks?

Executing a multi-task feature plan like payment processing is best handled by dispatching independent subagents for each task, such as model creation and endpoint setup, with automated spec compliance and quality reviews before integration.

Does subagent-driven development work with test-driven development and systematic debugging workflows?

Subagent-driven development natively integrates with test-driven development practices, planning skills, and systematic debugging tools. It automates the full implementation lifecycle from plan execution to committed, tested code with built-in guardrails.

Why does manual execution of multi-task development plans lead to inconsistent code quality?

Manual execution of multi-task development plans leads to inconsistent code quality due to context pollution from accumulated state and missed spec issues that compound across tasks, requiring costly rework and delaying delivery.

Can I reduce post-integration bugs when implementing independent software engineering tasks?

You can reduce post-integration bugs by over 50% when implementing independent software engineering tasks by enforcing mandatory two-stage spec compliance and code quality reviews prior to integration for every dispatched task.