home / skills / yellinzero / aico / subagent-driven

subagent-driven skill

safe

/employees/_shared/skills/subagent-driven

This skill executes an implementation plan by delegating tasks to subagents, ensuring spec compliance then quality review before progressing.

npx playbooks add skill yellinzero/aico --skill subagent-driven

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.6 KB

---
name: aico-subagent-driven
description: |
  Execute implementation plan by dispatching fresh subagent per task. Each task gets: Implementer → Spec Review → Quality Review. Two-stage review ensures both correctness and quality.

  Use this skill when:
  - Have implementation plan with multiple independent tasks
  - Want automated execution with quality gates after each task
  - Tasks are mostly independent (not tightly coupled)
  - User asks to "execute the plan", "run the tasks", "auto implement"

  Prerequisites: Must have plan from aico-*-plan or aico-*-task-breakdown skill.
  Process: For each task: Dispatch Implementer → Spec Review (passes?) → Quality Review (passes?) → Next task
  Review order: ALWAYS spec compliance first, THEN code quality.
---

# Subagent-Driven Development

## Process

```
1. Read plan, extract all tasks
      ↓
2. Create TodoWrite with all tasks
      ↓
3. For each task:
   a. Dispatch Implementer Subagent
   b. Implementer: implement and test
   c. Dispatch Spec Reviewer (matches spec?)
   d. Spec issues? → Implementer fixes → re-review
   e. Dispatch Quality Reviewer (code quality?)
   f. Quality issues? → Implementer fixes → re-review
   g. Mark task complete
      ↓
4. All tasks complete → Final review → Done
```

## Review Order is Critical

```
Spec Compliance Review FIRST
        ↓
    ✅ Passes
        ↓
Code Quality Review SECOND
```

**Why:** No point reviewing code quality if it doesn't meet spec.

## Subagent Prompts

### Implementer

- Provide FULL task text (don't make subagent read file)
- Provide context (where task fits in plan)
- Require TDD and self-review

### Spec Reviewer

- Check: Does implementation match spec exactly?
- Missing anything? Added anything extra?

### Quality Reviewer

- Check: Tests, readability, error handling, performance, security
- Rate issues as Critical/Important/Minor

## Key Rules

- ALWAYS run both reviews (spec AND quality)
- MUST fix issues before proceeding to next task
- NEVER dispatch multiple implementers in parallel
- ALWAYS provide full task text to subagent
- Spec review FIRST, then quality review

## Red Flags

**Never:**

- Skip any review
- Proceed with unfixed issues
- Start quality review before spec passes
- Move to next task with open issues

**If issues found:**

- Same implementer fixes them
- Reviewer reviews again
- Repeat until approved

## Common Mistakes

- ❌ Skip spec review → ✅ Always verify spec first
- ❌ Skip quality review → ✅ Always check quality
- ❌ Wrong review order → ✅ Spec first, then quality
- ❌ Provide partial task text → ✅ Give full text

Overview

This skill executes an implementation plan by dispatching a fresh subagent for each task and enforcing a two-stage review: spec compliance first, then code quality. Each task flows through an Implementer, a Spec Reviewer, and a Quality Reviewer, with fixes required before proceeding. It is designed to automate task execution while preserving correctness and maintainability.

How this skill works

The skill reads an existing plan, extracts tasks, and creates a master todo list. For each task it launches an Implementer subagent to implement and test, then runs a Spec Reviewer to confirm exact compliance, and finally runs a Quality Reviewer to check tests, readability, error handling, performance, and security. Any issues are fixed by the same Implementer and the reviewers re-run until the task is approved, then the skill moves to the next task.

When to use it

You have a multi-task implementation plan generated by a plan or task-breakdown skill.
You want fully automated execution with enforced quality gates after every task.
Tasks are independent or loosely coupled and can be executed sequentially.
You need strict spec compliance before any code-quality evaluation.
You want repeatable, auditable task-level reviews and fixes.

Best practices

Always provide a complete, self-contained task description to the Implementer subagent.
Ensure the plan contains independent tasks; avoid tightly coupled work items.
Enforce Test-Driven Development (TDD) and require implementer self-review before review dispatch.
Never skip spec review; fix spec issues before running quality checks.
Use the same implementer for iterative fixes to maintain context and ownership.

Example use cases

Execute a frontend feature list where each widget is an independent task with tests.
Automate backend microservice endpoints implementation task-by-task with spec gates.
Run a migration plan where each DB migration is implemented, spec-reviewed, and quality-reviewed sequentially.
Turn a task breakdown into working code for a TypeScript repo with enforced test coverage.

FAQ

What happens if a spec reviewer finds missing requirements?

The Implementer fixes the issues and the Spec Reviewer rechecks; the task does not proceed to quality review until spec passes.

Can multiple implementers work in parallel?

No. The process mandates a single implementer per task and no parallel implementers to preserve consistency and review order.