About

Imported from nickcrew/claude-cortex (skills/subagent-driven-development/SKILL.md). Install upstream with npx skills add nickcrew/claude-cortex --skill subagent-driven-development. Copyright stays with the author.

Subagent-Driven Development

Name: subagent-driven-development
Author: nickcrew

Execute plan by dispatching fresh subagent per task, with code review after each.

Core principle: Fresh subagent per task + review between tasks = high quality, fast iteration

Overview

vs. Executing Plans (parallel session):

Same session (no context switch)
Fresh subagent per task (no context pollution)
Code review after each task (catch issues early)
Faster iteration (no human-in-loop between tasks)

When to use:

Staying in this session
Tasks are mostly independent
Want continuous progress with quality gates

When NOT to use:

Need to review plan first (use executing-plans)
Tasks are tightly coupled (manual execution better)
Plan needs revision (brainstorm first)

The Process

1. Load Plan

Read plan file, create TodoWrite with all tasks.

2. Execute Task with Subagent

For each task:

Dispatch fresh subagent:

Task tool (general-purpose):
  description: "Implement Task N: [task name]"
  prompt: |
    You are implementing Task N from [plan-file].

    Read that task carefully. Your job is to:
    1. Implement exactly what the task specifies
    2. Write tests (following TDD if task says to)
    3. Verify implementation works
    4. Commit your work
    5. Report back

    Work from: [directory]

    Report: What you implemented, what you tested, test results, files changed, any issues

Subagent reports back with summary of work.

3. Review Subagent's Work

Dispatch code-reviewer subagent:

Task tool (code-reviewer):
  Use template at requesting-code-review/code-reviewer.md

  WHAT_WAS_IMPLEMENTED: [from subagent's report]
  PLAN_OR_REQUIREMENTS: Task N from [plan-file]
  BASE_SHA: [commit before task]
  HEAD_SHA: [current commit]
  DESCRIPTION: [task summary]

Code reviewer returns: Strengths, Issues (Critical/Important/Minor), Assessment

4. Apply Review Feedback

If issues found:

Fix Critical issues immediately
Fix Important issues before next task
Note Minor issues

Dispatch follow-up subagent if needed:

"Fix issues from code review: [list issues]"

5. Mark Complete, Next Task

Mark task as completed in TodoWrite
Move to next task
Repeat steps 2-5

6. Final Review

After all tasks complete, dispatch final code-reviewer:

Reviews entire implementation
Checks all plan requirements met
Validates overall architecture

7. Complete Development

After final review passes:

Announce: "I'm using the finishing-a-development-branch skill to complete this work."
REQUIRED SUB-SKILL: Use finishing-a-development-branch
Follow that skill to verify tests, present options, execute choice

Example Workflow

You: I'm using Subagent-Driven Development to execute this plan.

[Load plan, create TodoWrite]

Task 1: Hook installation script

[Dispatch implementation subagent]
Subagent: Implemented install-hook with tests, 5/5 passing

[Get git SHAs, dispatch code-reviewer]
Reviewer: Strengths: Good test coverage. Issues: None. Ready.

[Mark Task 1 complete]

Task 2: Recovery modes

[Dispatch implementation subagent]
Subagent: Added verify/repair, 8/8 tests passing

[Dispatch code-reviewer]
Reviewer: Strengths: Solid. Issues (Important): Missing progress reporting

[Dispatch fix subagent]
Fix subagent: Added progress every 100 conversations

[Verify fix, mark Task 2 complete]

...

[After all tasks]
[Dispatch final code-reviewer]
Final reviewer: All requirements met, ready to merge

Done!

Advantages

vs. Manual execution:

Subagents follow TDD naturally
Fresh context per task (no confusion)
Parallel-safe (subagents don't interfere)

vs. Executing Plans:

Same session (no handoff)
Continuous progress (no waiting)
Review checkpoints automatic

Cost:

More subagent invocations
But catches issues early (cheaper than debugging later)

Red Flags

Never:

Skip code review between tasks
Proceed with unfixed Critical issues
Dispatch multiple implementation subagents in parallel (conflicts)
Implement without reading plan task

If subagent fails task:

Dispatch fix subagent with specific instructions
Don't try to fix manually (context pollution)

Integration

Required workflow skills:

writing-plans - REQUIRED: Creates the plan that this skill executes
requesting-code-review - REQUIRED: Review after each task (see Step 3)
finishing-a-development-branch - REQUIRED: Complete development after all tasks (see Step 7)

Subagents must use:

Test-first discipline - Each subagent writes a failing test before implementing its task, then makes it pass

Alternative workflow:

executing-plans - Use for parallel session instead of same-session execution

See code-reviewer template: requesting-code-review/code-reviewer.md

Use it

Copy one of these into your project. Installing also returns the manifest and these snippets.

yaml

targets:
  - https://api.opensmartroute.ai/api/v1/registry/nickcrew-claude-cortex-subagent-driven-development/manifest   # or paste the manifest below

Manifest

An Open Capability Manifest: the router reads it to know what this does, what it costs and when to pick it.

nickcrew-claude-cortex-subagent-driven-development.ocm.jsonjson

{
  "ocm": "1",
  "id": "nickcrew-claude-cortex-subagent-driven-development",
  "kind": "skill",
  "name": "subagent-driven-development",
  "description": "Use when executing implementation plans with independent tasks in the current session - dispatches fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates",
  "publisher": "nickcrew",
  "version": "1.0.0",
  "capabilities": {
    "domains": [
      "coding"
    ],
    "tags": [
      "skill-md",
      "agent-development",
      "agent-orchestration",
      "modular-agent",
      "subagent",
      "skills-sh"
    ],
    "languages": [
      "en"
    ]
  },
  "quality_prior": 0.6,
  "examples": [
    "Use when executing implementation plans with independent tasks in the current session - dispatches fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates"
  ],
  "primary": false,
  "metadata": {
    "source": {
      "provider": "skills.sh",
      "repository": "https://github.com/nickcrew/claude-cortex",
      "path": "skills/subagent-driven-development/SKILL.md",
      "ref": "HEAD",
      "url": "https://github.com/nickcrew/claude-cortex/blob/HEAD/skills/subagent-driven-development/SKILL.md",
      "key": "nickcrew/claude-cortex/skills/subagent-driven-development/SKILL.md"
    }
  },
  "instructions": "# Subagent-Driven Development\n\nExecute plan by dispatching fresh subagent per task, with code review after each.\n\n**Core principle:** Fresh subagent per task + review between tasks = high quality, fast iteration\n\n## Overview\n\n**vs. Executing Plans (parallel session):**\n- Same session (no context switch)\n- Fresh subagent per task (no context pollution)\n- Code review after each task (catch issues early)\n- Faster iteration (no human-in-loop between tasks)\n\n**When to use:**\n- Staying in this session\n- Tasks are mostly independent\n- Want continuous progress with quality gates\n\n**When NOT to use:**\n",
  "cost": {
    "context_tokens": 1209
  }
}

Fetch it by URL: GET /api/v1/registry/nickcrew-claude-cortex-subagent-driven-development/manifest?version=1.0.0

Reviews

Star ratings from people who tried it. One review per account; edit yours any time.

No reviews yet. Install it, try it, and be the first to rate it.