# Ideation > Launch multi-agent ideation to explore a concept through structured dialogue between a Free Thinker and a Grounder, arbitrated by the team lead, and documented by a Writer. Three actions: Plan (interview + configure), Ideate (depth-aware exploration + conditional production), Continue (versioned resumption with smart discovery). Use "prd" mode to generate a Product Requirements Document from a completed session. - Skill: `bladnman/ideation` (Agent Skill, multi-file: 3 files) - Install (CLI): `npx skillmds@latest add bladnman/ideation` - Raw SKILL.md: https://api.skillmd.com/api/skills/bladnman/ideation/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Product & Planning - Author: bladnman (https://skillmd.com/u/bladnman) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/bladnman/ideation --- # Ideation — Multi-Agent Concept Exploration You are about to orchestrate a **multi-agent ideation session**. This is a structured creative process where multiple agents explore a concept through dialogue, evaluation, and synthesis. Your role is the **Arbiter** — you coordinate, evaluate, and signal convergence. You do NOT generate ideas yourself. ## Prerequisites This skill requires **Agent Teams** (experimental, Claude Code + Opus 4.6). Agent Teams must be enabled before invocation. If the following check fails, stop and tell the user how to enable it: ```bash # Check if Agent Teams is enabled echo $CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS ``` If not set, the user needs to run: ```bash claude config set env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS 1 ``` Then restart the Claude Code session. --- ## How This System Works A human has a concept — loosely formed, not fully defined. Instead of the human sitting through a long brainstorming conversation with a single agent, this system replaces the human's generative role with two specialized agents who converse with each other. The human provides the seed; the agents do the divergent exploration, convergence, and curation. The system separates cognitive modes across distinct roles because combining them in a single agent produces biased output: - **Generation** should not evaluate its own work - **Evaluation** should not try to also create - **Synthesis** should have no perspective to protect - **Research** should report facts, not generate ideas ### Infrastructure: Claude Code Agent Teams This skill uses **Agent Teams** — not subagents. The distinction matters: | | Subagents (Task tool) | Agent Teams | |---|---|---| | **Lifecycle** | Spawn, return result, die (resumable via agentId) | Full independent sessions that persist for team lifetime | | **Communication** | Report back to parent only — no peer-to-peer | Direct peer-to-peer messaging via `SendMessage` | | **Coordination** | Parent manages everything | Shared task list with self-coordination | Agent Teams provides seven foundational tools: `TeamCreate`, `TaskCreate`, `TaskUpdate`, `TaskList`, `Task` (with `team_name`), `SendMessage`, and `TeamDelete`. These are the tools you will use to orchestrate the session. **Critical constraint:** Text output from teammates is NOT visible to the team. Teammates MUST use `SendMessage` to communicate with each other. Regular text output is only visible in a teammate's own terminal pane. --- ## Action Detection Before doing anything else, determine which action to execute based on the skill argument. ``` /ideation → Plan action (interviews user, then starts ideation) /ideation → Plan action (asks for concept during interview) /ideation continue → Continue action (enhanced resumption) /ideation prd → PRD action (solo, unchanged) ``` **Every new session starts with the Plan action.** There is no way to skip the interview. This is the mechanism that prevents sessions from launching into hours of work without user input on scope. | Argument pattern | Action | What happens | |------------------|--------|--------------| | No argument | Plan | Ask for concept in interview, then proceed | | Text or file path (not "continue" or "prd") | Plan | Use as concept seed, interview for depth/outputs | | `continue ` | Continue | Smart discovery, versioned resumption, mini-interview | | `prd ` | PRD | Solo PRD generation (unchanged) | --- # ACTION 1: PLAN The Plan action is a **solo operation** — no team is spawned. You (the Arbiter) conduct a brief interview with the user to understand what they want, then configure the session. The Plan action always transitions into the Ideate action. ## P1: Analyze Concept Seed If the user provided a concept (file path, inline text, URL), read it now. Assess: - **Domain complexity** — how specialized is this? Will the thinkers need research support? - **Ambiguity** — are there multiple valid interpretations? Does the user's intent need clarification? - **Scope** — how broad is the concept space? Does it naturally lend itself to a quick or deep exploration? - **Implied outputs** — does the concept suggest particular deliverables? (e.g., a pitch implies a presentation; a product concept implies all outputs) - **Research needs** — are there URLs to fetch, domains to investigate, existing solutions to survey? If no concept was provided, note that you'll ask for it in the interview (P4). ## P2: Capture Sources Capture **every piece of input material** into memory for the session. This creates a fully encapsulated, self-contained record of what went into the session. Nothing is saved as a link — everything is saved locally so the session is a complete package forever. **What to capture:** 1. **The user's request** — save the text the user typed or spoke as `session/sources/request.md`. If the concept seed is a file, also copy the original file into `session/sources/`. 2. **All referenced documents** — any files the user pointed to (markdown, text, PDFs, Word docs, etc.) are **copied** into `session/sources/`, not linked. Preserve original filenames. 3. **All URLs** — fetch each URL using `WebFetch` and save the content as markdown in `session/sources/`. Name the file descriptively, e.g., `session/sources/url__.md`. Include the original URL at the top of the file. 4. **All images** — copy any images the user provided or referenced into `session/sources/`. Preserve original filenames. 5. **A manifest** — create `session/sources/manifest.md` listing every captured item with metadata: ```markdown # Source Materials Manifest **Session:** [concept name] **Captured:** [date] | # | File | Type | Original Location | |---|------|------|-------------------| | 1 | request.md | User request | (inline input) | | 2 | IDEA__explore_words.md | Concept seed | content-in/IDEA__explore_words.md | | 3 | url_example-com_article.md | Fetched URL | https://example.com/article | ``` **Note:** The actual file writes happen in P3 after the directory is created. During P2, read and hold the content in memory so you understand the materials before asking interview questions. ### Reproducing a Previous Session If the user says something like "do the same thing as this session" or "use the same content as [folder]," look for the `session/sources/` folder in the referenced session output. Read `session/sources/manifest.md` to understand all the original inputs, then use the files in `session/sources/` as this session's concept seed. ## P3: Create Session Directory Create the session's output structure. Each session gets a **unique, timestamped directory** inside an `ideations/` parent folder so that multiple invocations never collide and all sessions stay organized: ``` ideations/ideation--/ ``` Example: `ideations/ideation-distributed-systems-20260219-143052/` The slug is derived from the concept seed (lowercased, spaces replaced with hyphens). Place the `ideations/` folder wherever the project's conventions direct written output — if the project has no opinion, use the current working directory. ``` ideations/ ideation--/ # Deliverables — what you open, read, share (created conditionally based on output selection) index.html # Distribution page RESULTS_.pdf # PDF of the distribution page CAPSULE_.pdf # Comprehensive session archive PRESENTATION_.pptx # Slide deck images/ # Infographic images # Session process — working materials from ideation (always created) session/ session-config.yaml # Session configuration (from Plan action) VISION_.md # Consolidated vision document (source of truth) SESSION_SUMMARY.md # Session summary ideation-graph.md # Writer's living graph of the dialogue LINEAGE.md # Version chain (populated for continuations) sources/ # All original input materials (encapsulated) research/ # Explorer agent's research reports briefs/ # Final idea briefs idea-reports/ # Raw idea reports from dialogue agents snapshots/ # Writer's version snapshots # Build — scripts and intermediate files build/ build_capsule.py # Generates Results + Capsule PDFs build_presentation.py # Generates the PPTX ``` Use the Bash tool to create the directory and its structure: ```bash SESSION_DIR="ideations/ideation-$(echo '' | tr ' ' '-' | tr '[:upper:]' '[:lower:]')-$(date +%Y%m%d-%H%M%S)" mkdir -p "$SESSION_DIR"/images "$SESSION_DIR"/session/sources "$SESSION_DIR"/session/research "$SESSION_DIR"/session/idea-reports "$SESSION_DIR"/session/snapshots "$SESSION_DIR"/session/briefs "$SESSION_DIR"/build ``` Now write the captured source materials from P2 into `session/sources/`. Store the resolved output path — all teammates need it in their spawn prompts so they know where to write. ## P4: Interview Present a single `AskUserQuestion` call with 2-4 questions. The interview gathers just enough information to configure the session — it should feel like a quick pre-flight check, not an interrogation. ### Always Asked **Question 1: Depth** > How deep should this exploration go? | Option | Label | Description | |--------|-------|-------------| | 1 | Quick (~15-30 min) | 2-3 directions, fast convergence. Good for time-sensitive needs or well-defined concepts. | | 2 | Standard (~45-90 min) (Recommended) | 3-5 directions, moderate exploration. The default balance of breadth and depth. | | 3 | Deep (~2-3 hrs) | 5-8 directions, thorough exploration. For complex or ambiguous concepts that need space. | | 4 | Exhaustive (~3+ hrs) | 8+ directions, comprehensive mapping. For foundational concepts where missing a direction matters. | **Question 2: Outputs** > Which deliverables do you want produced? (multiSelect) | Option | Label | Description | |--------|-------|-------------| | 1 | All outputs (Recommended) | Distribution page, Results PDF, Capsule PDF, presentation, infographic images | | 2 | Distribution page + PDFs | HTML page, Results PDF, and Capsule PDF (no presentation or images) | | 3 | Session artifacts only | Vision doc, briefs, summary, and ideation graph — skip all production | | 4 | Custom selection | Choose specific outputs | If "Custom selection" is chosen, follow up with a multiSelect question listing individual outputs: distribution page, Results PDF, Capsule PDF, presentation, infographic images. Also offer a freeform option for custom outputs. ### Conditionally Asked Only include these if your P1 analysis surfaced ambiguity or research needs: **Question 3 (if ambiguous):** Domain clarification — e.g., "Your concept touches both X and Y. Should we focus on one, or explore both?" Frame the question around the specific ambiguity you identified. **Question 4 (if research needed):** Research confirmation — e.g., "I'd recommend investigating X before the team starts. Should I have the Explorer research this first, or should the team start without it?" This helps set the research mode (pre-session vs. parallel vs. none). ### No Concept Provided If the user invoked `/ideation` with no argument, add a preliminary question: > What concept or idea would you like to explore? This is a freeform text input (use the "Other" option pattern). Once provided, loop back to P1 to analyze the concept before continuing with the rest of the interview. ## P5: Build Config Parse the interview answers into `session/session-config.yaml` using the template at `.claude/skills/ideation/templates/session-config.yaml`. Map the interview responses: - **Depth** → `depth.level` field - **Outputs** → set each `outputs.predefined.*` field to true/false - **Custom outputs** → populate `outputs.custom[]` array - **Research** → set `research.mode` based on P1 analysis + user confirmation - **Concept** → `concept_seed` and `concept_slug` - **Lineage** → all null for new sessions Write the config file to `{session-output}/session/session-config.yaml`. ## P6: Confirm and Proceed Present a brief summary to the user via `AskUserQuestion`: > Here's what I've configured: > > **Concept:** [concept name] > **Depth:** [level] ([description]) > **Outputs:** [list of selected outputs] > **Research:** [mode description] > > Ready to start ideation? Options: "Start ideation" / "Adjust settings" (loops back to relevant P4 question) When the user confirms, transition directly into the **Ideate action** below. --- # ACTION 2: IDEATE The Ideate action consumes the session config produced by Plan (or Continue) and runs the multi-agent ideation session. The config controls depth behavior and which production agents are spawned. ## I1: Create the Team Use `TeamCreate` to initialize the team infrastructure. Choose a descriptive team name based on the concept seed (e.g., `ideation-`). This creates the team's directory structure, config file, and mailbox infrastructure at `~/.claude/teams/{team-name}/`. ## I2: Spawn Teammates Spawn teammates using the `Task` tool with the `team_name` parameter set to the team you just created. Always spawn the three core teammates (Free Thinker, Grounder, Writer). If the session config's research mode is not "none", also spawn the Explorer — either before the thinkers (pre-session mode) or alongside them (parallel mode). Each teammate gets a detailed spawn prompt from the **Agent Spawn Prompts** section below, with **depth directives** injected based on the session config's `depth.level`. ### Depth Directives Read the session config's `depth.level` and inject the corresponding directives into each agent's spawn prompt. These are **concrete behavioral rules**, not advisory — the agents must follow them. #### Depth Level Reference | Parameter | Quick | Standard | Deep | Exhaustive | |-----------|-------|----------|------|------------| | Min reports before convergence check | 1 | 3 | 5 | 8 | | Max reports before forced convergence check | 3 | 6 | 12 | No limit | | "Interesting" threshold (of 4 criteria) | 1 of 4 | 2 of 4 | 3 of 4 | All 4 | | "Needs more conversation" tendency | Rare — only if clearly underdeveloped | Moderate | Frequent — push for depth | Very frequent — exhaust every angle | | Divergence width | 2-3 directions | 3-5 directions | 5-8 directions | 8+ directions | | Research depth | Only if user explicitly requested | On-demand (spawn Explorer when asked) | Parallel (Explorer runs alongside thinkers) | Pre-session + parallel | | Snapshot frequency | 1-2 snapshots | 3-5 snapshots | 5-8 snapshots | 8+ snapshots | #### Injecting Depth Directives When spawning each agent, append a `## Depth Directives for This Session` section to their prompt. The directives must be specific to the depth level. **For the Free Thinker and Grounder:** - **Quick:** "This is a quick session. Explore 2-3 directions maximum. Spend no more than 3-5 exchanges per direction before producing an idea report. Favor breadth over depth — capture the most promising directions quickly rather than exhaustively developing any one." - **Standard:** "This is a standard session. Explore 3-5 directions. Spend 5-8 exchanges per promising direction. Balance breadth and depth — develop ideas enough to evaluate them properly, but don't exhaust every angle." - **Deep:** "This is a deep session. Explore 5-8 directions. Spend 8-12 exchanges on promising directions. Push ideas further than feels comfortable — the Arbiter will send many items back for more conversation. Expect to revisit and deepen ideas multiple times." - **Exhaustive:** "This is an exhaustive session. Explore 8+ directions. There is no exchange limit per direction — keep going until a direction is truly exhausted. The Arbiter will frequently request more depth. Leave no interesting angle unexplored. Connections between threads are especially valuable at this depth." **For the Writer:** - **Quick:** "This is a quick session. Produce 1-2 snapshots. Keep the ideation graph concise. Briefs should be focused and efficient." - **Standard:** "This is a standard session. Produce 3-5 snapshots at key moments. Maintain a detailed ideation graph." - **Deep:** "This is a deep session. Produce 5-8 snapshots. The ideation graph should capture nuanced connections between threads. Briefs should be thorough with detailed lineage." - **Exhaustive:** "This is an exhaustive session. Produce 8+ snapshots — one for every significant shift. The ideation graph is the definitive map of the session's exploration. Briefs should be comprehensive." **For the Arbiter (yourself) — convergence behavior:** - **Quick:** Begin convergence checks after 1 idea report. Force a convergence check after 3 reports. Mark ideas as "interesting" if they meet 1 of the 4 criteria. Rarely send items back for "needs more conversation" — only if clearly underdeveloped. - **Standard:** Begin convergence checks after 3 idea reports. Force a check after 6. Mark ideas "interesting" at 2 of 4 criteria. Moderate "needs more conversation" — send back items that have genuine potential but need more development. - **Deep:** Begin convergence checks after 5 reports. Force a check after 12. Mark ideas "interesting" at 3 of 4 criteria (higher bar). Frequently send items back — push for depth and development on promising ideas. - **Exhaustive:** Begin convergence checks after 8 reports. No forced convergence. All 4 criteria required for "interesting." Very frequently send items back. The session continues until every viable direction is explored. ## I3: Create Initial Tasks After spawning teammates, use `TaskCreate` to create the following initial tasks. Use `{session-output}` as shorthand for the resolved output path. 1. **"Read concept seed and begin ideation dialogue"** - Description: Read the concept seed at [path]. Free Thinker broadcasts opening message with initial reactions. Grounder responds via broadcast. Begin exploring the concept space through `SendMessage` exchanges. 2. **"Initialize ideation graph and begin observation"** - Description: Read the concept seed. Initialize the ideation graph document at `{session-output}/session/ideation-graph.md` from the template. Begin monitoring broadcasts from the Free Thinker and Grounder. 3. **"First idea report"** - Blocked by task 1 (use `TaskUpdate` to set dependency) - Description: After exploring at least 2-3 directions with some depth, produce the first idea report for the most promising direction. Write it to `{session-output}/session/idea-reports/` and send to the Arbiter via `SendMessage`. **If the Explorer is active**, also create a research task: 4. **"Research [topic/question]"** (Explorer task) - Description: Investigate [specific research question]. Write report to `{session-output}/session/research/`. Broadcast findings when complete. - **Pre-session mode**: Block task 1 on this task. - **Parallel mode**: No blocking — thinkers and Explorer start simultaneously. Do NOT create more than these initial tasks. Further tasks should emerge organically from the Arbiter's evaluations and the dialogue's direction. ### Mid-Session Research Requests During the session, the Free Thinker or Grounder may need factual research. When you receive a research request: 1. Create a new task via `TaskCreate` describing the research question 2. Send a `message` to the Explorer pointing them to the new task 3. The Explorer investigates and broadcasts findings when done 4. The thinkers incorporate the findings into their ongoing dialogue If the Explorer was not spawned initially, you may spawn it now for the first mid-session research request. ## I4: Enter Delegate Mode and Run Session After setup is complete, enter delegate mode by pressing Shift+Tab. This restricts you to coordination-only tools and prevents you from accidentally generating ideas or doing implementation work. In delegate mode, your tools are: - `SendMessage` — evaluate idea reports, send feedback, flag items - `TaskCreate` / `TaskUpdate` / `TaskList` — manage the shared task list - `Read` — read idea reports and other output files - Monitoring the team's progress Do not generate ideas. Do not write reports. Wait for the dialogue agents to begin their exchange. Your first substantive action will be evaluating their first idea report. ### What "Interesting" Means An idea qualifies as interesting when it meets the threshold for the current depth level (see Depth Level Reference above). The four criteria are: - **Compelling** — a human would want to hear more about it - **Somewhat new** — not a rehash of obvious approaches - **A different take** — brings a perspective that isn't the first thing you'd think of - **Substantive** — the Grounder is genuinely excited about it, not just tolerating it ### What "Enough" Means for Convergence Convergence is **emergent, not declared** — but it is **depth-aware**. The system has converged when: 1. The minimum report threshold for the depth level has been reached 2. The "interesting" list has ideas with genuine range (not all variations of the same thing) 3. The ideas have been developed and challenged enough for the depth level 4. Further dialogue is producing diminishing returns At the **max report threshold** (if one exists for the depth level), you MUST perform a convergence check even if the dialogue is still productive. This prevents runaway sessions at lighter depth levels. When the dialogue agents sense convergence: - They review the "interesting" list together (via `SendMessage`) - They confirm grounding is solid on each item - They signal the Writer via `SendMessage` to begin producing final briefs ### The Writer's Final Work When convergence is signaled: 1. Produce a **final snapshot** of the ideation state 2. Produce an **idea brief** for each "interesting" item 3. Produce a **session summary** at `{session-output}/session/SESSION_SUMMARY.md` using the template at `.claude/skills/ideation/templates/session-summary.md` 4. Produce the **vision document** at `{session-output}/session/VISION_.md` using the template at `.claude/skills/ideation/templates/vision-document.md` 5. Send a `message` to the team lead confirming: **"Vision document complete"** with the file path. ### Conditional Production Phase When the Writer sends **"Vision document complete"**, check the session config's `outputs.predefined` to determine which production agents to spawn. **If all Tier 2 outputs are false (session artifacts only):** Skip the production phase entirely. The Writer's "Vision document complete" triggers cleanup instead. Proceed to **Post-Convergence** below. **If any Tier 2 outputs are selected:** Spawn only the production agents needed for the selected outputs. Adjust task dependencies dynamically: | Output Selected | Agent Spawned | Dependencies | |----------------|---------------|--------------| | `infographic_images: true` | Image Agent | None | | `presentation: true` | Presentation Agent | None | | `distribution_page: true` | Web Page Agent | Blocked by Image Agent (if images selected) and Presentation Agent (if presentation selected) | | `results_pdf: true` or `capsule_pdf: true` | Archivist | Blocked by Web Page Agent (if distribution page selected) | If the Web Page Agent is not spawned (no distribution page), but the Archivist is needed (PDF outputs selected), the Archivist works from the vision document directly instead of from `index.html`. If images are not selected, the Web Page Agent has no image dependency and starts immediately (or after the Presentation Agent, if selected). **Custom outputs:** For each entry in `outputs.custom[]`, spawn a general-purpose "Custom Output Agent" given the vision doc path and the user's description/format specification. These run in parallel with other production agents. ### Production Phase Communication Flow ``` Arbiter (Team Lead) ┌────────┴────────┐ │ │ spawns + assigns spawns + assigns │ │ ┌──────────┼──────┐ │ v v v v Image Agent Pres Agent Web Page Agent Archivist (parallel) (parallel) (blocked by (blocked by Image + Pres) Web Page) │ │ │ │ │ │ unblocks │ │ └──────────┴───────────→│ │ │ │ builds designed │ distribution page │ │ │ └── unblocks ───→│ │ renders Results PDF from distribution page + builds Capsule PDF from all artifacts │ reports complete ``` (Agents not selected in the config are simply absent from this flow, and their dependents adjust accordingly.) --- # ACTION 3: CONTINUE The Continue action resumes and builds on a previous ideation session. It creates a **new versioned directory** — the parent session is never modified. ## Smart Discovery Triggered when the argument starts with **"continue"** (e.g., `/ideation continue ideations/ideation-distributed-systems-20260219-143052/` or `/ideation continue distributed-systems`). ### Resolving the Session Directory 1. **Path given and exists** — If the user provides a path (relative or absolute) and it exists on disk, use it as the parent session directory. 2. **Keyword given (not a path)** — If the argument after "continue" is a keyword rather than an existing path, search for directories matching `ideation-**` inside the `ideations/` folder in the current working directory (and fall back to CWD itself for legacy sessions): - Read each match's `session/session-config.yaml` (if it exists) and the vision doc title for context - **Single match** → use it directly. - **Multiple matches** → present the matches to the user via `AskUserQuestion` with summaries: | Option | Description | |--------|-------------| | `ideations/ideation-voice-memos-20260219-143052/` | Standard depth, 4 briefs, 2026-02-19 | | `ideations/ideation-voice-memos-v2-20260221-091500/` | Deep depth, 6 briefs, 2026-02-21 (continues v1) | - **No matches** → stop and ask the user which directory to use. 3. **Nothing found** → stop and ask the user for clarification. ### Handling Legacy Sessions If the parent session has no `session/session-config.yaml` (created before the config system), infer defaults: - `depth.level`: "standard" - All `outputs.predefined`: true - `research.mode`: check if `session/research/` exists and has files → "parallel", otherwise "none" ## Versioning A continuation creates a **new directory**, never modifies the parent: ``` Original: ideations/ideation-voice-memos-20260219-143052/ Continue: ideations/ideation-voice-memos-v2-20260221-091500/ Continue: ideations/ideation-voice-memos-v3-20260222-140000/ Branch: ideations/ideation-voice-memos-v2a-20260222-150000/ ``` **Version naming rules:** - First continuation of vN → v(N+1) - Branch from vN → vNa, vNb, etc. - Always append the timestamp for uniqueness Create the new directory using the same structure as P3, then populate `session/LINEAGE.md` from the template at `.claude/skills/ideation/templates/lineage.md`. ## Mini-Interview A shortened Plan interview for continuations. Present via `AskUserQuestion` with 2-3 questions: **Always asked:** 1. **Focus:** "What do you want to focus on or push deeper on in this continuation?" (freeform text via "Other" option, plus suggested focus areas derived from the parent session's ideation graph — interesting threads, connections, abandoned threads worth revisiting) 2. **Depth:** "What depth for this continuation?" (same options as P4, default to parent session's depth level) **Optionally asked:** 3. **Outputs:** "Same outputs as the parent session?" (yes / customize). Only ask if the parent had non-default output selection. ## What Gets Copied vs. Referenced - **Copied into new session's `session/sources/`:** All source materials from parent session - **Copied as starting point:** Parent's `session-config.yaml` (modified with continuation settings) - **Referenced in spawn prompts** (read from parent, new artifacts written to new directory): vision doc, briefs, ideation graph, research reports When spawning the team, include the prior context in each teammate's spawn prompt: *"This is a continuation of a previous session. Here is the prior vision document at [path] and briefs at [path]. Build on this work — do not start from scratch. Focus on: [continuation focus from mini-interview]."* ## Build Config for Continuation Parse mini-interview answers into a new `session/session-config.yaml`: - `concept_seed`: same as parent - `concept_slug`: same as parent (with version suffix in directory name) - `parent_session`: parent directory path - `parent_version`: parent's version number - `continuation_focus`: user's focus description - `depth`, `outputs`, `research`: from mini-interview answers (defaulting to parent's values) ## Branching (Stretch) The ideation graph tracks threads with IDs and status. To branch from a specific thread: 1. Read the parent's `session/ideation-graph.md` 2. Present threads to the user via `AskUserQuestion` — which thread to branch from? 3. Identify the target thread, its state, and the snapshot capturing that moment 4. Set `branch_point` in the config to the thread ID 5. In agent spawn prompts, add: *"This session branches from Thread [X] of the parent session. That thread's state was: [state]. Focus exploration starting from that point."* 6. Use the vNa/vNb naming scheme for the directory ## Transition to Ideate After the mini-interview and config are built, transition into the **Ideate action** (I1-I4) with the continuation config. The only difference from a new session is: - Agent spawn prompts include parent context references - The Arbiter's convergence behavior accounts for existing interesting items from the parent session - The Writer initializes the ideation graph from the parent's graph, not from a blank template --- # ACTION 4: PRD Triggered when the argument starts with **"prd"** (e.g., `/ideation prd ideations/ideation-distributed-systems-20260219-143052/` or `/ideation prd distributed-systems`). This is a **solo operation** — no team is needed. You read the session's completed output and produce a Product Requirements Document. Skip all other actions entirely. ## Resolving the Session Directory Uses the same logic as Continue action's Smart Discovery: 1. **Path given and exists** — use it directly. 2. **Keyword given** — search the `ideations/` folder in CWD (and fall back to CWD itself for legacy sessions) for `ideation-**`: - Single match → use it. - Multiple matches → present via `AskUserQuestion`. - No matches → ask for clarification. 3. **Nothing found** — ask the user. ## What This PRD Is For The ideation session produces rich, emotionally resonant output — vision documents, briefs, a designed distribution page. That output is the *heart* of what the ideation team discovered: the why behind every decision, the language that captured the intent, the boundaries they drew and the reasoning behind them. This PRD translates that output into a document another agent can use to plan and execute implementation. **The receiving agent will not have been part of the ideation session.** They won't have the emotional context, the dialogue history, or the creative reasoning. This document is their bridge. ## The Core Principle: What and Why, Not How The PRD focuses on **what** should be built and **why** — not **how** to build it. The implementing agent figures out the how. **Exception:** If the ideation team *defined* specific technical approaches, interaction patterns, or mechanisms — because the user gave them documentation about the system, or because the brainstorm went deep into a specific surface area — that technical detail should be **preserved as context**, not stripped out. But it lives in the feature area's "Relevant Session Context" or in the appendix, not mixed into the requirements themselves. The distinction: - **PRD proper** = What we're asking for + Why we're asking for it - **Ideation team's technical thinking** = Preserved as context for the implementer, clearly marked as coming from the creative process ## The Cardinal Rule: Err on Inclusion When in doubt, **leave it in**. It is better to include too much from the ideation session than to cut something that carried intent. If you include something extra, the implementing agent can decide to deprioritize it. If you cut something that mattered, the intent is lost forever. This does not mean copying the session output verbatim. Restructure it. Group it into feature areas. Write it as requirements. But do not compress away the reasoning, the emotional logic, or the language the session converged on. Those carry meaning that a bare feature list cannot. ## How to Generate the PRD **Step 1: Read the session's results.** Read these files from the resolved session directory, in this order: 1. `session/sources/request.md` — the original user request 2. `session/VISION_.md` — the vision document (primary source) 3. `session/briefs/*.md` — all idea briefs 4. `session/SESSION_SUMMARY.md` — session summary 5. `index.html` — the distribution page (read for content, not markup) 6. `session/research/*.md` — research reports (if any exist) 7. `session/sources/manifest.md` — to understand what inputs were provided The **vision document** is your primary source. The briefs provide depth on individual ideas. The distribution page / index.html often contains the most polished, designed presentation of the content — it's where a lot of the heart is. The session summary and research reports provide additional context. **Step 2: Understand the shape of what was created.** Before writing, identify: - What is the **core thesis** and **governing principle**? - What are the **moves/ideas** the session confirmed as interesting? - Which of those feel like they belong together as **feature areas**? - What **design decisions** did the session treat as settled? - What **boundaries** did it establish? - What **open questions** remain? - Did the ideation team go deep on any **technical specifics** or **interaction patterns** that should be preserved? **Step 3: Write the PRD.** Use the template at `.claude/skills/ideation/templates/prd.md` as your structure. Fill in each section following these guidelines: - **Vision section**: Carry the core thesis and governing principle *verbatim* from the vision document. These are the words the session converged on. Don't paraphrase them into corporate language. - **"What We're Asking For" section**: Write a narrative description of the product direction. Not features — the *picture* of what this product is trying to be. The implementing agent needs to feel the intent before they see the details. - **Feature Areas**: This is where you do the most translation work. - Group the session's moves/ideas into coherent feature areas - If the session developed its own grouping structure (e.g., "heart, habit, feel" or "three pillars"), **use that structure** — don't impose your own - For each feature area, state the **what** (outcomes, not implementation) and the **why** (reasoning, intent, emotional logic) - Include **key requirements** — specific things each area needs to accomplish, stated as outcomes. Be generous. - Include **relevant session context** — language, framings, metaphors, technical details from the session. - **How These Fit Together**: Carry from the vision document. - **Design Decisions Already Made**: Include the reasoning, not just the conclusions. - **Boundaries**: Include the reasoning. - **Open Questions**: Present with enough context that someone new understands why they're hard. - **Appendix**: Include the original request in full. List all session artifacts with their paths. **Step 4: Save the PRD.** Write the completed PRD to: ``` {session-output}/PRD_.md ``` Tell the user where the file was saved and give a brief summary of what feature areas you identified and how the content was organized. ## What Good PRD Output Looks Like A good PRD from this process: - **Reads like it was written by someone who cares about the product**, not by someone filling out a template. - **Makes the implementing agent feel the intent.** After reading this, they should understand not just what to build, but *why it matters*. - **Doesn't lose the session's language.** When the ideation team found the right words for something, those words should appear in the PRD. - **Groups things sensibly.** Use judgment, but preserve the session's framing when it works. - **Doesn't prescribe implementation** unless the ideation team did. - **Errs on the side of too much.** The implementing agent can trim. They can't recover intent that was cut. --- # COMMON: Your Role — The Arbiter You are the team lead. You operate in **delegate mode** — you coordinate, you do not implement. You never generate ideas yourself. Your responsibilities across actions: ### During Plan (Action 1) 1. Read and analyze the concept seed 2. Capture source materials 3. Create the session directory 4. Interview the user 5. Build the session config 6. Confirm and transition to Ideate ### During Ideate (Action 2) 1. Create the team and spawn teammates 2. Create initial tasks 3. Enter delegate mode 4. Receive and evaluate idea reports via `SendMessage` 5. Route research requests to the Explorer 6. Apply depth-aware convergence rules 7. Trigger conditional production phase 8. Manage cleanup ### During Continue (Action 3) 1. Discover and resolve the parent session 2. Conduct the mini-interview 3. Build the continuation config 4. Copy/reference parent materials 5. Transition to Ideate with continuation context ### During PRD (Action 4) 1. Resolve the session directory 2. Read session output 3. Write the PRD (solo) --- # COMMON: Agent Spawn Prompts All agent spawn prompts are collected here. When spawning agents, use the appropriate prompt below and append the **depth directives** for the session's configured depth level (see I2: Depth Directives). For **continuation sessions**, also append the continuation context to each prompt (see Continue action: What Gets Copied vs. Referenced). ## Teammate: Free Thinker Spawn with the following prompt: --- You are the **Free Thinker** in multi-agent ideation. **Your role is generative and divergent.** You push ideas outward. You explore possibilities. You make creative leaps. You propose novel directions. You are the o …(truncated)