Create Implementation Plan

Activation

When this skill is triggered, ALWAYS display this banner first:

╭─────────────────────────────────────────────────────────────╮
│  📐 SKILL ACTIVATED: create-implementation-plan             │
├─────────────────────────────────────────────────────────────┤
│  Task: [ticket/feature being planned]                       │
│  Action: Research → Design → Plan → Review                  │
│  Output: Phased implementation plan with success criteria   │
╰─────────────────────────────────────────────────────────────╯

You are tasked with creating detailed implementation plans through an interactive, iterative process. Be skeptical, thorough, and work collaboratively to produce high-quality technical specifications.

When to Use

This skill activates when:

• •"create a plan for"
• •"plan the implementation of"
• •"how should we build"
• •"design the approach for"
• •Need structured planning before coding

Process Steps

Step 1: Context Gathering & Initial Analysis

1. •

   Read all mentioned files completely:

   • •Ticket files, research documents, related plans
   • •Any JSON/data files mentioned
   • •Read files FULLY - never partially
2. •

   Research the codebase:

   • •Find all files related to the ticket/task
   • •Understand how current implementation works
   • •Find any existing documents about this feature
   • •Trace data flow and key functions
3. •

   Present informed understanding:

   code

   Based on the ticket and my research of the codebase, I understand we need to [accurate summary].
   
   I've found that:
   - [Current implementation detail with file:line reference]
   - [Relevant pattern or constraint discovered]
   - [Potential complexity or edge case identified]
   
   Questions that my research couldn't answer:
   - [Specific technical question that requires human judgment]
   - [Business logic clarification]
   

Step 2: Research & Discovery

After getting initial clarifications:

1. •

   Verify any corrections: Don't just accept corrections - verify in the code

2. •

   Find similar patterns: Look for features we can model after

3. •

   Identify integration points: Where does this connect with existing code?

4. •

   Present findings and design options:

   code

   Based on my research, here's what I found:
   
   **Current State:**
   - [Key discovery about existing code]
   - [Pattern or convention to follow]
   
   **Design Options:**
   1. [Option A] - [pros/cons]
   2. [Option B] - [pros/cons]
   
   Which approach aligns best with your vision?
   

Step 3: Plan Structure Development

Once aligned on approach:

Here's my proposed plan structure:

## Overview
[1-2 sentence summary]

## Implementation Phases:
1. [Phase name] - [what it accomplishes]
2. [Phase name] - [what it accomplishes]
3. [Phase name] - [what it accomplishes]

Does this phasing make sense? Should I adjust the order or granularity?

Step 4: Detailed Plan Writing

Always save the plan to docs/plans/YYYY-MM-DD_<slug>.md with code snippets and a checklist so implementation can be tracked.

Use this template structure:

# [Feature/Task Name] Implementation Plan

## Overview
[Brief description of what we're implementing and why]

## Current State Analysis
[What exists now, what's missing, key constraints discovered]

## Desired End State
[Specification of the desired end state and how to verify it]

### Key Discoveries:
- [Important finding with file:line reference]
- [Pattern to follow]
- [Constraint to work within]

## What We're NOT Doing
[Explicitly list out-of-scope items to prevent scope creep]

## Implementation Approach
[High-level strategy and reasoning]

## Phase 1: [Descriptive Name]

### Overview
[What this phase accomplishes]

### Changes Required:

#### 1. [Component/File Group]
**File**: `path/to/file.ext`
**Changes**: [Summary of changes]

```[language]
// Specific code to add/modify

Success Criteria:

• • Tests pass
• • Type checking passes
• • Linting passes
• • Manual verification: [specific check]

Phase 2: [Descriptive Name]

[Similar structure...]

References

• •Original ticket: [link/path]
• •Related research: [link/path]
• •Similar implementation: [file:line]

### Step 5: Review

1. **Present the draft plan** and ask for feedback
2. **Iterate based on feedback** - adjust phases, success criteria, scope
3. **Continue refining** until satisfied

## Important Guidelines

1. **Be Skeptical**: Question vague requirements, identify issues early, verify with code
2. **Be Interactive**: Don't write the full plan in one shot, get buy-in at each step
3. **Be Thorough**: Read all context files completely, include specific file paths and line numbers
4. **Be Practical**: Focus on incremental, testable changes, consider edge cases
5. **No Open Questions**: If you encounter unresolved questions, STOP and clarify before finalizing