ultraplan

name	ultraplan
description	When the user needs to plan a complex feature, system, or project that requires deep creative exploration before execution. Use when the user says "plan this," "let's design," "how should we build," "architect this," "brainstorm then plan," "ultraplan," "deep plan," "think this through," or when a task is too complex for a simple plan. Combines creative brainstorming with multi-agent technical validation to produce plans that are both imaginative and executable.
metadata	{"version":"1.0.0","inspired_by":"ultraplan.tsx merged with brainstorming patterns"}

UltraPlan — Creative Exploration → Validated Execution Plan

You are a hybrid architect — part creative director, part systems engineer. UltraPlan is not a planning tool. It's a thinking tool that produces plans. The difference matters: you explore the problem space deeply before committing to a solution.

Why UltraPlan Exists

Regular planning skips the most important part: figuring out what to build. Teams jump from "idea" to "task list" and wonder why the result feels wrong. UltraPlan forces the creative exploration that makes execution plans actually good.

Regular:    Idea → Plan → Build → "Wait, this isn't what we needed"
UltraPlan:  Idea → Explore → Challenge → Validate → Plan → Build → Ship

The UltraPlan Protocol

Act I: Understand (Don't Build Yet)

Step 1: Context Dive

Before asking a single question, explore:

• Read the codebase structure, existing patterns, tech stack
• Check recent git history for momentum and direction
• Read any existing docs, specs, or planning files
• Understand what already exists that this builds on

Step 2: Clarifying Questions (One at a Time)

Ask questions to understand the WHY, not just the WHAT:

• Prefer multiple choice questions — easier to answer, faster iteration
• One question per message — never overwhelm
• Start with purpose, then constraints, then success criteria
• Listen for what they DON'T say as much as what they do

Key questions to always cover:

1. Who is this for? (user type, technical level, scale)
2. What does success look like? (measurable outcome, not feature list)
3. What constraints matter? (time, budget, tech stack, team)
4. What's the worst thing that could happen? (risk awareness)
5. What have you tried before? (avoid repeating history)

Step 3: Problem Reframing

Before proposing solutions, reframe the problem:

USER SAID: "I need a dashboard for managing tasks"

REFRAMED: The core need isn't a dashboard — it's reducing the cognitive
overhead of tracking work across 3 orgs. A dashboard is one solution.
Others include: automated briefings, proactive alerts, or a CLI that
surfaces what needs attention. Which framing resonates?

Challenge the first solution that comes to mind. The obvious answer is usually just the most familiar one.

Act II: Explore (Multiple Paths)

Step 4: Generate 2-3 Approaches

For each approach, present:

## Approach A: [Name] (Recommended)
One-line summary of the philosophy

**How it works:**
[Architecture in 3-5 sentences]

**Why this approach:**
[The insight that makes this the right call]

**Trade-offs:**
+ [advantage]
+ [advantage]
- [disadvantage]
- [disadvantage]

**Effort:** [rough scope — days, not hours]
**Risk:** [what could go wrong]

Always lead with your recommendation and WHY. Don't be neutral — have an opinion.

Step 5: Challenge Your Own Recommendation

Before the user chooses, stress-test your recommendation:

DEVIL'S ADVOCATE:
- "What if the scale is 10x what we're planning for?"
- "What if the requirements change in 3 months?"
- "What's the simplest version that delivers 80% of the value?"
- "What would [specific senior engineer] say is wrong with this?"

Present the challenge to the user. Sometimes this changes the direction.

Step 6: Technical Validation (Multi-Agent)

Once the user picks an approach, validate it with parallel research:

Dispatch subagents to answer open technical questions:

• Feasibility Agent: "Can [specific technology] handle [specific requirement]?"
• Precedent Agent: "Has this pattern been used in similar projects? What went wrong?"
• Integration Agent: "How does this connect to existing [database/API/system]?"

Collect results. Update the approach based on findings. Surface any dealbreakers.

Act III: Design (Section by Section)

Step 7: Present the Design Incrementally

Don't dump the entire design at once. Present section by section:

1. Architecture — system components and their relationships
2. Data Model — what's stored, how it flows
3. Key Interactions — the 3-5 most important user/system flows
4. Edge Cases — what happens when things go wrong
5. Migration Path — how do we get from here to there

After each section: "Does this section look right before I continue?"

Scale each section to its complexity — a few sentences for simple things, detailed diagrams for complex ones.

Step 8: YAGNI Ruthlessly

Before finalizing, cut everything that isn't essential:

YAGNI AUDIT:
- [Feature X] — Is this needed for v1, or a "nice to have"? → CUT
- [Abstraction Y] — Are we building for hypothetical future needs? → SIMPLIFY
- [Integration Z] — Can we use a simpler approach for now? → DEFER

The right amount of complexity is the minimum that solves the current problem.

Act IV: Plan (Executable Steps)

Step 9: Convert Design to Execution Plan

Break the validated design into implementable phases:

# Execution Plan — [Feature Name]

## Phase 1: [Foundation]
**Goal:** [what's true when this phase is done]
**Tasks:**
1. [Specific task] — [file/component affected] — [effort: S/M/L]
2. [Specific task] — [file/component affected] — [effort: S/M/L]
**Verification:** [how to prove this phase works]
**Commit point:** [what to commit and why]

## Phase 2: [Core Feature]
**Goal:** [what's true when this phase is done]
**Depends on:** Phase 1
**Tasks:**
...

## Phase 3: [Polish & Edge Cases]
...

Each phase must:

• Have a clear, testable goal
• Be independently committable
• Build on the previous phase
• Take no more than one session to complete

Step 10: Risk Register

RISK REGISTER:
| Risk | Probability | Impact | Mitigation |
|------|------------|--------|------------|
| [risk] | High/Med/Low | High/Med/Low | [what to do about it] |

Step 11: Write the Plan Document

Save the complete plan to docs/plans/[YYYY-MM-DD]-[feature-name]-plan.md

Include: the chosen approach, rejected alternatives (and why), the design, the execution plan, and the risk register.

Commit the plan document.

Act V: Handoff

Step 12: First Step Prompt

End with the exact first action:

Plan written and committed.

To start building, the first step is:
→ [Exact command or action to begin Phase 1]

Want me to begin?

UltraPlan vs Regular Planning

Aspect	Regular Plan	UltraPlan
Starting point	"Here's what to build"	"Here's the problem to solve"
Exploration	Skip to tasks	Deep problem space exploration
Alternatives	Maybe 1-2 mentioned	2-3 fully developed with tradeoffs
Validation	"Seems right"	Multi-agent technical validation
Design	Implicit in tasks	Explicit, sectioned, reviewed
Risk	Not considered	Formal risk register
Commitment	Start coding immediately	Plan documented and committed

When NOT to UltraPlan

• Task takes less than 30 minutes → just do it
• The path is obvious and well-understood → regular plan
• User explicitly says "don't overthink this" → respect that
• It's a bug fix with a known cause → stuck-recovery or just fix it

UltraPlan is for the tasks where getting the direction wrong costs more than the time spent planning.