Implementing

Execute implementation plans with TDD, subagent-driven development, and code review checkpoints. This workflow turns a plan into working, tested, reviewed code.

When to Use This

• You have a written implementation plan (from /write-plan or /speckit-plan).
• You want TDD — tests written before implementation code.
• You want automatic code review between plan steps.
• The implementation has multiple independent tasks that can be parallelized.

What You'll Use

Walkthrough

Scenario: Execute the API endpoint plan from the planning workflow.

Step 1: Execute the Plan

Run /execute-plan and provide the plan (or reference the plan file if it was saved):

"Execute the user preferences API plan we wrote."

Step 2: TDD for Each Task

For each task in the plan, the test-driven-development skill enforces the TDD cycle:

1. Write the test first — Claude writes a failing test that describes the expected behavior.
2. Run the test — Confirm it fails for the right reason.
3. Write the implementation — Write the minimum code to make the test pass.
4. Run all tests — Confirm the new test passes and no existing tests broke.
5. Refactor if needed — Clean up the implementation while keeping tests green.

Step 3: Code Review Between Steps

After each task, the code-reviewer agent runs automatically:

• Reviews the changes made in the current task
• Checks for bugs, style issues, and missed edge cases
• Verifies the implementation matches the plan
• Flags any concerns before moving to the next task

If the reviewer finds issues, Claude addresses them before proceeding.

Step 4: Subagent Parallelization

When the plan has independent tasks (tasks that do not depend on each other), the subagent-driven-development skill dispatches parallel subagents:

• Each subagent works on one task independently
• Results are collected and reviewed
• Dependencies are respected — parallel execution only happens for truly independent tasks

Step 5: Verification

Before marking the plan as complete, the verification-before-completion skill runs final checks:

• All tests pass
• No linting errors
• All plan tasks are addressed
• Code review findings are resolved

Quick Reference

Tips

• The TDD skill is strict: it will not let you write implementation before tests. This is by design.
• Code review between steps catches issues early, when they are cheap to fix.
• For very large plans, consider splitting into multiple /execute-plan runs.
• The ralph-wiggum plugin offers an alternative approach: iterative loops that keep running until completion. Use superpowers for structured plan execution, ralph-wiggum for open-ended iteration.

See Also

• superpowers plugin — Full plugin documentation
• Planning workflow — Previous step: write the plan
• Code Review workflow — Standalone code review
• ralph-wiggum plugin — Alternative: iterative loops