---

name: feature-planner description: Creates phase-based feature plans with TDD workflow and quality gates. Use for code projects requiring structured development approach. Keywords: plan, planning, phases, TDD, test-driven, roadmap.

Feature Planner

Phase-based development planning with TDD workflow and quality gates (v1.0.0)

Version: 1.0.0 | Author: El Fenomeno | Last Updated: 2025-12-24

Based on: anthropic-agent-skills feature-planner (adapted for our system)

---

트리거 키워드

계획, 플래닝, 피처 계획, 기능 계획, 단계별 계획, TDD, 테스트 주도 개발, 로드맵, 페이즈 계획, feature plan, phase planning, implementation plan, development roadmap, structured planning

---

자동 활성화 조건

Claude는 다음 상황에서 이 스킬 사용을 자동 제안합니다:

1. "X 기능 구현해줘" (4시간+ 작업 예상) → "feature-planner 스킬로 계획 먼저 세울까요?"
2. "X 개발 계획 세워줘" → 자동 활성화
3. 코드 프로젝트에서 복잡한 기능 요청 → "단계별 TDD 계획 필요해 보입니다. feature-planner 사용할까요?"
4. pytest/jest 환경에서 새 기능 → TDD 워크플로우 제안

사용 예시

CopyUser: "인증 시스템 구현해줘"
Claude: "이 기능은 4시간 이상 걸릴 것 같습니다.
        feature-planner 스킬로 단계별 TDD 계획을 먼저 세울까요?"

User: "NVDA 분석 계획 세워줘"
→ 이건 코드 프로젝트가 아니므로 feature-planner 대신 일반 계획 제안

---

Purpose

Generate structured, phase-based plans where:

• Each phase delivers complete, runnable functionality
• Quality gates enforce validation before proceeding
• User approves plan before any work begins
• Progress tracked via markdown checkboxes
• Each phase is 1-4 hours maximum

When to Use

• Python projects with pytest
• JavaScript/TypeScript with Jest
• Any code project with test framework
• Features requiring structured development (>4 hours work)

When NOT to Use

• Document-only projects
• Quick bug fixes (<1 hour)
• Simple refactoring without behavioral changes

Planning Workflow

Step 1: Requirements Analysis

1. Read relevant files to understand codebase architecture
2. Identify dependencies and integration points
3. Assess complexity and risks
4. Determine appropriate scope (small/medium/large)

Step 2: Phase Breakdown with TDD Integration

Break feature into 3-7 phases where each phase:

• Test-First: Write tests BEFORE implementation
• Delivers working, testable functionality
• Takes 1-4 hours maximum
• Follows Red-Green-Refactor cycle
• Has measurable test coverage requirements
• Can be rolled back independently
• Has clear success criteria

Phase Structure:

• Phase Name: Clear deliverable
• Goal: What working functionality this produces
• Test Strategy: What test types, coverage target, test scenarios
• Tasks (ordered by TDD workflow):
  1. RED Tasks: Write failing tests first
  2. GREEN Tasks: Implement minimal code to make tests pass
  3. REFACTOR Tasks: Improve code quality while tests stay green
• Quality Gate: TDD compliance + validation criteria
• Dependencies: What must exist before starting
• Coverage Target: Specific percentage or checklist for this phase

Step 3: Plan Document Creation

Use plan-template.md to generate: docs/planning/PLAN_<feature-name>.md

Include:

• Overview and objectives
• Architecture decisions with rationale
• Complete phase breakdown with checkboxes
• Quality gate checklists
• Risk assessment (see template reference)
• Rollback strategy per phase
• Progress tracking section
• Notes & learnings area

Step 4: User Approval

CRITICAL: Get explicit approval before proceeding.

Ask:

• "Does this phase breakdown make sense for your project?"
• "Any concerns about the proposed approach?"
• "Should I proceed with creating the plan document?"

Only create plan document after user confirms approval.

Step 5: Document Generation

1. Create docs/planning/ directory if not exists (already exists in our project)
2. Generate plan document with all checkboxes unchecked
3. Add clear instructions in header about quality gates
4. Inform user of plan location and next steps

Quality Gate Standards

Each phase MUST validate these items before proceeding to next phase:

Build & Compilation:

• Project builds/compiles without errors
• No syntax errors

Test-Driven Development (TDD):

• Tests written BEFORE production code
• Red-Green-Refactor cycle followed
• Unit tests: >=80% coverage for business logic
• Integration tests: Critical user flows validated
• Test suite runs in acceptable time (<5 minutes)

Testing:

