create-plans

<essential_principles>

When planning a phase, you are writing the prompt that will execute it. </principle>

The quality degradation curve:

• 0-30% context: Peak quality (comprehensive, thorough, no anxiety)
• 30-50% context: Good quality (engaged, manageable pressure)
• 50-70% context: Degrading quality (efficiency mode, compression)
• 70%+ context: Poor quality (self-lobotomization, rushed work)

Critical insight: Claude doesn't degrade at 80% - it degrades at ~40-50% when it sees context mounting and enters "completion mode." By 80%, quality has already crashed.

Solution: Aggressive atomicity - split phases into many small, focused plans.

Examples:

• 01-01-PLAN.md - Phase 1, Plan 1 (2-3 tasks: database schema only)
• 01-02-PLAN.md - Phase 1, Plan 2 (2-3 tasks: database client setup)
• 01-03-PLAN.md - Phase 1, Plan 3 (2-3 tasks: API routes)
• 01-04-PLAN.md - Phase 1, Plan 4 (2-3 tasks: UI components)

Each plan is independently executable, verifiable, and scoped to 2-3 tasks maximum.

Atomic task principle: Better to have 10 small, high-quality plans than 3 large, degraded plans. Each commit should be surgical, focused, and maintainable.

Autonomous execution: Plans without checkpoints execute via subagent with fresh context - impossible to degrade.

See: references/scope-estimation.md </principle>

Checkpoint types:

• checkpoint:human-verify - Human confirms Claude's automated work (visual checks, UI verification)
• checkpoint:decision - Human makes implementation choice (auth provider, architecture)

Rarely needed: checkpoint:human-action - Only for actions with no CLI/API (email verification links, account approvals requiring web login with 2FA)

Critical rule: If Claude CAN do it via CLI/API/tool, Claude MUST do it. Never ask human to:

• Deploy to Vercel/Railway/Fly (use CLI)
• Create Stripe webhooks (use CLI/API)
• Run builds/tests (use Bash)
• Write .env files (use Write tool)
• Create database resources (use provider CLI)

Protocol: Claude automates work → reaches checkpoint:human-verify → presents what was done → waits for confirmation → resumes

See: references/checkpoints.md, references/cli-automation.md </principle>

During execution, deviations are handled automatically via 5 embedded rules:

1. Auto-fix bugs - Broken behavior → fix immediately, document in Summary
2. Auto-add missing critical - Security/correctness gaps → add immediately, document
3. Auto-fix blockers - Can't proceed → fix immediately, document
4. Ask about architectural - Major structural changes → stop and ask user
5. Log enhancements - Nice-to-haves → auto-log to ISSUES.md, continue

No user intervention needed for Rules 1-3, 5. Only Rule 4 (architectural) requires user decision.

All deviations documented in Summary with: what was found, what rule applied, what was done, commit hash.

Result: Flow never breaks. Bugs get fixed. Scope stays controlled. Complete transparency.

See: workflows/execute-phase.md (deviation_rules section) </principle>

Milestone-driven: Ship v1.0 → mark milestone → plan v1.1 → ship → repeat. Milestones mark shipped versions and enable continuous iteration. </principle>

Purpose:

• Historical record in MILESTONES.md (what shipped when)
• Greenfield → Brownfield transition marker
• Git tags for releases
• Clear completion rituals

Default approach: Extend existing roadmap with new phases.

• v1.0 ships (phases 1-4) → add phases 5-6 for v1.1
• Continuous phase numbering (01-99)
• Milestone groupings keep roadmap organized

Archive ONLY for: Separate codebases or complete rewrites (rare).

See: references/milestone-management.md </principle>

If it sounds like corporate PM theater, delete it. </principle>

At 25% remaining: Mention context getting full At 15% remaining: Pause, offer handoff At 10% remaining: Auto-create handoff, stop

Never start large operations below 15% without user confirmation. </principle>

Mandatory gates:

• Before writing PLAN.md (confirm breakdown)
• After low-confidence research
• On verification failures
• After phase completion with issues
• Before starting next phase with previous issues

See: references/user-gates.md </principle>

• Check for repo on invocation, offer to initialize
• Commit only at: initialization, phase completion, handoff
• Intermediate artifacts (PLAN.md, RESEARCH.md, FINDINGS.md) NOT committed separately
• Git log becomes project history

See: references/git-integration.md </principle>

</essential_principles>

<context_scan> Run on every invocation to understand current state:

# Check git status
git rev-parse --git-dir 2>/dev/null || echo "NO_GIT_REPO"

# Check for planning structure
ls -la .planning/ 2>/dev/null
ls -la .planning/phases/ 2>/dev/null

# Find any continue-here files
find . -name ".continue-here.md" -type f 2>/dev/null

# Check for existing artifacts
[ -f .planning/BRIEF.md ] && echo "BRIEF: exists"
[ -f .planning/ROADMAP.md ] && echo "ROADMAP: exists"

If NO_GIT_REPO detected: Inline question: "No git repo found. Initialize one? (Recommended for version control)" If yes: git init

Present findings before intake question. </context_scan>

<domain_expertise> Domain expertise lives in ~/.claude/skills/expertise/

Before creating roadmap or phase plans, determine if domain expertise should be loaded.

<scan_domains>

ls ~/.claude/skills/expertise/ 2>/dev/null

This reveals available domain expertise (e.g., macos-apps, iphone-apps, unity-games, nextjs-ecommerce).

If no domain skills found: Proceed without domain expertise (graceful degradation). The skill works fine without domain-specific context. </scan_domains>

<inference_rules> If user's request contains domain keywords, INFER the domain: