Skip to main content
brainstorming Collaborative ideation and planning with resilient multi-model exploration, consensus scoring, and adaptive confidence-based validation
Ir para a instalação Skills Marketplace Descubra e explore skills de IA criadas pela comunidade.
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Mostrar detalhes do prompt Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
npx skills add https://github.com/MadAppGang/claude-code --skill brainstormingO comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.
Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.
Baixar Zip Baixando... SOC
Baseado na classificação ocupacional SOC
name brainstorming version 2.0.0 description Collaborative ideation and planning with resilient multi-model exploration, consensus scoring, and adaptive confidence-based validation author MAG Claude Plugins tags ["planning","ideation","collaboration","multi-model","resilient"] dependencies {"skills":["superpowers:using-git-worktrees","superpowers:writing-plans"],"tools":["Task","TaskCreate","TaskUpdate","TaskList","TaskGet","Read","Write","Edit","Glob"],"models":{"primary":["anthropic/claude-opus-4-20250514","anthropic/claude-sonnet-4-20250514","anthropic/claude-haiku-3-20250514"],"explorers":{"fallback_chain":["x-ai/grok-code-fast-1","google/gemini-2-5-pro","deepseek/deepseek-coder","anthropic/claude-sonnet-4-20250514","anthropic/claude-haiku-3-20250514"]}}} parameters {"exploration_models":3,"chunk_size":250,"confidence_threshold_auto":95,"confidence_threshold_confirm":60,"retry_attempts":2,"timeout_per_model_ms":120000} gates [{"phase":0,"type":"USER_GATE","trigger":"Problem understanding validated"},{"phase":1,"type":"AUTO_GATE","trigger":"Parallel exploration consolidated"},{"phase":2,"type":"AUTO_GATE","trigger":"Consensus scores calculated"},{"phase":3,"type":"USER_GATE","trigger":"User selects approach"},{"phase":4,"type":"MIXED_GATE","trigger":"Section-by-section validation"},{"phase":5,"type":"USER_GATE","trigger":"Final plan approval"}]
Brainstorming v2.0: Resilient Multi-Model Planning
Turn ideas into validated designs through collaborative AI dialogue with resilient model execution and confidence-based validation.
Overview
This skill improves upon v1.0 by addressing critical reliability gaps:
Key v2.0 Improvements:
No AskUserQuestion dependency : Uses Task + Tasks for structured interactionFallback chains : 3+ models per role ensures completion even if some failExplicit parallelism : Documented Task call patterns for parallel executionDefined algorithms : Consensus matrix and confidence scoring are mathematically specified
When to Use
Use this skill BEFORE implementing any feature:
"Design a user authentication system"
"Brainstorm approaches for API rate limiting"
"Plan architecture for a new dashboard feature"
"Evaluate options for real-time data synchronization"
Prerequisites
Required Setup
/plugin marketplace add MadAppGang/claude-code
skill install superpowers:using-git-worktrees
skill install superpowers:writing-plans
export OPENROUTER_API_KEY=your-key
{
"brainstorming" : {
"primary_model" : "anthropic/claude-opus-4-20250514" ,
"explorer_models" : [
"x-ai/grok-code-fast-1" ,
"google/gemini-2-5-pro" ,
"anthropic/claude-sonnet-4-20250514"
]
}
}
Model Requirements
Role Min Context Capabilities Primary 200K tokens Complex reasoning, orchestration Explorer 100K tokens Code generation, analysis
Workflow
Phase 0: Problem Analysis (200-300 words)
Objective : Capture problem scope, constraints, and success criteria
How to Ask Users (Without AskUserQuestion)
await Write ({
file_path : "/tmp/brainstorm-q1.md" ,
content : `## Question 1 of 3
**What are the main constraints or requirements for this feature?**
Please respond with:
- Functional requirements (what it must do)
- Non-functional requirements (performance, scale)
- Any existing dependencies or integrations
`
});
const problemSummary = await Write ({
file_path : "/tmp/brainstorm-problem.md" ,
content : `## Problem Understanding
**Constraints identified:**
- [From user response]
**Success criteria:**
- [Measurable outcomes]
**Scope boundaries:**
- [What's in/out]
---
**Does this accurately capture the problem?** (Reply "yes" to proceed or clarify)
`
});
Gate Type : USER_GATE (requires confirmation)
Phase 1: Parallel Exploration Objective : Generate diverse solutions via multi-model brainstorming
Fallback Chain Implementation :
interface ModelResult {
model : string ;
success : boolean ;
output ?: string ;
error ?: string ;
}
async function exploreWithFallback (
prompt : string ,
role : "explorer"
): Promise <ModelResult > {
const fallbackModels = role === "explorer"
? ["x-ai/grok-code-fast-1" , "google/gemini-2-5-pro" , "deepseek/deepseek-coder" ]
: ["anthropic/claude-opus-4-20250514" , "anthropic/claude-sonnet-4-20250514" ];
for (const model of fallbackModels) {
try {
const result = await Task ({
model : model,
prompt : prompt,
timeout_ms : 120000
});
return { model, success : true , output : result };
} catch (error) {
console .warn (`Model ${model} failed:` , error.message );
continue ;
}
}
throw new Error (`All models in fallback chain failed` );
}
Parallel Execution Pattern :
const [result1, result2, result3] = await Promise .all ([
Task ({
model : "x-ai/grok-code-fast-1" ,
prompt : generateExplorerPrompt (problem, "fast_code" )
}),
Task ({
model : "google/gemini-2-5-pro" ,
prompt : generateExplorerPrompt (problem, "balanced" )
}),
Task ({
model : "anthropic/claude-sonnet-4-20250514" ,
prompt : generateExplorerPrompt (problem, "thorough" )
})
]);
const results = [result1, result2, result3].filter (r =>success );
if (results.length === 0 ) {
throw new Error ("All exploration models failed" );
}
## Approach: [Name]
**Model** : [Which model generated this]
**Approach Type** : [architecture/algorithm/pattern]
**Summary** : 2-3 sentences
**Key Components** :
1. Component A
2. Component B
3. Component C
**Trade-offs** :
- + Advantage
- - Disadvantage
**Confidence** : [Model's confidence 0-100]
Gate Type : AUTO_GATE (automatic consolidation)
Phase 2: Consensus Analysis Objective : Identify strongest ideas using defined algorithms
Consensus Matrix Algorithm :
Clustering : Group approaches by semantic similarity (vector embedding + clustering)Scoring : Count model agreement per clusterClassification : UNANIMOUS (3/3), STRONG (2/3), DIVERGENT (1/3)Confidence : Weighted average of model confidences + agreement bonus Consensus Matrix Calculation :
interface Approach {
id : string ;
name : string ;
summary : string ;
model : string ;
modelConfidence : number ;
embedding : number [];
}
interface Cluster {
approaches : Approach [];
representative : Approach ;
agreementScore : number ;
confidenceScore : number ;
consensusLevel : "UNANIMOUS" | "STRONG" | "DIVERGENT" ;
}
function calculateConsensus (approaches : Approach []Cluster [] {
const clusters = clusterByEmbedding (approaches, threshold : 0.85 );
return clusters.map (cluster =>const models = cluster.map (a =>model );
const modelCount = new Set (models).size ;
const totalModels = approaches.length ;
const agreementScore = modelCount / totalModels;
const baseConfidence = cluster
.map (a =>modelConfidence )
.reduce ((a, b ) => a + b, 0 ) / cluster.length ;
const confidenceScore = Math .min (100 ,
baseConfidence + (agreementScore * 20 )
);
const consensusLevel = agreementScore >= 0.9 ? "UNANIMOUS" :
agreementScore >= 0.5 ? "STRONG" :
"DIVERGENT" ;
return {
approaches : cluster,
representative : cluster.reduce ((best, current ) =>
current.modelConfidence > best.modelConfidence ? current : best
),
agreementScore,
confidenceScore : Math .round (confidenceScore),
consensusLevel
};
}).sort ((a, b ) => b.confidenceScore - a.confidenceScore );
}
Confidence Scoring Formula :
Confidence = Base + AgreementBonus - DiversityPenalty
Where:
Base = average(model confidences in cluster)
AgreementBonus = (unique_models / total_models) * 20
DiversityPenalty = (1 - similarity_coefficient) * 10
Example:
3 models propose similar approaches
Base = (92 + 88 + 95) / 3 = 91.7
AgreementBonus = (3/3) * 20 = 20
DiversityPenalty = (1 - 0.9) * 10 = 1
Confidence = 91.7 + 20 - 1 = 110.7 -> capped at 100
Final: 97%
Consensus Matrix Example :
Approach Grok Gemini Sonnet Agreement Confidence Token Bucket Yes Yes Yes UNANIMOUS 97% Leaky Bucket Yes Yes No STRONG 82% Sliding Window No No Yes DIVERGENT 45%
Gate Type : AUTO_GATE (automatic scoring)
Phase 3: User Selection Objective : Present top approaches for user decision
async function presentApproaches (clusters : Cluster []Promise <string > {
const topClusters = clusters.slice (0 , 5 );
let presentation = `## Top Approaches\n\n` ;
for (const [index, cluster] of topClusters.entries ()) {
const approach = cluster.representative ;
presentation += `### ${String .fromCharCode(65 + index)} : ${approach.name} [${cluster.consensusLevel} ]
**Summary**: ${approach.summary}
**Confidence**: ${cluster.confidenceScore} % (${cluster.approaches.length} model(s) agree)
**Pros**:
${cluster.approaches.map(a => `- ${a.summary} ` ).join("\n" )}
**Cons**:
${cluster.approaches.map(a => `- Potential issue from ${a.model} ` ).join("\n" )}
---
` ;
}
presentation += `
## Your Choice
Which approach best fits your requirements?
- **A**: Select approach A
- **B**: Select approach B
- **C**: Select approach C
- **D**: Combine elements from multiple
- **E**: Explore alternatives (return to Phase 1)
` ;
await Write ({
file_path : "/tmp/brainstorm-approaches.md" ,
content : presentation
});
return presentation;
}
Gate Type : USER_GATE (selection via conversation)
Phase 4: Detailed Planning Objective : Elaborate selected approach into actionable sections
Confidence Gate Type Action >=95% AUTO_GATE Proceed automatically 80-94% AUTO_GATE Proceed with notification 60-79% USER_GATE Request confirmation <60% USER_GATE Require revision
## [Section Name] (Confidence: XX%)
**Approach** : [Selected approach]
**Implementation Details** :
[200-300 words]
**Assumptions** :
- Assumption 1
- Assumption 2
**Confidence Calculation** :
- Technical feasibility: XX%
- Edge cases covered: XX%
- Team capability: XX%
- Overall: XX%
**Status** : [AUTO_GATE|PENDING_ USER] - [Reason]
Gate Type : MIXED_GATE (adaptive)
Phase 5: Plan Validation Objective : Final review before implementation
## Plan Validation
**Problem** : [Summary]
**Approach** : [Selected]
**Confidence** : [Overall]
### Checklist
- [ ] Problem scope accurately captured
- [ ] Chosen approach matches expectations
- [ ] Module structure aligns with capabilities
- [ ] Technical constraints addressed
- [ ] Success criteria measurable
### Next Steps
**To proceed** :
1. Reply "approve" to finalize
2. Reply "revise [section]" to modify
3. Reply "restart" to begin fresh
**Final decision?**
Gate Type : USER_GATE (explicit approval)
Complete Parallel Execution Example
async function runParallelExploration (problem : string Promise <Approach []> {
const explorerModels = [
"x-ai/grok-code-fast-1" ,
"google/gemini-2-5-pro" ,
"anthropic/claude-sonnet-4-20250514"
];
const prompts = explorerModels.map (model =>`Generate 5 implementation approaches for: ${problem}
For each approach provide:
1. Name (2-3 words)
2. One-sentence summary
3. Key components (bullet points)
4. Trade-offs (+/-)
5. Your confidence (0-100)
Format as JSON array.`
);
const taskPromises = explorerModels.map ((model, index ) =>
Task ({
model : model,
prompt : prompts[index],
timeout_ms : 120000 ,
max_turns : 1
}).catch (error =>success : false ,
error : error.message
}))
);
const results = await Promise .all (taskPromises);
const approaches : Approach [] = results
.filter (r =>success )
.flatMap (r =>parseApproaches (r.output ));
if (approaches.length < 5 ) {
console .warn (`Only got ${approaches.length} approaches from ${explorerModels.length} models` );
if (approaches.length === 0 ) {
throw new Error ("All models failed" );
}
}
return approaches;
}
Troubleshooting
Model Failures Symptom Cause Solution Single model fails API error, timeout Fallback chain handles automatically All models fail API key issue, network Check OPENROUTER_API_KEY, retry Partial results (2/3) One model unavailable Continue with available; lower diversity but valid
async function resilientExploration (problem : string Promise <Approach []> {
let attempts = 0 ;
const maxAttempts = 3 ;
while (attempts < maxAttempts) {
try {
return await runParallelExploration (problem);
} catch (error) {
attempts++;
if (attempts === maxAttempts) throw error;
await new Promise (r =>setTimeout (r, Math .pow (2 , attempts) * 1000 ));
}
}
}
Consensus Issues Symptom Cause Solution All approaches DIVERGENT Models produce very different ideas Not a failure - indicates novel problem Single cluster with 90%+ confidence Problem is well-understood Good for AUTO_GATE No clear winner Multiple valid approaches Present all to user
User Interaction Issues Symptom Cause Solution User doesn't respond Unclear question Rewrite with specific format User provides conflicting answers Multiple questions at once Ask one at a time, confirm understanding User wants to restart Dissatisfied with direction Allow restart to Phase 0
Configuration
Environment Variables
OPENROUTER_API_KEY=...
BRAINSTORM_TIMEOUT_MS=120000
BRAINSTORM_MAX_RETRIES=2
BRAINSTORM_MIN_MODELS=2
Model Configuration {
"brainstorming" : {
"primary" : [ "anthropic/claude-opus-4-20250514" ] ,
"explorers" : {
"primary_chain" : [ "x-ai/grok-code-fast-1" , "google/gemini-2-5-pro" ] ,
"fallback_chain" : [ "deepseek/deepseek-coder" , "anthropic/claude-haiku-3-20250514" ]
} ,
"thresholds" : {
"auto_gate" : 95 ,
"confirm_gate" : 60
}
}
}
Performance Metric v1.0 v2.0 Improvement Model failure recovery 0% 95% Fallback chains Consensus calculation Undefined Defined Mathematically specified User interaction AskUserQuestion Task+Write No tool dependency Parallel execution Implicit Explicit Documented patterns
Comparison: v1.0 vs v2.0 Aspect v1.0 v2.0 AskUserQuestion Required Removed Model fallbacks None 3+ per role Parallel pattern Described Code example Consensus algorithm Table example Full implementation Confidence formula Mentioned Math specified Troubleshooting 4 items 10+ items Prerequisites None Setup guide
Version History
Removed AskUserQuestion dependency
Added model fallback chains
Explicit parallel execution patterns
Defined consensus matrix algorithm
Added confidence scoring formula
Added prerequisites and setup guide
Expanded troubleshooting section
Winner of blind multi-model voting (3/3 votes, avg confidence 8.7/10)
Initial release
6-phase workflow
Multi-model exploration
Confidence-based gating
Status : v2.0 Ready for use
Tested : Fallback chains, parallel execution, consensus algorithm
Known Limitations : Requires OpenRouter for multi-model access