• All existing tests pass
• New tests added for new functionality
• Test coverage maintained or improved

Code Quality:

• Linting passes with no errors
• Type checking passes (if applicable)
• Code formatting consistent

Functionality:

• Manual testing confirms feature works
• No regressions in existing functionality
• Edge cases tested

Security & Performance:

• No new security vulnerabilities
• No performance degradation

Documentation:

• Code comments updated
• Documentation reflects changes

Integration with Project Gate Check

This skill integrates with the project's Gate Check system:

Documentation Gate (always required):

• CHANGELOG updated
• ACTIVE_TASKS updated
• CLAUDE.md status current

Risk & Recovery Gate (for significant changes):

• Risk identified (at least 1 line)
• Rollback method documented
• Templates: docs/manuals/risk-assessment-template.md, docs/manuals/rollback-strategy-template.md

Phase completion triggers both gates as per .claude/rules/core-documents.md.

Phase Sizing Guidelines

Small Scope (2-3 phases, 3-6 hours total):

• Single component or simple feature
• Minimal dependencies
• Clear requirements
• Example: Add dark mode toggle, create new form component

Medium Scope (4-5 phases, 8-15 hours total):

• Multiple components or moderate feature
• Some integration complexity
• Database changes or API work
• Example: User authentication system, search functionality

Large Scope (6-7 phases, 15-25 hours total):

• Complex feature spanning multiple areas
• Significant architectural impact
• Multiple integrations
• Example: AI-powered search with embeddings, real-time collaboration

Risk Assessment

For each risk, document using docs/manuals/risk-assessment-template.md:

• Technical Risks: API changes, performance issues, data migration
• Dependency Risks: External library updates, third-party service availability
• Timeline Risks: Complexity unknowns, blocking dependencies
• Quality Risks: Test coverage gaps, regression potential

Specify: Probability (Low/Medium/High), Impact (Low/Medium/High), Mitigation Strategy.

Rollback Strategy

For each phase, document using docs/manuals/rollback-strategy-template.md:

• What code changes need to be undone
• Database migrations to reverse (if applicable)
• Configuration changes to restore
• Dependencies to remove

Test Specification Guidelines

Test-First Development Workflow

For Each Feature Component:

1. Specify Test Cases (before writing ANY code)

   • What inputs will be tested?
   • What outputs are expected?
   • What edge cases must be handled?
   • What error conditions should be tested?

2. Write Tests (Red Phase)

   • Write tests that WILL fail
   • Verify tests fail for the right reason
   • Run tests to confirm failure

3. Implement Code (Green Phase)

   • Write minimal code to make tests pass
   • Run tests frequently (every 2-5 minutes)
   • Stop when all tests pass

4. Refactor (Blue Phase)

   • Improve code quality while tests remain green
   • Extract duplicated logic
   • Improve naming and structure
   • Run tests after each refactoring step

Test Types

Unit Tests:

• Target: Individual functions, methods, classes
• Speed: Fast (<100ms per test)
• Coverage: >=80% of business logic

Integration Tests:

• Target: Interaction between components/modules
• Speed: Moderate (<1s per test)
• Coverage: Critical integration points

End-to-End (E2E) Tests:

• Target: Complete user workflows
• Speed: Slow (seconds to minutes)
• Coverage: Critical user journeys

Coverage Thresholds

Coverage Commands

Copy# Python
pytest --cov=src --cov-report=html

# JavaScript/TypeScript
jest --coverage

Test Documentation in Plan

In each phase, specify:

1. Test File Location: Exact path where tests will be written
2. Test Scenarios: List of specific test cases
3. Coverage Target: Percentage for this phase
4. Dependencies to Mock: What needs mocking/stubbing?

Progress Tracking Protocol

Add this to plan document header:

Copy**CRITICAL INSTRUCTIONS**: After completing each phase:
1. Check off completed task checkboxes
2. Run all quality gate validation commands
3. Verify ALL quality gate items pass
4. Update "Last Updated" date
5. Document learnings in Notes section
6. Only then proceed to next phase

DO NOT skip quality gates or proceed with failing checks

Supporting Files Reference

• plan-template.md - Complete plan document template

---

버전 이력

• v1.0.0 (2025-12-24): 초기 버전
  • anthropic-agent-skills feature-planner 기반
  • 우리 시스템 통합 (Gate Check, Risk/Rollback 템플릿)
  • 경로 수정: docs/planning/
  • 트리거 키워드 및 자동 활성화 조건 추가

---

Version: 1.0.0 | Last Updated: 2025-12-24