Plan Feature

If any prerequisites are missing, request completion of the research phase first.

Process

Once prerequisites are verified:

1. Read Planning Documents: Read all planning documents from _features/{feature_name}/planning/ to understand:

   • What systems will be impacted
   • What new systems need to be created
   • The selected solution approach and rationale
   • Any interface requirements or dependencies

2. Read Feature File: Read the feature file from _features/{feature_name}.md to extract:

   • Background context
   • Specific task requirements
   • Testing requirements

3. Read Relevant Context: Read relevant files from @docs/AI_CONTEXT/ based on the feature scope:

   • Always read: AI_CONTEXT_QUICK_REFERENCE.md and AI_CONTEXT_REPOSITORY.md
   • Read service-specific context files if the feature affects data loading, search engine, API services, or UI
   • Always read: AI_CONTEXT_PATTERNS.md for code patterns and conventions

4. Create Plan Directory Structure: Create the plan directory structure:

   • Ensure _features/{feature_name}/plans/master/ directory exists
   • This directory will contain all plan documents

5. Create Implementation Plan Documents: Create comprehensive plan documents in _features/{feature_name}/plans/master/ that cover all aspects of the implementation. The plan should consist of multiple detailed documents:

   a. overview.md - Executive summary of the plan:

   • What the feature accomplishes and its purpose
   • High-level objectives and success criteria
   • Key requirements and constraints
   • Relationship to existing systems

   b. architecture.md - System architecture and design:

   • Overall system design and structure
   • Component breakdown and responsibilities
   • Data flow and interactions
   • Design patterns and principles to be used
   • References to existing architecture patterns from AI_CONTEXT_PATTERNS.md

   c. interfaces.md - Interface definitions and contracts:

   • All public interfaces that will be created or modified
   • Function/method signatures with type hints
   • Data models and their structure
   • Interface contracts and expected behavior
   • Dependencies between interfaces

   d. implementation.md - Implementation approach and order:

   • Step-by-step implementation sequence
   • Prioritization: models & interfaces first, then implementation code
   • Files to create/modify with specific changes needed
   • Code organization and structure
   • Dependency injection requirements
   • Implementation dependencies and order

   e. testing.md - Test strategy and approach:

   • Test strategy following TDD principles
   • Which tests to write first (before implementation)
   • Test cases for each component
   • Integration test requirements
   • Validation steps to verify implementation works correctly
   • Black box testing approach (validate functionality, not internal behavior)

   f. dependencies.md - Dependencies and requirements:

   • External dependencies (packages, libraries)
   • Internal dependencies (other modules, systems)
   • System requirements
   • Environment setup requirements
   • Configuration requirements

   g. documentation.md - Documentation requirements:

   • What documentation needs to be created
   • What documentation needs to be updated
   • Code documentation requirements (docstrings, comments)
   • User-facing documentation updates
   • Developer documentation updates

6. Ensure Plan Completeness: Verify that the plan documents:

   • Cover all aspects needed for implementation
   • Are detailed enough for the task-list command to review and create prioritized tasks
   • Include clear interface definitions between components
   • Prioritize models and interfaces before implementation code
   • Follow TDD approach (tests before implementation)
   • Include all necessary information for task decomposition

7. Validate Plan: Ensure the plan:

   • Adheres to @.cursor/rules/development_practices.mdc (TDD, models first, dependency injection, etc.)
   • Follows @.cursor/rules/content_length.mdc - if any document would exceed limits, split it into multiple documents
   • Includes clear interface definitions between components
   • Prioritizes models and interfaces before implementation code
   • Is comprehensive enough for task decomposition
   • References relevant files and existing code patterns

Plan Document Requirements

Each plan document should:

• Be written in Markdown format
• Be self-contained but reference other plan documents where appropriate
• Include specific, actionable details (not vague descriptions)
• Reference existing code patterns and conventions from AI_CONTEXT_PATTERNS.md
• Include file paths and specific locations for changes
• Be detailed enough that the task-list command can:
  • Identify high-level tasks and their interdependence
  • Determine clear interface requirements between components
  • Create a prioritized list of tasks that, when completed, fully implement the plan

Output

The plan should be stored in _features/{feature_name}/plans/master/ with the following structure:

_features/{feature_name}/plans/master/
  ├── overview.md
  ├── architecture.md
  ├── interfaces.md
  ├── implementation.md
  ├── testing.md
  ├── dependencies.md
  └── documentation.md

The plan documents should be comprehensive enough for the task-list command to review and create a prioritized list of tasks that, once completed, will ensure the plan is fully implemented.

Scratchpad

If the orchestrator passes scratchpad path _features/{feature_name}/scratchpad.md and content, read it for context from the Research phase (impacted systems, chosen approach). After completing the plan, include a brief summary of key decisions (architecture, interfaces) in your output so the orchestrator can add it to the scratchpad Notes.

Subagent Usage

Must use mcp_task with subagent_type "generalPurpose" for context-heavy plan synthesis. This isolates document creation from the main conversation. Do not skip subagent invocation.