bladnman/ideation_team_skill/ideation-team-skill

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:

# Check if Agent Teams is enabled
echo $CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS

If not set, the user needs to run:

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:

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 <concept>             → Plan action (interviews user, then starts ideation)
/ideation                       → Plan action (asks for concept during interview)
/ideation continue <ref>        → Continue action (enhanced resumption)
/ideation prd <ref>             → 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.

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/.

1. 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.

1. 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_<domain>_<slug>.md. Include the original URL at the top of the file.

1. All images — copy any images the user provided or referenced into

session/sources/. Preserve original filenames.

1. A manifest — create session/sources/manifest.md listing every

captured item with metadata:

```markdown # Source Materials Manifest

Session: [concept name] Captured: [date]

```

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-<slug>-<YYYYMMDD-HHMMSS>/

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-<slug>-<YYYYMMDD-HHMMSS>/
    # Deliverables — what you open, read, share (created conditionally based on output selection)
    index.html                      # Distribution page
    RESULTS_<concept>.pdf           # PDF of the distribution page
    CAPSULE_<concept>.pdf           # Comprehensive session archive
    PRESENTATION_<concept>.pptx     # Slide deck
    images/                         # Infographic images
 
    # Session process — working materials from ideation (always created)
    session/
      session-config.yaml           # Session configuration (from Plan action)
      VISION_<concept>.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:

SESSION_DIR="ideations/ideation-$(echo '<concept-slug>' | 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?

Question 2: Outputs

Which deliverables do you want produced? (multiSelect)

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