Plan

Creates structured, research-backed implementation plans in your plans/ directory. Formerly split across /ck:plan --fast, /ck:plan --hard, and other commands—now consolidated into one skill.

What This Skill Does

Planning produces complete project blueprints: plan.md overview plus phase-XX-*.md files with implementation steps, file ownership, success criteria, and risk assessment. Plans persist across sessions and drive task hydration.

Workflow Modes

Flag	Mode	Research	Red Team	Validation	Cook Flag
`--auto`	Auto-detect	Follows mode	Follows mode	Follows mode	`--auto`
`--fast`	Fast	Skip	Skip	Skip	`--auto`
`--hard`	Hard	2 researchers	Yes	Optional	(none)
`--parallel`	Parallel	2 researchers	Yes	Optional	`--parallel`
`--two`	Two approaches	2+ researchers	After selection	After selection	(none)

Add --no-tasks to any mode to skip task hydration after plan creation.

Usage

/ck:plan <requirements> [flags]

Examples:

/ck:plan "add Stripe subscription billing" --fast
/ck:plan "migrate from REST to GraphQL" --hard
/ck:plan "implement real-time notifications + presence" --parallel
/ck:plan "redesign auth system" --two
/ck:plan "scaffold new microservice" --auto --no-tasks

Workflow Process

Pre-Creation Check → Mode Detection → Research Phase
→ Codebase Analysis → Plan Documentation → Red Team Review
→ Validation → Hydrate Tasks → Context Reminder

Pre-Creation Check — scan existing plans to avoid duplication
Mode Detection — interpret flags or auto-select based on task complexity
Research Phase — spawn parallel researchers (hard/parallel/two modes)
Codebase Analysis — scout relevant files, patterns, dependencies
Plan Documentation — write plan.md + phase files
Red Team Review — adversarial critique of the plan (hard/parallel)
Validation — confirm plan is implementable
Hydrate Tasks — create session-scoped tasks from phase todo items
Context Reminder — remind active plan for downstream tools

Plan Output Structure

plans/
└── YYMMDD-HHMM-<slug>/
    ├── plan.md              # Overview, phases, status
    ├── phase-01-setup.md    # Setup / environment
    ├── phase-02-*.md        # Implementation phases
    └── reports/
        └── researcher-*.md  # Research findings

Each phase file contains: overview, requirements, architecture, file ownership, implementation steps, todo checklist, success criteria, risk assessment.

Task Hydration

Tasks are ephemeral (session-scoped). Plan files are persistent. Hydration bridges them:

Read [ ] items from phase files
TaskCreate for each unchecked item
Work proceeds via TaskUpdate
On complete: mark [x] in plan file
Next session: re-hydrate remaining [ ] items

Use --no-tasks when you want the plan only (e.g., for review before execution).

Active Plan State

Hooks track the current active plan. Downstream skills (cook, project-management, research) automatically write reports to the active plan’s directory. Switching plans updates hook context.

Quality Standards

Plans follow YAGNI, KISS, DRY. Honest and brutal—no wishful thinking about complexity or timeline. Concise phase files beat exhaustive ones. Each phase must be independently executable.

Cook — executes plans produced by this skill
Bootstrap — end-to-end scaffold that delegates to plan + cook
Agent Teams — parallel execution teams that consume phase files