Executing Plans — Full Pipeline

Plan → File → Execute. One skill for the entire workflow.

---

Pipeline Overview

Spec (from brainstorming)

  → Phase 1: Write Implementation Plan (docs/superpowers/plans/)

  → Phase 2: Create Working Files (task_plan.md, findings.md, progress.md)

  → Phase 3: Execute Tasks

  → Phase 4: Report & Close

---

Phase 1: Write the Plan

Announce: "I'm using the executing-plans skill to create the implementation plan."

Plan Header

# [Feature Name] Implementation Plan



**Goal:** [One sentence]

**Architecture:** [2-3 sentences]

**Tech Stack:** [Key technologies]



## Global Constraints

[Project-wide requirements copied from spec]



---

Task Structure

Each task is one action (2-5 minutes):

### Task N: [Component Name]



**Files:**

- Create: `exact/path/to/file.py`

- Modify: `exact/path/to/existing.py:123-145`



**Interfaces:**

- Consumes: [what from earlier tasks]

- Produces: [what later tasks need]



- [ ] **Step 1: Write the failing test**

      ```python

      def test_specific_behavior():

          result = function(input)

          assert result == expected

      ```



- [ ] **Step 2: Run test to verify it fails**

      Run: `pytest tests/path/test.py::test_name -v`

      Expected: FAIL



- [ ] **Step 3: Write minimal implementation**

- [ ] **Step 4: Run test to verify it passes**

- [ ] **Step 5: Commit**

No Placeholders

NEVER write: "TBD", "TODO", "implement later", "add error handling", "write tests" (without actual code), "similar to Task N" (repeat the code).

Self-Review

After writing, check:

1. Spec coverage — every requirement has a task

2. Placeholder scan — no TBD/TODO

3. Type consistency — signatures match across tasks

Save & Handoff

Save to: docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md

---

Phase 2: Create Working Files

After the plan is written, create persistent planning files in the project root.

task_plan.md

# Task Plan: [Feature]



## Goal

[One sentence]



## Phases

### Phase 1: [Name]

Status: pending | in_progress | complete

Tasks:

- [ ] Task 1

- [ ] Task 2



## Decisions

| # | Decision | Rationale |

|---|----------|-----------|



## Errors

| Error | Attempt | Resolution |

|-------|---------|------------|

findings.md

# Findings: [Feature]



## [Date]

- Discovery 1

- Discovery 2

progress.md

# Progress: [Feature]



## Session YYYY-MM-DD

- **HH:MM** — Action

- **HH:MM** — Result

Rules

1. Create plan first — never start a complex task without task_plan.md

2. Read before decide — re-read plan before major decisions

3. Update after act — mark phases complete, log errors

4. 2-Action Rule — after every 2 browser/search operations, save findings to findings.md

5. Log ALL errors — every error goes in the plan file

6. Never repeat failures — track attempts, mutate approach

---

Phase 3: Execute Tasks

Load and Review

1. Read plan file

2. Review critically — questions or concerns?

3. If concerns: raise before starting

4. If clear: create todos and proceed

Execute

For each task:

1. Mark as in_progress

2. Follow each step exactly

3. Run verifications as specified

4. Mark as completed

5. Update progress.md

Verification Gates

• Programmatic: command must exit 0

• Judge: rubric for quality assessment

• Human: explicit user confirmation needed

When to Stop

• Blocker (missing dependency, test fails, instruction unclear)

• Plan has critical gaps

• Verification fails repeatedly

• 3 consecutive failures → escalate to user

When NOT to Do

• Start implementation on main/master branch without explicit consent

• Skip verifications

• Force through blockers — stop and ask

---

Phase 4: Report & Close

1. Verify all phases complete in task_plan.md

2. Save final progress.md entry

3. Report to user:

   • What was done

   • Files modified

   • Any issues / blockers

   • Verification results

Per-Task Review (merged from subagent-driven-development)

Between plan tasks — a quick review per task:

• Spec compliance — does the implementation correspond to the task text in the plan?

• Code quality — clean, no regressions, tests green?

• Found non-conformance to plan → ask the user what takes precedence

  (the plan text or the task), don't silently choose.

• Final broad review of all code — after the last task.

Continuous execution: between plan tasks do NOT pause with "continue?".

Execute all tasks in a row; stop only: BLOCKED, which you cannot resolve;

ambiguity that really blocks progress; all tasks are done.