القائمة
Collaborative ideation and planning with resilient multi-model exploration, consensus scoring, and adaptive confidence-based validation
يُحدَّد Prompt الذي يراجع المصدر أولًا بشكل افتراضي. يمكنك التبديل إلى أمر مباشر أو تنزيل نسخة محلية.
اقرأ SKILL.md وأي ملفات مرافقة يعرضها SkillsMP قبل أن تقرر التثبيت.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/MadAppGang/claude-code --skill brainstormingيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
استنادا إلى تصنيف SOC المهني
Use when starting isolated feature work or before executing implementation plans. Manages full worktree lifecycle from creation through cleanup with safety checks and error recovery.
Configuration reference and troubleshooting for the statusline plugin — sections, themes, bar widths, and script architecture
Common agent patterns and templates for Claude Code. Use when implementing agents to follow proven patterns for Tasks integration, quality checks, and external model invocation via claudish CLI.
عرض SKILL.md
| 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"}] |
Turn ideas into validated designs through collaborative AI dialogue with resilient model execution and confidence-based validation.
This skill improves upon v1.0 by addressing critical reliability gaps:
Key v2.0 Improvements:
Use this skill BEFORE implementing any feature:
# 1. Install required skills
/plugin marketplace add MadAppGang/claude-code
skill install superpowers:using-git-worktrees
skill install superpowers:writing-plans
# 2. Verify OpenRouter access (for multi-model)
export OPENROUTER_API_KEY=your-key
# 3. Configure models in ~/.claude/settings.json
{
"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"
]
}
}
| Role | Min Context | Capabilities |
|---|---|---|
| Primary | 200K tokens | Complex reasoning, orchestration |
| Explorer | 100K tokens | Code generation, analysis |
Objective: Capture problem scope, constraints, and success criteria
How to Ask Users (Without AskUserQuestion):
// Pattern: Use Tasks to track questions, Read/Write for presentation
// 1. Write question to temp file
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
`
});
// 2. Present file and wait for user response
// User reads file, provides input via conversation
// 3. Summarize understanding
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)
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 // 2 minute timeout
});
return { model, success: true, output: result };
} catch (error) {
console.warn(`Model ${model} failed:`, error.message);
continue;
}
}
();
}
Parallel Execution Pattern:
// WRONG: Sequential (slow)
// const result1 = await Task({ model: "grok", ... });
// const result2 = await Task({ model: "gemini", ... });
// const result3 = await Task({ model: "sonnet", ... });
// CORRECT: Parallel (3-5x faster)
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")
})
]);
// Handle partial failures
const results = [result1, result2, result3].filter(r => r.success);
if (results.length === 0) {
throw new Error("All exploration models failed");
}
Output Format:
## 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)
Objective: Identify strongest ideas using defined algorithms
Consensus Matrix Algorithm:
Consensus Matrix Calculation:
interface Approach {
id: string;
name: string;
summary: string;
model: string; // Which model proposed
modelConfidence: number; // 0-100
embedding: number[]; // For clustering
}
interface Cluster {
approaches: Approach[];
representative: Approach; // Most complete
agreementScore: number; // 0-1
confidenceScore: number; // 0-100
consensusLevel: "UNANIMOUS" | "STRONG" | "DIVERGENT";
}
function calculateConsensus(approaches: Approach[]): Cluster[] {
// Step 1: Cluster by semantic similarity
const clusters = clusterByEmbedding(approaches, threshold: 0.85);
// Step 2: Calculate metrics per cluster
return clusters.map(cluster => {
const models = cluster.( a.);
modelCount = (models).;
totalModels = approaches.;
agreementScore = modelCount / totalModels;
baseConfidence = cluster
.( a.)
.( a + b, ) / cluster.;
confidenceScore = .(,
baseConfidence + (agreementScore * )
);
consensusLevel = agreementScore >= ? :
agreementScore >= ? :
;
{
: cluster,
: cluster.(
current. > best. ? current : best
),
agreementScore,
: .(confidenceScore),
consensusLevel
};
}).( b. - a.);
}
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)
Objective: Present top approaches for user decision
Presentation Pattern:
async function presentApproaches(clusters: Cluster[]): Promise<string> {
const topClusters = clusters.slice(0, 5); // Top 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)
`;
// Save for user review
await Write({
file_path: "/tmp/brainstorm-approaches.md",
content: presentation
});
presentation;
}
Gate Type: USER_GATE (selection via conversation)
Objective: Elaborate selected approach into actionable sections
Confidence-Based Gating:
| 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 Template:
## [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)
Objective: Final review before implementation
Validation Checklist:
## 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 Phase 1 parallel exploration
async function runParallelExploration(problem: string): Promise<Approach[]> {
const explorerModels = [
"x-ai/grok-code-fast-1", // Fast, code-focused
"google/gemini-2-5-pro", // Balanced, creative
"anthropic/claude-sonnet-4-20250514" // Thorough
];
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.`
);
// LAUNCH ALL MODELS IN PARALLEL
const taskPromises = explorerModels.map((model, index) =>
Task({
model: model,
prompt: prompts[index],
timeout_ms: 120000,
max_turns: 1
}).catch(error => ({
model,
success: false,
error: error.message
}))
);
// WAIT FOR ALL TO COMPLETE
const results = await Promise.all(taskPromises);
: [] = results
.( r.)
.( (r.));
(approaches. < ) {
.();
(approaches. === ) {
();
}
}
approaches;
}
| 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 |
Recovery Pattern:
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;
// Exponential backoff
await new Promise(r => setTimeout(r, Math.pow(2, attempts) * 1000));
}
}
}
| 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 |
| 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 |
# Required for multi-model
OPENROUTER_API_KEY=...
# Optional
BRAINSTORM_TIMEOUT_MS=120000
BRAINSTORM_MAX_RETRIES=2
BRAINSTORM_MIN_MODELS=2 # Minimum models for valid consensus
{
"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
}
}
}
| 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 |
| 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 |
v2.0.0 (2026-01-30):
v1.0.0 (2026-01-30):
Status: v2.0 Ready for use Tested: Fallback chains, parallel execution, consensus algorithm Known Limitations: Requires OpenRouter for multi-model access