execute-plans

execute the plan, implement the spec, build this, start coding, run the plan, implement tasks, work through the plan, execute tasks, build from spec. Task-by-task plan execution with implementer subag

SKILL.md

GitHub

Execute Plans

Execute an implementation plan task-by-task using subagents. Each task gets: implement → spec review → code quality review → fix loop → next task.

Step 1: Load the plan

Find the spec by slug from $ARGUMENTS or most recent in .claude/specs/. Read all spec files:

  • requirements.md
  • design.md
  • tasks.md
  • diagrams.md (if exists — generated by /plan visualize)

If tasks.md doesn't exist or has no tasks: Stop. "No tasks found. Run /plan review first to generate tasks."

Step 2: Review the plan critically

Before executing anything:

  1. Read the task list. Are tasks ordered correctly? Are dependencies satisfied?
  2. Read CLAUDE.md for project conventions.
  3. Check the current branch — if on main, create a feature branch first.
  4. Raise any concerns via AskUserQuestion before starting.

Step 3: Execute in batches

Work through tasks in batches of 3 (configurable). For each task:

3a: Dispatch implementer agent

prompt: "You are implementing a task from a spec. Read CLAUDE.md first.

TASK:
<full task text from tasks.md — never make the agent read the file>

SPEC CONTEXT:
<relevant sections from requirements.md and design.md>

DIAGRAMS:
<relevant diagrams from diagrams.md, if they exist>

Instructions:
1. If anything is unclear, list your questions and STOP — do not guess.
2. Implement exactly what the task specifies. Nothing more, nothing less.
3. Write tests for new functionality.
4. Run tests to verify they pass.
5. Commit your changes with a descriptive message.
6. Self-review: check completeness, code quality, test coverage.

Return: what you implemented, what tests you wrote, test results, any concerns."
description: "Implement task: <task title>"

If the agent has questions: Present them to the user via AskUserQuestion. Answer, then re-dispatch.

3b: Dispatch spec compliance reviewer

After the implementer finishes:

prompt: "You are reviewing an implementation for spec compliance. Read the actual code changes (git diff), not just the implementer's report.

TASK THAT WAS IMPLEMENTED:
<full task text>

SPEC REQUIREMENTS:
<relevant requirements>

Check:
- Did the implementer build exactly what was requested?
- Is anything missing from the task requirements?
- Is there extra/unneeded work beyond the task scope?
- Do the tests cover the requirements?

Report: ✅ Passes spec compliance, or ❌ with specific file:line issues."
description: "Spec review: <task title>"

If issues found: Re-dispatch the implementer with the specific issues. Re-review after fixes. Max 2 fix cycles — if still failing, escalate to user.

3c: Dispatch code quality reviewer

Only after spec compliance passes:

prompt: "You are reviewing code quality. Read CLAUDE.md first, then review the changes.

Run: git diff origin/main --name-only to find changed files. Read each changed file.

Check:
- Does the code follow project conventions from CLAUDE.md?
- Are there DRY violations, unnecessary complexity, or missing error handling?
- Could existing utilities be reused instead of new code?
- Are there security concerns?

Report: list of issues (Critical/Important/Minor) with file:line references and suggested fixes."
description: "Quality review: <task title>"

If critical issues found: Fix them (or dispatch implementer to fix). Re-review.

3d: Mark task complete

Update tasks.md — check off the completed task.

Step 4: Batch checkpoint

After each batch of 3 tasks, report to the user:

Batch N complete: tasks X-Y done
  Implemented: [summary of each task]
  Spec reviews: all passed (or N fix cycles needed)
  Quality reviews: N issues found and fixed
  Tests: all passing

Next batch: tasks Y+1 to Z
Continue? (A) Yes  (B) Review changes first  (C) Stop here

Step 5: Completion

After all tasks are done:

  1. Run the full test suite
  2. Update tasks.md with all checkboxes checked
  3. Report final status
Plan execution complete:
  Tasks: N/N completed
  Test suite: passing
  Fix cycles: N total across all tasks

Ready for /review and /ship

Gotchas

  • Never start implementing on main/master. Always create a feature branch first.
  • Never skip the spec compliance review. It catches scope drift — implementers tend to over-build.
  • Spec review BEFORE quality review. No point polishing code that doesn't match the spec.
  • Include full task text in agent prompts. Never tell the agent to "read tasks.md" — fresh agents don't have your context.
  • Max 2 fix cycles per review stage. If it's still failing after 2 rounds, the task spec is probably unclear — escalate to the user.
  • Tasks must execute sequentially. Unlike parallel review agents, implementation tasks often have dependencies. Never dispatch multiple implementers in parallel.