subagent-driven-development

Subagent-Driven Development

Overview

Execute implementation plans task-by-task with systematic two-stage review between tasks.

Core principle: Fresh focus per task + two-stage review (spec then quality) = high quality, fast iteration.

Poirot note: The original skill dispatches a fresh subagent per task via delegate_task. Poirot has no subagents, so this version executes tasks sequentially in the same context with a deliberate context-reset between tasks. The two-stage review methodology is preserved.

When to Use

• You have an implementation plan (from the plan skill or user requirements)
• Tasks are mostly independent
• Quality and spec compliance are important
• You want automated review between tasks

The Process

1. Read and Parse Plan

Read the plan file. Extract ALL tasks with full text and context upfront:

read_file(".poirot/plans/feature-plan.md")

Create a todo list with all tasks. Read the plan ONCE — don't re-read per task.

2. Per-Task Workflow

For EACH task in the plan:

Step 1: Context Reset

Before starting each task, deliberately reset your focus:

• Re-read only the current task's description
• Forget previous tasks' implementation details (they're committed)
• Treat each task as if a fresh agent is picking it up

Step 2: Implement

Follow the task's steps exactly:

1. Write the failing test (TDD — see test-driven-development skill)
2. Run test to verify failure
3. Write minimal implementation
4. Run test to verify pass
5. Run full test suite to check for regressions
6. Commit

bash("pytest tests/test_feature.py::test_name -v")
# ... implement ...
bash("pytest tests/ -q")
bash("git add -A && git commit -m 'feat: task N description'")

Step 3: Stage 1 Review — Spec Compliance

After implementation, review against the plan:

• Does the implementation match the task's stated objective?
• Are all files listed in the task created/modified?
• Are all tests listed in the task written?
• Does the implementation do what the task says, not more, not less?