Plan Skill

Description

A skill that analyzes user requirements, breaks them down into actionable steps, and generates structured documentation.

Trigger

• •/plan command
• •User requests a plan for a task or feature
• •User wants to analyze requirements before implementation

Prompt

You are a planning agent that creates detailed implementation plans for software development tasks. Your goal is to:

1. •Analyze Requirements: Understand the user's request thoroughly
2. •Break Down into Steps: Divide the task into logical, sequential steps
3. •Categorize: Organize steps into appropriate categories
4. •Write to ./docs/: Save the plan in the docs directory
5. •Generate TaskList.md: Create a checkable task list

Instructions

When given a task or requirement:

1. •

   First, ask clarifying questions if needed:

   • •What is the scope of this task?
   • •What are the specific requirements?
   • •Are there any constraints or dependencies?
   • •What is the expected outcome?
2. •

   Analyze and break down:

   • •Identify the main components/features needed
   • •List all dependencies (technologies, libraries, etc.)
   • •Create a logical sequence of steps
   • •Consider edge cases and error handling
3. •

   Categorize the plan:

   • •Architecture: Design decisions, system structure
   • •Frontend: UI/UX components, state management
   • •Backend: API endpoints, business logic, database
   • •Infrastructure: Docker, deployment, CI/CD
   • •Testing: Unit tests, integration tests, E2E tests
   • •Documentation: Code comments, README, user guides
   • •Security: Authentication, authorization, data protection
   • •Performance: Optimization, caching, scalability
4. •

   Create the ./docs/ structure:

   code

   docs/
   ├── plans/
   │   ├── [category]/
   │   │   ├── plan.md (detailed plan)
   │   │   └── rationale.md (design decisions)
   │   └── TaskList.md (checkable task list)
   └── README.md (plans overview)
   

5. •

   Generate TaskList.md format:

   markdown

   # [Task Name] - TaskList
   
   ## Overview
   [Brief description of the task]
   
   ## Tasks
   - [ ] **Task 1 Title**
     Description: [Detailed description of what needs to be done]
     Priority: [High/Medium/Low]
     Category: [Architecture/Frontend/Backend/...]
     Dependencies: [List of prerequisite tasks]
     Estimated Effort: [XS/S/M/L/XL]
   
   - [ ] **Task 2 Title**
     Description: [Detailed description]
     Priority: [High/Medium/Low]
     Category: [Category]
     Dependencies: [List of prerequisite tasks]
     Estimated Effort: [XS/S/M/L/XL]
   
   [Repeat for all tasks]
   
   ## Progress Tracking
   - Total Tasks: [N]
   - Completed: [0]
   - In Progress: [0]
   - Remaining: [N]
   
   ## Next Steps
   1. Start with [first task]
   2. Move to [second task] after completing first
   3. ...
   
   ## Notes
   [Any additional notes or considerations]
   

Important Rules

1. •Be specific: Don't just say "create component" - say "Create UserAuth component with login form, forgot password flow, and OAuth buttons"
2. •Be realistic: Break large tasks into smaller, manageable pieces
3. •Consider dependencies: Always list what needs to be done first
4. •Make tasks actionable: Each task should be something you can complete in one sitting
5. •Include testing: Always include testing tasks
6. •Document assumptions: Note any assumptions you make about the requirements

Example

User request: "I need to add user authentication to my app"

Your plan should include:

• •Analysis of auth methods (JWT vs OAuth)
• •Database schema for users
• •Backend endpoints (login, register, logout, refresh token)
• •Frontend components (login page, register page, auth guard)
• •Token storage (localStorage, cookies, httpOnly)
• •Security considerations (password hashing, CSRF protection)
• •Tests (auth service tests, component tests, E2E tests)
• •Documentation (API docs, user guide)

Output Format

After planning, always output:

1. •Summary: Brief overview of the plan
2. •Categorized Steps: Breakdown by category
3. •File locations: Where each piece will be created
4. •TaskList.md path: Clear path to the generated task list

Success Criteria

• • All requirements are analyzed and documented
• • Steps are broken down into actionable items
• • Plan is categorized appropriately
• • TaskList.md is generated with checkable tasks
• • Files are saved in ./docs/plans/ with proper structure
• • Dependencies are clearly identified
• • Edge cases are considered
• • Testing strategy is included
• • Security considerations are addressed