Interactive brainstorming with documented thought evolution, multi-perspective analysis, and iterative refinement. Serial execution with no agent delegation.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Interactive brainstorming with documented thought evolution, multi-perspective analysis, and iterative refinement. Serial execution with no agent delegation.
argument-hint
TOPIC="<idea or topic>" [--perspectives=creative,pragmatic,systematic] [--max-ideas=<n>]
Codex Brainstorm-With-File Prompt
Overview
Interactive brainstorming workflow with documented thought evolution. Expands initial ideas through questioning, inline multi-perspective analysis, external research, and iterative refinement.
Core workflow: Seed Idea โ Expand โ Multi-Perspective Explore โ Research โ Refine โ Crystallize โ Next Step
Key features:
brainstorm.md: Complete thought evolution timeline
Aggregated findings with synthesis (convergent/conflicting themes)
Updated brainstorm.md
Round 1: Exploration results and multi-perspective analysis
Phase 3: Interactive Refinement
Artifact
Purpose
ideas/{idea-slug}.md
Deep-dive analysis for selected ideas
ideas/merged-idea-{n}.md
Merged idea documents
Updated brainstorm.md
Round 2-6: User feedback, idea selections, refinement cycles
Phase 4: Convergence & Crystallization
Artifact
Purpose
synthesis.json
Final synthesis: top ideas, recommendations, insights
Final brainstorm.md
Complete thought evolution with conclusions
Recording Protocol
CRITICAL: During brainstorming, the following situations MUST trigger immediate recording to brainstorm.md:
Trigger
What to Record
Target Section
Idea generated
Idea content, source perspective, novelty/feasibility ratings
#### Ideas Generated
Perspective shift
Old framing โ new framing, trigger reason
#### Decision Log
User feedback
User's original input, which ideas selected/rejected
#### User Input
Assumption challenged
Original assumption โ challenge result, survivability
#### Challenged Assumptions
Ideas merged
Source ideas, merged concept, what was preserved/discarded
#### Decision Log
Scope adjustment
Before/after scope, trigger reason
#### Decision Log
Decision Record Format
> **Decision**: [Description of the decision]> - **Context**: [What triggered this decision]> - **Options considered**: [Alternatives evaluated]> - **Chosen**: [Selected approach] โ **Reason**: [Rationale]> - **Rejected**: [Why other options were discarded]> - **Impact**: [Effect on brainstorming direction]
Narrative Synthesis Format
Append after each round update:
### Round N: Narrative Synthesis**Starting point**: Based on previous round's [conclusions/questions], this round explored [starting point].
**Key progress**: [New ideas/findings] [confirmed/refuted/expanded] previous understanding of [topic area].
**Decision impact**: User selected [feedback type], directing brainstorming toward [adjusted/deepened/maintained].
**Current state**: After this round, top ideas are [updated idea rankings].
**Open directions**: [remaining exploration angles for next round]
// Match topic text against keyword lists from Dimensions Reference// If multiple dimensions match, include all// If none match, default to "technical" and "innovation"const dimensions = identifyDimensions(topic, BRAINSTORM_DIMENSIONS)
Step 1.2: Role Selection
Recommend roles based on topic keywords, then let user confirm or override.
Professional Roles (recommended based on topic keywords):
Generate key questions that guide the brainstorming exploration. Done inline โ no agent delegation.
Exploration Vectors:
Core question: What is the fundamental problem/opportunity?
User perspective: Who benefits and how?
Technical angle: What enables this technically?
Alternative approaches: What other ways could this be solved?
Challenges: What could go wrong or block success?
Innovation angle: What would make this 10x better?
Integration: How does this fit with existing systems/processes?
Analyze the topic inline against user focus areas and constraints to produce 5-7 exploration vectors.
Step 1.5: Initialize brainstorm.md
const brainstormMd = `# Brainstorm Session
**Session ID**: ${sessionId}
**Topic**: ${topic}
**Started**: ${getUtc8ISOString()}
**Dimensions**: ${dimensions.join(', ')}
**Mode**: ${brainstormMode}
## Table of Contents
<!-- TOC: Auto-updated after each round/phase. -->
- [Session Context](#session-context)
- [Current Ideas](#current-ideas)
- [Thought Evolution Timeline](#thought-evolution-timeline)
## Current Ideas
<!-- REPLACEABLE BLOCK: Overwrite (not append) after each round with latest ranked ideas. -->
> To be populated after exploration.
## Session Context
- Focus areas: ${focusAreas.join(', ')}
- Perspectives: ${selectedPerspectiveNames.join(', ')}
- Constraints: ${constraints.join(', ')}
- Mode: ${brainstormMode}
## Exploration Vectors
${explorationVectors.map((v, i) => `${i+1}. ${v}`).join('\n')}
## Initial Decisions
> Record why these perspectives and focus areas were selected.
---
## Thought Evolution Timeline
> Rounds will be appended below as brainstorming progresses.
---
## Decision Trail
> Consolidated critical decisions across all rounds (populated in Phase 4).
`Write(`${sessionFolder}/brainstorm.md`, brainstormMd)
Success Criteria:
Session folder created with brainstorm.md initialized
Brainstorm dimensions identified and user preferences captured
Initial decisions recorded: Perspective selection rationale, excluded options with reasons
Exploration vectors generated
1-3 perspectives selected
Phase 2: Divergent Exploration
Objective: Gather codebase context and execute multi-perspective analysis to generate diverse viewpoints. All exploration done inline โ no agent delegation.
Step 2.1: Detect Codebase & Explore
const hasCodebase = functions.exec_command(`
test -f package.json && echo "nodejs" ||
test -f go.mod && echo "golang" ||
test -f Cargo.toml && echo "rust" ||
test -f pyproject.toml && echo "python" ||
test -f pom.xml && echo "java" ||
test -d src && echo "generic" ||
echo "none"
`).trim()
if (hasCodebase !== 'none') {
// 1. Read project metadata (if exists)// - Run `ccw spec load --category exploration` (load project specs)// - Run `ccw spec load --category debug` (known issues and root-cause notes)// - .workflow/specs/*.md (project conventions)// 2. Search codebase for relevant content// Use: Grep, Glob, Read, or mcp__ace-tool__search_context// Focus on: modules/components, patterns/structure, integration points, config/dependencies// 3. Write findingsWrite(`${sessionFolder}/exploration-codebase.json`, JSON.stringify({
project_type: hasCodebase,
relevant_files: [...], // [{path, relevance, summary}]existing_patterns: [...], // [{pattern, files, description}]architecture_constraints: [...], // Constraints foundintegration_points: [...], // [{location, description}]key_findings: [...], // Main insights from code search_metadata: { timestamp: getUtc8ISOString(), exploration_scope: '...' }
}, null, 2))
}
Ask which ideas to merge. Inline synthesis: identify complementary elements, resolve contradictions, create unified concept, preserve strengths. Write to ideas/merged-idea-{n}.md.
ๅค้จ็ ็ฉถ
Execute web.run with topic-specific queries. Search for: industry patterns, competitive solutions, best practices, academic research. Merge findings into current round. Update research.json.
Ready to Converge
Record why concluding. Exit loop โ Phase 4.
Step 3.3: Deep Dive on Selected Ideas
When user selects "deep dive", provide comprehensive inline analysis:
// For each selected idea, analyze inline
selectedIdeas.forEach(idea => {
const deepDive = {
title: idea.title,
detailed_description: '...', // Elaborated concepttechnical_requirements: [...], // Implementation needsdependencies: [...], // What this depends onchallenges: [ // Risk/challenge matrix
{ challenge: '...', severity: 'high|medium|low', mitigation: '...' }
],
poc_approach: '...', // Proof-of-concept suggestionsuccess_metrics: [...], // How to measure successsource_perspectives: [...] // Which perspectives contributed
}
Write(`${sessionFolder}/ideas/${ideaSlug}.md`, formatIdeaMarkdown(deepDive))
})
Step 3.4: Devil's Advocate Challenge
When user selects "challenge", perform inline critical analysis:
selectedIdeas.forEach(idea => {
const challenge = {
idea: idea.title,
objections: [...], // 3+ strongest objectionschallenged_assumptions: [...], // Core assumptions testedfailure_scenarios: [...], // When/how this failsalternatives: [...], // Competitive/alternative solutionssurvivability_rating: 1-5, // How well idea survives challengestrengthened_version: '...'// Improved version post-challenge
}
// Record in brainstorm.md
})
Step 3.5: Merge Multiple Ideas
When user selects "merge", synthesize inline:
const merged = {
title: '...', // New merged concept namedescription: '...', // Unified concept descriptionsource_ideas: [...], // Which ideas were mergedelements_from_each: [...], // What was taken from each sourcecontradictions_resolved: [...], // How conflicts were handledcombined_strengths: [...], // New combined advantagesimplementation_considerations: '...'
}
Write(`${sessionFolder}/ideas/merged-idea-${n}.md`, formatMergedIdeaMarkdown(merged))
Append to Thought Evolution Timeline: User Direction, Decision Log, Ideas Generated/Updated, Analysis Results, Challenged Assumptions, Open Items, Narrative Synthesis.
Replace (not append):
Section
Update Rule
## Current Ideas
Overwrite with latest ranked idea list
## Table of Contents
Update links to include new Round N sections
Success Criteria:
User feedback processed for each round
brainstorm.md updated with all refinement rounds
Ideas in ideas/ folder for selected deep-dives
Exit condition reached (user selects converge or max rounds)
Phase 4: Convergence & Crystallization
Objective: Synthesize final ideas, generate conclusions and recommendations, and offer next steps.
Step 4.4: MANDATORY Terminal Gate (Post-Completion Next Step)
CRITICAL: This gate MUST execute. The workflow MUST NOT end without this functions.request_user_input call.
// Update progress โ mark phase 4 complete, activate terminal gate
functions.update_plan([
{ id: "phase-4", title: "Phase 4: Convergence & Crystallization", status: "completed" },
{ id: "next-step", title: "GATE: Post-Completion Next Step", status: "in_progress" }
])
const nextStep = functions.request_user_input({
questions: [{
header: "Next Step", // max 12 charsquestion: "Brainstorming complete. What would you like to do next?",
multiSelect: false,
options: [
{ label: "Execute Task", description: "Build implementation scope and handoff spec from top ideas" },
{ label: "Create Issue", description: "Convert top ideas into trackable issues" },
{ label: "Done", description: "End workflow, all artifacts saved" }
]
}]
})
// Handle next stepif (nextStep === "Execute Task") {
// Build implementation scope from accepted ideas// Step A: Identify scope items from top ideas// Step B: Generate handoff-spec.json with implementation details// Step C: Write handoff-spec.json to session folderWrite(`${sessionFolder}/handoff-spec.json`, JSON.stringify({
session_id: sessionId,
topic,
scope_items: acceptedIdeas.map(idea => ({
title: idea.title,
description: idea.description,
implementation_approach: idea.next_steps,
priority: idea.score >= 8 ? 'high' : idea.score >= 5 ? 'medium' : 'low',
estimated_complexity: idea.feasibility <= 2 ? 'high' : idea.feasibility <= 4 ? 'medium' : 'low'
})),
recommended_workflow: 'workflow-lite-plan or workflow-plan',
_metadata: { generated: getUtc8ISOString(), source_session: sessionId }
}, null, 2))
// Display: "Handoff spec created. Run /workflow-lite-plan to execute."
} elseif (nextStep === "Create Issue") {
// Display command for user to run manually// "/issue:from-brainstorm ${sessionFolder}" or "/issue:new ..."
}
// Mark terminal gate complete
functions.update_plan([
{ id: "next-step", title: "GATE: Post-Completion Next Step", status: "completed" }
])
Success Criteria:
synthesis.json created with complete synthesis
brainstorm.md finalized with all conclusions
Terminal gate executed with user's next-step choice
If "Execute Task": handoff-spec.json created with implementation scope
Session complete and all artifacts available
Templates
Round Documentation Pattern
Each round follows this structure in brainstorm.md:
### Round N - [DeepDive|Diverge|Challenge|Merge] (timestamp)#### User Input
What the user indicated they wanted to focus on
#### Decision Log
<!-- Use Decision Record Format from Recording Protocol -->
#### Ideas Generated
New ideas from this round with ratings
#### Analysis Results
Detailed findings from this round's analysis
- Finding 1 (evidence: file:line or rationale)
- Finding 2 (evidence: file:line or rationale)
#### Challenged Assumptions- ~~Previous assumption~~ โ New understanding
- Reason: Why the assumption was wrong
#### Open Items
Remaining questions or exploration directions
#### Narrative Synthesis
<!-- Use Narrative Synthesis Format from Recording Protocol -->
brainstorm.md Evolution Summary
Header: Session ID, topic, start time, dimensions, mode
Need multi-perspective exploration of possibilities
Want documented thought evolution showing how ideas develop
Exploring creative solutions before committing to implementation
Need diverge-converge cycles to refine ideas
Consider alternatives when:
Analyzing existing code/architecture โ use analyze-with-file
Specific bug diagnosis needed โ use debug-with-file
Complex planning with requirements โ use collaborative-plan-with-file
Ready to implement โ use lite-plan
Now start brainstorming for topic: $TOPIC
IMPORTANT: This skill is brainstorming-only. It produces analysis, perspectives, and synthesis documents but NEVER executes code, modifies source files, or auto-launches other skills. All follow-up actions require user to manually run the suggested commands.
