ase-meta-brainstorm

@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md @${CLAUDE_SKILL_DIR}/../../meta/ase-dialog.md @${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md

<purpose name="ase-meta-brainstorm"> Collaboratively Brainstorm a Topic </purpose>

<expand name="getopt" arg1="ase-meta-brainstorm" arg2="--max-clarify|-c=3 --min-ideas|-i=12 --min-rank|-r=7 --max-shortlist|-s=4"> $ARGUMENTS </expand>

<objective> Collaboratively brainstorm the topic <topic><getopt-arguments/></topic> by first *diverging* into a broad space of candidate ideas, then *converging* through clustering and scoring, and finally distilling a *shortlist* with a single recommended direction. </objective>

Guiding Tenets

Honor the following tenets throughout the brainstorming:

• No Assumption of Simplicity: Every topic goes through the full process - a one-line config change as much as a new subsystem - because the simplest-looking topics often hide the most harmful assumptions.

• Explore Intent First: Understand the purpose, constraints, and success criteria behind the topic before generating ideas, because ideas that optimize the wrong goal are worse than no ideas.

• Diverge Before Converge: Generate many candidate ideas without judging them first, because premature evaluation collapses the space before the good ideas have a chance to surface.

• One Question at a Time: Ask a single, preferably multiple-choice question per dialog round, because a wall of open questions overwhelms and yields shallow answers.

• YAGNI Ruthlessly: Actively prune ideas that serve speculative future needs rather than the stated purpose, because unbuilt features still cost clarity now.

• Ground in Reality: Cross-check ideas against the existing code base, documented context, and your world knowledge, because an idea that contradicts what already exists is a defect, not an option.

• Incremental Validation: Seek the user's confirmation at each phase boundary before advancing, because converging on a misunderstanding wastes the entire downstream effort.

<flow>

1. <step id="STEP 1: Restate Topic"> <if condition="<topic/> is empty"> Only output the following <template/> and then immediately *STOP* processing the entire current skill: <template> ⧉ **ASE**: ✪ skill: **ase-meta-brainstorm**, ▶ ERROR: expected a `<topic>` argument </template> </if>

   Restate the topic to be brainstormed by outputting the following <template/>:

   <template> <ase-tpl-bullet-secondary/> **TOPIC**: <topic/> </template> </step>
2. <step id="STEP 2: Clarify Intent">

   Before generating any ideas, explore the project context (review relevant existing files, documentation, and recent changes) and determine the <m/> (<m/> = 1..<getopt-option-max-clarify/>) essential unknowns about the topic - the purpose, constraints, scope boundaries, and success criteria that must be pinned down for the brainstorming to be reasonably grounded.

   Notice: you are intentionally constrained to just 1..<getopt-option-max-clarify/> unknowns, as too much upfront intent clarification kills the brainstorming of ideas later. So, you MUST reduce the clarifications of the unknowns to the absolute minimum in general and cap them at <getopt-option-max-clarify/>!

   For each essential unknown to clarify, derive a short 1-3 word facet <facet-M/> and a corresponding question <question-M/> whose answer materially changes which ideas make sense at all.

   1. For each <question-M/> in the iteration cycle <M/> (<M/>=1...<m/>):

      1. Output the following <template/>:

         <template> <ase-tpl-bullet-signal/> FACET <M/>/<m/>: **<facet-M/>**, QUESTION: **<question-M/>** </template>

      2. Determine 2 to 4 grounded candidate answers <answer-M-K/> (K={1,2,3,4}) from the code base, the documented context, and your world knowledge.

      3. In the following, you MUST NOT use your built-in <user-dialog-tool/> tool! Instead, you MUST just show a custom dialog according to the expanded custom-dialog definition. You MUST closely follow this definition.

         For this interactive dialog, use header <facet-M/> and question <question-M/>, and let the user select the <answer-M/> out of the candidate answers <answer-M-K/> (leave out the answer lines of those candidate answers you have not determined):

         <expand name="custom-dialog" arg1="--other"> <facet-M/>: <question-M/> <answer-M-1/>: (grounded candidate answer 1) <answer-M-2/>: (grounded candidate answer 2) [...] </expand>

      4. Dispatch on the dialog <result/>:

         • If <result/> is CANCEL: Skip the remaining sub-steps of this iteration cycle, break out of the iteration cycle entirely, and continue directly with the outer item 2. (cancellation handling) that immediately follows this iteration cycle 1. within this STEP 2.

         • If <result/> starts with ERROR:: Ask the user interactively, without a special tool, the question <question-M/> directly and set <answer-M/> to the response of the user.

         • If <result/> matches OTHER: <text/>: Set <answer-M><text/></answer-M> (take the user's free-text answer).

         • Otherwise: Set <answer-M><result/></answer-M> (take the selected candidate answer).

         Do not output anything in this sub-step.

      5. Output the following <template/>:

         <template> <ase-tpl-bullet-normal/> FACET <M/>/<m/>: **<facet-M/>**, ANSWER: **<answer-M/>** </template>

   2. If at any point <result/> is CANCEL: Only output the following <template/> and then immediately STOP processing the entire current skill:

      <template> ⧉ **ASE**: ✪ skill: **ase-meta-brainstorm**, ▶ status: **brainstorm cancelled** </template>
   </step>
3. <step id="STEP 3: Diverge Idea Space">

   Generate a broad space of candidate ideas that address the <topic/> within the constraints established by the answers <answer-M/>.

   Deliberately pursue diverse angles - e.g. the minimal/MVP-first angle, the robustness/risk-first angle, the user-experience-first angle, the reuse-existing-machinery angle, the coolness angle, and the unconventional/wildcard angle - because variety in origin yields variety in outcome.

   Still do not judge, rank, or prune ideas in this step. Generate ideas until you either reach at least <getopt-option-min-ideas/> distinct candidate ideas or have clearly exhausted the meaningfully distinct space.

   Store each candidate idea in <idea-N/> with the format **<idea-name-N/>**: <idea-statement-N/> (where <idea-name-N/> is a short 1-4 word summary and <idea-statement-N/> is a single-sentence statement of not more than 40 words), and output the following <template/>:

   <template> <ase-tpl-bullet-normal/> **IDEA <N/>**: <idea-N/> </template> </step>
4. <step id="STEP 4: Converge Idea Space">

   Converge the candidate ideas <idea-N/> into a smaller, structured set and finally into a recommendation.

   1. Cluster: group the candidate ideas into <c/> coherent clusters <cluster-C/> (a short 1-4 word label, C=1...<c/>), collapsing near-duplicates and discarding ideas pruned by You Aren't Gonna Need It (YAGNI) (speculative, out-of-scope, or contradicting documented context).

      For each cluster and its contained retained ideas, output the following <template/> (<cluster-summary-C/> is a single-sentence statement of not more than 40 words):

      <template> <ase-tpl-bullet-secondary/> **IDEA CLUSTER <C/>/<c/>**: <cluster-C/> - <cluster-summary-C/>, **IDEAS**: <idea-index-C/> </template>

      Here, <idea-index-C/> is the comma-separated list of the indices <N/> of those retained ideas <idea-N/> that belong to cluster <cluster-C/> (e.g. 2, 5, 9).

   2. Score: for each retained idea <idea-N/> in the clusters, rank its fit against the purpose and constraints on a Likert scale of 0 (poor) to 10 (excellent), considering value, uniqueness, risk, and alignment with the existing code base. Keep only ideas in the clusters with a rank of at least <getopt-option-min-rank/>.

      If no idea meets the <getopt-option-min-rank/> floor, the floor filter would empty the set and leave the downstream steps without any options. In this case, disregard the floor and instead keep the up-to-<getopt-option-max-shortlist/> highest-ranked ideas, and output the following <template/> to flag that even the strongest ideas fall below the bar:

      <template> <ase-tpl-bullet-signal/> **NOTICE**: no idea reached the minimum rank of <getopt-option-min-rank/>/10 - shortlisting the highest-ranked ideas regardless. </template>

   3. From the scored ideas <idea-N/>, distill a shortlist of the top <getopt-option-max-shortlist/> options, sorted by rank from highest to lowest.

      For this, draw the shortlist from distinct clusters <cluster-C/> wherever possible - prefer a diverse shortlist spanning different clusters over several high-ranked variations of the same cluster, unless one cluster clearly dominates on rank.

      Store each distilled option in <option-N/> with the format **<option-name-N/>** (rank: <option-rank-N/>/10, cluster: <option-cluster-N/>): <option-statement-N/> (where the statement is a single sentence of not more than 40 words capturing the direction and its primary trade-off), and output the following <template/>:

      <template> <ase-tpl-bullet-normal/> **DISTILLED IDEA**: <option-N/> </template>

   4. Finally, derive a single recommended idea - the highest-ranked option, or a principled synthesis of the option shortlist that preserves what is strongest in each - store its one-sentence rationale (not more than 40 words) in <recommendation/>, and output the following <template/>:

      <template> <ase-tpl-bullet-signal/> **RECOMMENDED IDEA**: <recommendation/> </template>

   5. Finally, give the closing hint by expanding the following (which, depending on the configured <ase-guidance-level/>, may expand into nothing and hence emit no output at all):

      <ase-tpl-hint level="normal"> To turn the recommended idea into a plan, use `/ase-task-edit`; to turn it directly into code, use `/ase-code-craft`. </ase-tpl-hint>
   </step>

</flow>