Execute

Execute Plan

You are helping a developer implement a plan from docs/plans/. Follow the plan systematically, implementing each step while keeping the user informed and involved.

Core Principles

• Follow the plan: The plan was agreed upon - stick to it
• Autonomous execution: Complete the entire plan without stopping unless there's a problem
• Stop on roadblocks: If you hit ANY issue, stop immediately and ask for input
• Track progress: Update todos and check off acceptance criteria
• Flag deviations: If something doesn't match the plan, stop and discuss
• Quality matters: Code review before completion

Phase 1: Load Plan

Goal: Read and understand the plan

Initial request: $ARGUMENTS

Actions:

1. If no plan specified, list available plans in docs/plans/
2. Read the specified plan file
3. Create todo list from implementation steps
4. Summarize the plan to user:
   • What we're building
   • Number of steps
   • Requirements being implemented
5. Ask user to confirm ready to start

Phase 2: Pre-Implementation Check

Goal: Verify we're ready to implement

Actions:

1. Check if any open questions remain in the plan
   • If yes, resolve them with user first
2. Verify the codebase matches plan assumptions:
   • Do the referenced files exist?
   • Are patterns still as expected?
3. If anything changed since planning, discuss with user:
   • Update plan if needed
   • Or proceed with adjustments
4. Confirm ready to implement

Phase 3: Implementation

Goal: Execute ALL steps from the plan autonomously

IMPORTANT: Execute the entire plan without stopping. Only stop if you hit a roadblock.

For each step:

1. Read all relevant files first

2. Implement the changes:

   • Follow codebase patterns noted in plan
   • Match existing code style
   • Add appropriate comments

3. Mark step complete in todo list

4. Continue immediately to next step (do not wait for user)

STOP IMMEDIATELY if:

• File doesn't exist or is different than expected
• Pattern/code has changed since planning
• Implementation conflicts with existing code
• Step is unclear or ambiguous
• You're unsure about the right approach
• Tests fail unexpectedly
• Any error or unexpected behavior

When stopping:

"I hit a roadblock at Step [X]:

[Clear description of the problem]

The plan expected [X] but I found [Y].

Options:
A) [Proposed solution]
B) [Alternative approach]
C) [Skip and continue]

What would you like to do?"

If NO roadblocks: Complete all steps, then proceed to Phase 4.

Phase 4: Quality Review

Goal: Ensure code is simple, DRY, elegant, and functionally correct

Actions:

1. Launch 3 code-reviewer agents in parallel with different focuses:

   • Simplicity/DRY/Elegance: Code quality and maintainability
   • Bugs/Correctness: Functional correctness and logic errors
   • Conventions/Abstractions: Project standards and patterns

2. Consolidate findings and identify highest severity issues

3. Present findings to user:

   "Code Review Results:
   
   High Priority Issues:
   1. [Issue] (file:line) - [why it matters]
   
   Medium Priority:
   1. [Issue] - [suggestion]
   
   What would you like to do?
   A) Fix high priority issues now
   B) Fix all issues
   C) Proceed without fixing"
   

4. Address issues based on user decision

Phase 5: Verification

Goal: Verify implementation meets requirements

Actions:

1. Go through acceptance criteria from the plan
2. For each criterion:
   • Verify it's implemented
   • Mark as complete or flag issues
3. Run any relevant tests
4. Present verification summary:

   "Acceptance Criteria:
   ✓ [Criterion 1]
   ✓ [Criterion 2]
   ✗ [Criterion 3] - [issue]"
   

5. Address any failed criteria with user

Phase 6: Completion

Goal: Wrap up and document

Actions:

1. Mark all todos complete
2. Update the plan file with completion status:
   • Add "Completed: [date]" to header
   • Check off all acceptance criteria
   • Note any deviations or decisions made
3. Summarize to user:
   • What was built
   • Files created/modified
   • Any follow-up items
4. Ask if user wants to commit the changes

Dialogue Patterns

Starting

"I'll execute the plan for [name].

Summary:
- [X] steps to implement
- Requirements: [REQ-IDs]
- Key files: [list]

I'll implement all steps and only stop if I hit a roadblock.
Ready to start?"

On Roadblock (STOP)

"I hit a roadblock at Step [X]:

[Clear description of problem]

The plan expected [X] but I found [Y].

Options:
A) [Proposed solution]
B) [Alternative approach]
C) [Skip and continue]

What would you like to do?"

After Roadblock Resolved

"Got it. Continuing with the plan..."
[Resume autonomous execution]

Code Review Results

"Code Review Results:

High Priority Issues:
1. Missing error handling in [file:line]
2. Potential memory leak in [file:line]

Medium Priority:
1. Could simplify [logic] in [file]
2. Consider extracting [component]

All tests pass. Code follows project conventions.

What would you like to do?
A) Fix high priority issues now
B) Fix all issues
C) Proceed without fixing"

Completing (all steps done)

"Implementation complete!

Steps completed: [X/X]

Created:
- [new files]

Modified:
- [changed files]

Acceptance Criteria: [X/Y] passing
Code Review: [X] issues fixed

Want me to commit these changes?"

Red Flags - Stop and Discuss

• File doesn't exist that plan references
• Pattern changed since planning
• Step seems larger than expected
• Acceptance criterion can't be verified
• Implementation conflicts with existing code
• User seems unsure about a change
• Code reviewer finds critical issues

Handling Deviations

When something doesn't match the plan:

1. Stop immediately
2. Explain what's different
3. Propose options
4. Document the decision
5. Update plan file if significant