Create Plans

You are now executing the planner-create skill. Follow these steps immediately:

Agent Reference: This skill uses the plan-creator agent (@agents/plan-creator.md) to perform the actual plan creation work.

Template Reference: The default plan template is available at @templates/plan.TEMPLATE.md

Standards Reference: Convention files are available at @templates/standards/

Step 1: Read Smart Parallelism Configuration

Read the user's project configuration to understand the plan creation strategy:

•
Read configuration file: Read plans/planner.config.json
- •
  If successful and valid JSON:
  - •Parse: smart_parallelism
  - •Store the value and proceed to Step 2
•
Use default: If file not found or invalid:
- •smart_parallelism = false

This affects dependency creation:

•true: Aggressive parallelization (fewer dependencies, more parallel plans)
•false: Conservative dependencies (safer sequential execution)

Step 2: Detect Plan Template

Check for a plan template to ensure consistent plan structure:

•
Check user's project first: Use Glob to check if plans/plan.TEMPLATE.md exists
- •If found: Read the file using Read tool and store as template_content
- •Set template_source = "project"
•
Fall back to plugin default: If not found in project:
- •Read the plugin's default template: templates/plan.TEMPLATE.md from plugin directory
- •Store as template_content
- •Set template_source = "default"
•
Check for convention files: Use Glob to check if plans/standards/*.md exists
- •If found: Store paths as convention_files
- •If not found: Agent will use built-in conventions

Template affects plan structure:

•Plans will follow the template's section structure
•Placeholders ({{PLACEHOLDER}}) guide content placement
•Convention @mentions are preserved for reference

Step 3: Analyze Existing Plans

Understand the current project structure:

•Use Glob: plans/*.plan.md (only plan files, not specs or templates)
•Store as existing_plans for context
•
Detect naming conventions:
- •Prefix patterns (e.g., "auth-", "api-")
- •Numbering schemes (e.g., "01-", "02-")
- •Naming styles (e.g., kebab-case, descriptive names)

Step 4: Spawn Plan-Creator Agent

CRITICAL: You MUST spawn the plan-creator agent now using the Task tool.

This is NOT optional - the agent performs the actual plan creation work.

Use the Task tool with these exact parameters:

code

Task tool parameters:
  description: "Create plans for: [short summary]"
  subagent_type: "planner:plan-creator"
  prompt: |
    description: "[user's full feature description]"
    prefix: "[provided prefix or inferred from description]"

    smart_parallelism: [true/false from Step 1]

    template_source: [project/default]
    template_content: |
      [TEMPLATE CONTENT IF FROM PROJECT, OR "use built-in default"]

    convention_files:
      [LIST OF CONVENTION FILE PATHS, OR "use built-in conventions"]

    existing_plans:
    [LIST OF EXISTING PLAN FILES]

    naming_conventions:
    [DETECTED PATTERNS FROM EXISTING PLANS]

    IMPORTANT: Follow the template structure when creating plans.
    Include @mentions to convention files in the Standards section.

    BEGIN CREATION.

Important: Do NOT just gather information - you MUST call the Task tool to spawn the agent.

Step 5: Report Results

After the agent completes, show the creation result:

code

════════════════════════════════════════
Plans Created Successfully

Feature: [feature description]
Prefix: [prefix used]
Plans created: [N]
Template: [project custom / plugin default]

Plan Execution Order:
Round 1 (parallel): [list of independent plans]
Round 2: [plans depending on Round 1]
Round 3: [plans depending on Round 2]
...

Files created:
- plans/[plan-01].plan.md
- plans/[plan-02].plan.md
- plans/[plan-03].plan.md
- Updated plans/PROGRESS.md

To execute:
  /planner:batch --prefix=[prefix]
  OR
  /planner:batch [plan-01].plan.md [plan-02].plan.md ...

Smart Parallelism: [enabled/disabled]
════════════════════════════════════════

If extra sections were needed:

code

Note: The following sections were added beyond the template:
- [section name]: [reason]

Reference Information

What This Skill Does

When creating plans for a feature, this skill:

•Reads Configuration: Gets smart parallelism setting from plans/planner.config.json
•Detects Templates: Checks for custom template or uses plugin default
•Analyzes Requirements: Breaks down the feature into manageable plans
•Creates Plan Files: Each plan is self-contained (~40% context usage)
•Determines Dependencies: Identifies sequential vs. parallel execution needs
•Updates Tracking: Adds new plans to plans/PROGRESS.md

Key Features

•Template Support: Uses project template or plugin default for consistent structure
•Convention References: Includes @mentions to coding standards
•Smart Breakdown: Splits complex features into small, focused plans
•Dependency Analysis: Identifies which plans must run sequentially vs. in parallel
•Context Optimization: Each plan uses ~40% context to leave room for implementation
•Naming Conventions: Follows existing project patterns or creates sensible defaults
•Automatic Tracking: Updates PROGRESS.md with all new plans
•Configurable Strategy: Uses smart parallelism setting for dependency decisions

Template System

The planner uses a template system for consistent plan creation:

Project Template (plans/plan.TEMPLATE.md):

•Custom template for your project
•Created via /planner:eject-template plan
•Takes priority over plugin default

Plugin Default Template:

•Built into the plan-creator agent
•Used when no project template exists
•Includes all standard sections

Convention Files (plans/standards/*.md):

•Referenced via @templates/standards/[name].md
•Provide coding standards and best practices
•Can be customized per project

Smart Parallelism

The smart_parallelism setting in plans/planner.config.json affects how aggressively plans are parallelized:

When true (Aggressive):

•Minimizes dependencies
•Maximizes parallel execution
•Faster overall execution
•Requires careful conflict management

When false (Conservative):

•More sequential dependencies
•Safer execution order
•Slower but more predictable
•Better for complex interdependencies

Plan Structure

Each created plan follows the template structure and includes:

markdown

# Configuration

depends_on: "prefix-00-setup.md"

# Plan: prefix-01-database.md

## Objective

[What this plan accomplishes]

## Context

[Relevant codebase context]

## Implementation Steps

### Step 1: [Title]

[Details]

## Files to Modify

| File | Action | Description |
| ---- | ------ | ----------- |

## Standards & Conventions

@templates/standards/coding-style.md
@templates/standards/error-handling.md

## Testing Instructions

[How to verify the changes work]

## Completion

Update plans/PROGRESS.md to mark this plan as COMPLETED.

Example

code

User: Create plans for user authentication with JWT

Step 1: Read smart_parallelism
→ Found: smart_parallelism: true

Step 2: Detect template
→ Found: plans/plan.TEMPLATE.md (project custom)
→ Found: plans/standards/*.md (8 convention files)

Step 3: Analyze existing plans
→ Found naming pattern: "feature-NN-name.plan.md"
→ Detected numbering scheme: 00, 01, 02, etc.

Step 4: Spawn plan-creator agent
→ Passes config, description, template, and conventions

Agent creates:
→ auth-00-setup.plan.md (no deps)
→ auth-01-database.plan.md (depends on: 00)
→ auth-02-jwt-service.plan.md (depends on: 01)
→ auth-03-api.plan.md (depends on: 02)
→ auth-04-tests.plan.md (no deps - can run in parallel)

Updates PROGRESS.md:
→ Added 5 new plans

Report:
→ Round 1: auth-00-setup.plan.md, auth-04-tests.plan.md
→ Round 2: auth-01-database.plan.md
→ Round 3: auth-02-jwt-service.plan.md
→ Round 4: auth-03-api.plan.md

Suggested command: /planner:batch --prefix=auth