---
name: ideation-first
description: Use before planning a new feature or greenfield refactor whose requirements aren't yet pinned down — clarifies intent through a few questions and ends with a short scope brief the planner can build on.
---

# Ideation First

## Overview

Planning against guessed requirements wastes work. The planner turns a request into ordered steps —
but if the request itself is vague, every step is built on a guess, and the further the pipeline
runs, the more expensive that guess is to unwind. This skill settles the *what* before anyone plans
the *how*.

**Core principle:** clarify the what before planning the how.

## When this applies

A request for a **new capability, feature, or greenfield refactor whose requirements aren't pinned
down** — the goal, the boundaries, or the success criteria are open to interpretation. Signals:
"build a … screen", "add … support", "let users …", "we need something that …" with no spec.

## When to skip

- **Well-specified requests** — the goal, inputs, and done-condition are already unambiguous. Don't
  interrogate when the ask is clear; go straight to planning.
- **`quick` one-liners** — typo fixes, obvious small edits. Ideation is overhead here.
- **`bugfix`** — bugs get root-cause investigation first via the `debugger`, not requirements
  clarification. The "what" is already defined (make the broken thing work).

If you find yourself asking questions whose answers you already have, stop — you're past the point
this skill is for.

## The process

Keep it lightweight. The value is a locked scope, not ceremony.

1. **Ask 3–5 clarifying questions, one at a time.** One question per turn — each answer informs the
   next. Cover **purpose** (what problem does this solve, for whom), **constraints** (what must it
   fit within — existing patterns, platforms, non-negotiables), and **success criteria** (how do we
   know it's done and right).
2. **Prefer the minimal interpretation.** When the request is open-ended, propose the smallest thing
   that satisfies it and confirm — don't quietly scope in an ambitious version. This is
   `smallest-change-first` applied to requirements: don't build features nobody asked for (YAGNI).
3. **Propose 2–3 approaches** when there's a real design fork, each with its trade-off and your
   recommendation. Lead with the one you'd pick and say why.
4. **Confirm, then write the scope brief.** Once the user agrees, produce the brief below — it
   becomes the planner's input.

## The scope brief

End by producing this block. It is the hand-off to the planner; keep it compact.

```
**Scope brief**
- Goal: <one sentence>
- In scope: <bullets>
- Out of scope: <bullets — the explicit "not doing" list>
- Key decisions: <choices made during ideation + why>
- Open questions: <anything still unresolved, or "none">
```

When routing through `@orchestrator`, pass this brief in the invocation so the planner receives it —
a cold subagent can't see the conversation it wasn't part of.

## Red flags

| Thought | Reality |
|---|---|
| "I get the gist, I'll just start coding" | A gist is not an agreed scope. Confirm the what first. |
| "I'll ask all my questions at once" | One at a time — each answer changes what you'd ask next. |
| "The request was vague, so I'll pick something ambitious" | Pick the *minimal* interpretation and confirm it. Scope creep starts here. |
| "This feature is obviously simple, skip the brief" | Simple-looking features are where unexamined assumptions cost the most. The brief can be three lines, but write it. |
| "The out-of-scope list is empty" | If nothing is out of scope, you haven't bounded anything. Name what you're deliberately not doing. |