implementation-planner

name	implementation-planner
description	Creates detailed implementation plans after requirements are clarified. Use when user says "plan this", "how should I implement", or after requirements-clarifier skill has gathered context. Breaks down work into steps with dependencies and complexity estimates.
user-invocable	true
disable-model-invocation	false

Implementation Planner

Create structured implementation plans that guide development from requirements to working code.

When to Use

Activate when:

• User says "plan this" or "create a plan"
• Requirements have been clarified
• Complex tasks need decomposition
• User asks "how should I implement this?"
• Before starting multi-file or multi-step work

Prerequisites

Don't plan until:

• ✅ Requirements are clear (problem, users, success criteria)
• ✅ Constraints are known (timeline, scope, tech choices)
• ✅ Edge cases are identified
• ✅ Dependencies are understood

If requirements unclear, activate requirements-clarifier skill first.

Planning Framework

Step 1: Define Success Criteria

Clear success criteria:

1. What does "done" look like?
2. How will we verify it works?
3. What are the acceptance criteria?

Example:

Success Criteria:
- User can authenticate with email/password
- JWT tokens expire after 24 hours
- Refresh tokens work for 30 days
- All tests pass
- No security vulnerabilities detected

Step 2: Identify Components

Identify what needs to be created/modified:

Files:
- src/auth/auth.service.ts (new)
- src/auth/auth.controller.ts (new)
- src/auth/jwt.strategy.ts (new)
- src/auth/refresh-token.strategy.ts (new)
- src/main.ts (modify - add auth module)

Dependencies:
- @nestjs/jwt, @nestjs/passport, passport-jwt

Step 3: Break Down Tasks

Create ordered task list:

Phase 1: Foundation (30 min)
├─ [1.1] Install dependencies (5 min)
├─ [1.2] Create auth module structure (10 min)
└─ [1.3] Configure JWT module (15 min)

Phase 2: Core Authentication (45 min)
├─ [2.1] Implement auth service (20 min)
├─ [2.2] Create JWT strategy (15 min)
└─ [2.3] Add refresh token logic (10 min)

Phase 3: API Endpoints (30 min)
├─ [3.1] Create auth controller (20 min)
└─ [3.2] Add validation (10 min)

Phase 4: Testing & Verification (30 min)
├─ [4.1] Write unit tests (15 min)
├─ [4.2] Test authentication flow (10 min)
└─ [4.3] Security review (5 min)

Total estimated time: 2 hours 15 min

Step 4: Identify Dependencies

Task dependencies:

1.2 depends on 1.1 (need dependencies installed)
2.1 depends on 1.3 (need JWT configured)
3.1 depends on 2.1 and 2.2 (need service + strategy)
4.1 depends on 3.1 (need controller to test)

Step 5: Identify Risks & Edge Cases

Potential risks:

Risk: JWT secret management
Mitigation: Use environment variables, document setup

Risk: Token expiration timing
Mitigation: Implement refresh token rotation

Edge cases:
- User logs out before token expires
- Token stolen mid-session
- Refresh token expires during active session

Step 6: Define Verification Steps

How to verify completion:

✅ Tests pass: npm test
✅ Can authenticate: curl /auth/login
✅ Token validates: JWT decodes correctly
✅ Refresh works: Can get new access token
✅ No security issues: Run security scan

Plan Template

Use this structure for all plans:

# Implementation Plan: [Feature Name]

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

## Success Criteria
- [ ] Criterion 1
- [ ] Criterion 2
- [ ] Criterion 3

## Components
| File | Type | Purpose |
|------|------|---------|
| path/to/file | New/Modify | Description |

## Tasks

### Phase 1: [Phase Name] (Estimated: XX min)
- [1.1] Task description
- [1.2] Task description

### Phase 2: [Phase Name] (Estimated: XX min)
- [2.1] Task description (depends on 1.x)
- [2.2] Task description

## Dependencies
- Task 1.2 depends on 1.1
- Task 2.1 depends on 1.3
- [Full dependency graph]

## Risks & Mitigations
| Risk | Mitigation |
|------|-----------|
| Risk description | Mitigation strategy |

## Verification
- [ ] Test 1
- [ ] Test 2
- [ ] Manual verification step

## Notes
[Additional context, considerations, alternatives]

Complexity Indicators

When estimating complexity, consider:

Factor	Simple	Complex
Files	1-2 files	5+ files or multiple directories
Dependencies	No new deps	New packages, external APIs
Integration	Standalone	Integrates with existing system
Data	No persistence	Database, state management
Testing	Obvious behavior	Edge cases, error scenarios
Security	No security concerns	Auth, permissions, sensitive data

Integration with Requirements Clarifier

Workflow:

1. User makes vague request
   ↓
2. requirements-clarifier activates
   ↓
3. Questions asked, requirements gathered
   ↓
4. implementation-planner activates
   ↓
5. Detailed plan created
   ↓
6. User approves plan
   ↓
7. Implementation begins

Example conversation:

User: "Add user authentication"

Claude (requirements-clarifier):
I want to make sure I implement the right solution:
1. What auth methods? (email/password, OAuth?)
2. Security requirements? (JWT, sessions?)
3. Existing auth system?

User: "Email/password, JWT tokens, new system"

Claude (implementation-planner):
Great, I'll create a plan:

[Detailed plan with phases, tasks, estimates]

Does this plan look good? I can adjust if you'd prefer different approach.

Anti-Patterns

Don't

• ❌ Plan without clarifying requirements first
• ❌ Create overly detailed plans (analysis paralysis)
• ❌ Ignore time estimates
• ❌ Skip risk identification
• ❌ Plan in isolation (incorporate user feedback)

Do

• ✅ Clarify before planning
• ✅ Focus on structure, not every line of code
• ✅ Provide time estimates
• ✅ Identify risks early
• ✅ Get user approval on plan
• ✅ Leave room for adjustments during implementation

Quick Reference

Prerequisites: Requirements clear, constraints known Structure: Success criteria → Components → Tasks → Dependencies → Risks → Verification Format: Markdown checklist with phases Estimation: Consider files, dependencies, integration, data, testing, security Next step: Get user approval, then implement

---

Note: This skill works best after requirements-clarifier. Always clarify requirements first, then plan.