iterate-plan

name: iterate-plan description: Iterate on existing implementation plans with thorough research and updates. Use when you need to modify, expand, or refine an existing plan based on new information or feedback. compatibility: Designed for GitHub Copilot CLI metadata: author: humanlayer version: "1.0" original-source: https://github.com/humanlayer/humanlayer

Iterate Implementation Plan

You are tasked with updating existing implementation plans based on user feedback. You should be skeptical, thorough, and ensure changes are grounded in actual codebase reality.

Initial Response

When this skill is invoked:

1. Parse the input to identify:

   • Plan file path
   • Requested changes/feedback

2. Handle different input scenarios:

   If NO plan file provided:

   I'll help you iterate on an existing implementation plan.
   
   Which plan would you like to update? Please provide the path to the plan file.
   

   Wait for user input.

   If plan file provided but NO feedback:

   I've found the plan at [path]. What changes would you like to make?
   
   For example:
   - "Add a phase for migration handling"
   - "Update the success criteria to include performance tests"
   - "Adjust the scope to exclude feature X"
   - "Split Phase 2 into two separate phases"
   

   Wait for user input.

   If BOTH plan file AND feedback provided:

   • Proceed immediately to Step 1

Process Steps

Step 1: Read and Understand Current Plan

1. Read the existing plan file COMPLETELY:

   • Understand the current structure, phases, and scope
   • Note the success criteria and implementation approach

2. Understand the requested changes:

   • Parse what the user wants to add/modify/remove
   • Identify if changes require codebase research
   • Determine scope of the update

Step 2: Research If Needed

Only spawn research tasks if the changes require new technical understanding.

If the user's feedback requires understanding new code patterns or validating assumptions:

1. Create a research todo list using update_todo

2. Spawn parallel sub-tasks for research: Use the task tool with explore agent type for:

   • Finding relevant files
   • Understanding implementation details
   • Finding similar patterns

3. Read any new files identified by research:

   • Read them FULLY into the main context
   • Cross-reference with the plan requirements

4. Wait for ALL sub-tasks to complete before proceeding

Step 3: Present Understanding and Approach

Before making changes, confirm your understanding:

Based on your feedback, I understand you want to:
- [Change 1 with specific detail]
- [Change 2 with specific detail]

My research found:
- [Relevant code pattern or constraint]
- [Important discovery that affects the change]

I plan to update the plan by:
1. [Specific modification to make]
2. [Another modification]

Does this align with your intent?

Get user confirmation before proceeding.

Step 4: Update the Plan

1. Make focused, precise edits to the existing plan:

   • Use the edit tool for surgical changes
   • Maintain the existing structure unless explicitly changing it
   • Keep all file:line references accurate
   • Update success criteria if needed

2. Ensure consistency:

   • If adding a new phase, ensure it follows the existing pattern
   • If modifying scope, update "What We're NOT Doing" section
   • If changing approach, update "Implementation Approach" section
   • Maintain the distinction between automated vs manual success criteria

3. Preserve quality standards:

   • Include specific file paths and line numbers for new content
   • Write measurable success criteria
   • Keep language clear and actionable

Step 5: Review

1. Present the changes made:

   I've updated the plan at [path]
   
   Changes made:
   - [Specific change 1]
   - [Specific change 2]
   
   The updated plan now:
   - [Key improvement]
   - [Another improvement]
   
   Would you like any further adjustments?
   

2. Be ready to iterate further based on feedback

Important Guidelines

1. Be Skeptical: Don't blindly accept change requests that seem problematic
2. Research First: Always verify technical details before updating the plan
3. Preserve Context: Keep existing good content when making updates
4. Think Holistically: Consider how changes affect other phases
5. Iterate Quickly: Small focused updates are better than large rewrites