playbooks

home / skills / htooayelwinict / claude-config / brainstorming

brainstorming skill

/skills/brainstorming

This skill helps you brainstorm and advise on technical decisions using structured processes and MCP helpers, delivering a documented, consensus-ready plan.

npx playbooks add skill htooayelwinict/claude-config --skill brainstorming

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
2.6 KB
---
name: brainstorming
description: Brainstorm and advise on technical decisions using structured process and MCP helpers. EXCLUSIVE to brainstormer agent. Does NOT implement — only advises.
allowed-tools: Read, Grep, Glob, Bash, WebFetch, mcp_gemini-bridge, mcp_open-bridge, mcp_codex-bridge, mcp_context7
---
# Brainstorming

**Exclusive to:** `brainstormer` agent

> ⚠️ **CRITICAL**: This skill is for brainstorming and advising ONLY. Do NOT implement solutions.

## MCP Helpers (Brain + Memory)

### 🧠 Gemini-Bridge (Brain)
Use for deep reasoning, architecture analysis, and creative problem-solving:
```
mcp_gemini-bridge_consult_gemini(query="Analyze trade-offs for [topic]...", directory=".")
```

### 🌉 Open-Bridge
Alternative deep reasoning:
```
mcp_open-bridge_consult_gemini(query="Analyze trade-offs for [topic]...", directory=".")
```

### 📚 Context7 (Memory)
Use for up-to-date library docs and best practices:
```
mcp_context7_resolve-library-id(libraryName="[lib]", query="[topic]")
mcp_context7_query-docs(libraryId="/[id]", query="[specific question]")
```

## Instructions

1. **Discover** — Ask clarifying questions about requirements, constraints, timeline
2. **Research** — Gather information from codebase and external sources
3. **Analyze** — Evaluate multiple approaches with pros/cons
4. **Debate** — Present options, challenge assumptions, find optimal solution
5. **Consensus** — Ensure alignment on chosen approach
6. **Document** — Create comprehensive summary report

## Output Template

```markdown
# Brainstorm Summary: [Topic]

## Problem Statement
[Description]

### Requirements
- [Requirement]

### Constraints
- [Constraint]

## Evaluated Approaches

### Option A: [Name]
| Pros | Cons |
|------|------|
| [Pro] | [Con] |

### Option B: [Name]
[Same structure]

## Recommended Solution
[Decision and rationale]

## Risks & Mitigations
| Risk | Impact | Mitigation |
|------|--------|------------|

## Success Metrics
- [ ] [Metric]

## Next Steps
1. [Step] — [Owner]
```

## Decision Frameworks

### Weighted Criteria
| Criteria | Weight |
|----------|--------|
| Feasibility | 30% |
| Maintainability | 25% |
| Performance | 20% |
| Time to build | 25% |

### SCAMPER
- **S**ubstitute — What can be replaced?
- **C**ombine — What can be merged?
- **A**dapt — What can we borrow?
- **M**odify — What can change?
- **P**ut to other uses — New applications?
- **E**liminate — What can be removed?
- **R**everse — What if opposite?

## Examples
- "Brainstorm architecture for feature X"
- "Compare these two technical approaches"
- "Help me decide between options"

Overview

This skill provides a structured brainstorming and advisory process for technical decisions, exclusive to the brainstormer agent. It guides discovery, research, analysis, debate, consensus, and documentation without implementing code. The output focuses on clear trade-offs, decision rationale, and actionable next steps.

How this skill works

The skill uses MCP helper patterns (deep-reasoning bridge and memory/document lookups) to gather context, analyze options, and produce a formal Brainstorm Summary. It inspects requirements, constraints, codebase context, and up-to-date library docs to evaluate multiple approaches with pros/cons. The result is a decision-ready recommendation, risk analysis, and prioritized next steps for stakeholders.

When to use it

  • Planning architecture for a new feature or service
  • Choosing between competing technical approaches or libraries
  • Evaluating trade-offs for scalability, cost, or maintenance
  • Preparing a decision brief for engineering leadership
  • Aligning a cross-functional team on a technical direction

Best practices

  • Start with clarifying questions to capture requirements, constraints, and timeline
  • Use memory/document lookups to verify current libraries and implementation details before analysis
  • Compare at least two distinct approaches with clear pros/cons and weighted criteria
  • Quantify key success metrics and acceptance criteria to measure outcomes
  • Document risks, mitigations, and concrete next steps with owners and timelines

Example use cases

  • Brainstorm architecture for feature X and produce a decision brief
  • Compare monolith vs microservices for a migration project and recommend a path
  • Evaluate storage and caching options for high-throughput workloads
  • Decide between two third-party libraries based on maintenance, performance, and ecosystem
  • Create a prioritized implementation plan and success metrics for a chosen approach

FAQ

Can this skill write or modify production code?

No. This skill advises only. It produces analysis, recommendations, and documentation but does not implement or modify code.

What helper tools does the skill rely on?

It leverages deep-reasoning bridges for architecture analysis and memory/document lookups to fetch up-to-date library docs and best practices before making recommendations.