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