ideate

name	ideate
description	Develops ONE chosen direction into a shaped concept — the core idea, how it works, what it needs, the open questions. Use to deepen a single idea, or /ideate. Not for generating many (brainstorm) or deciding among them (propose).

ideate

The depth skill. Given one chosen direction (often a pick from a brainstorm shortlist), it develops it into a shaped concept: what the idea actually is, how it would work, what it depends on, what is still unknown. It goes deep on a single idea; it does not generate many (that is brainstorm) or choose among options (that is propose).

It is read-only and advisory: it writes a CONCEPT.md for the one idea, never product code. The output is judged by Review — is the concept concrete enough to decide on or prototype, and are the open questions named honestly rather than hidden?

What this does / does not do

Does: take one direction; articulate the core idea in a sentence; work out how it functions (the mechanism, the shape, the primary flow); name what it depends on and assumes; surface the open questions + risks; sketch a first-cut of what "good" looks like; write CONCEPT.md + a receipt. Does not: generate alternatives (that is brainstorm), pick between concepts (that is propose), build a proof-of-concept (that is prototype), or write product code.

When NOT to use

• No single direction is chosen yet — the space is still wide; use brainstorm first.
• A decision among several developed concepts is needed — use propose.
• The open question is feasibility and needs a throwaway build to answer — use prototype.
• The concept is settled and it is time to spec it — go to specify.

Inputs

• The one chosen direction (a brainstorm shortlist item, or a stated idea) + its intent.
• Optional context: state/project-map.md, constraints, the intake/spec if one exists.

How to do it

1. State the core. One sentence: what the idea is and the value it delivers. If that sentence is fuzzy, the concept is not ready to develop — sharpen it first.
2. Work out the mechanism. How it functions — the shape, the primary flow, the moving parts. Concrete enough that someone could argue with it.
3. Name dependencies + assumptions. What it needs to exist/be true to work; what you are assuming.
4. Surface open questions + risks. The unknowns that would change the concept if answered differently — named honestly, not buried.
5. Sketch "good". A first cut of what success looks like for this concept (the shape of acceptance, not full criteria — that is specify).
6. Write CONCEPT.md — core + mechanism + dependencies/assumptions + open questions + a sketch of good.

Output

• CONCEPT.md at the product root (or concepts/CONCEPT.md if that dir exists) — persistence: Ephemeral. Core (one sentence) · mechanism · dependencies + assumptions · open questions + risks · sketch of "good".
• receipt (<workspace>/receipts/ideate-receipt-<ts>.json): base schema + concept, core_statement, dependencies, open_questions, concept_path. persistence: Ephemeral.

Completion Criteria

Done when: CONCEPT.md develops one direction into a concrete concept — a sharp core sentence, a mechanism, its dependencies/assumptions, honestly-named open questions, and a sketch of "good"; a receipt records the concept + open questions.

Not done if: it generated alternatives instead of developing the one (that is brainstorm); the core sentence is still fuzzy; or the open questions/risks were hidden to make the concept look more settled than it is.

Next step: propose decides between this and other concepts; prototype de-risks an open feasibility question; specify turns a settled concept into a task card.

Related Skills

• brainstorm: generates many candidates. ideate develops ONE of them in depth.
• propose: chooses among developed concepts with tradeoffs. ideate produces the concept it weighs.
• prototype: answers a feasibility open-question with a throwaway build. ideate names the question.