
brainstorm
Use this skill when exploring an open product or architecture question before choosing an approach. Activates on mentions of brainstorm, ideate, design session, explore options, what should we build, how should we approach, let's think about, new project, architecture decision, or design exploration. Skip it for a clear implementation request.
- Installs
- 611
- Last 24h
- —
- Trending rank
- —
- Security
- Not audited
Install
Works with every agent the skills CLI supports.
npx skills add https://github.com/hyperb1iss/hyperskills --skill brainstorm- 01
Install
Run the command in your project. The CLI asks which agents to install for.
- 02
Describe the task
Ask your agent for something this skill covers. It loads brainstorm automatically when relevant.
- 03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.
SKILL.md
The instructions your agent reads when the skill is triggered.
Collaborative Brainstorming
Turn uncertainty into a useful choice or a focused experiment. Explore only the questions that could change the design. A clear implementation request already supplies direction; act on it without manufacturing a brainstorm or approval gate.
The user's instructions take precedence over this skill's guidelines. Preserve their constraints and existing authorization. Resolve routine design details with judgment; ask only when missing information materially changes the outcome and cannot be inferred.
Choose the Work Shape
| Situation | Useful output |
|---|---|
| The user wants open exploration | Distinct directions with concrete tradeoffs and unresolved questions |
| The problem is clear but the mechanism is uncertain | A recommendation and the evidence that would overturn it |
| One assumption determines feasibility | A small test of that assumption before elaborating designs |
| The approach is selected and implementation is authorized | Continue into implementation |
| The user asks why something happens | Diagnose the cause before designing a fix |
Ground the Question
Read the relevant code, artifact, or workflow and recall prior decisions. When Sibyl is configured, use its installed skill for current commands (sibyl context "<decision>" --intent plan). Memory supplies leads; inspect current evidence before reusing a volatile claim.
Name the intended experience or behavior, the constraint that matters most, and what remains unknown. Treat the user's hunch as a hypothesis worth checking, not a claim to rubber-stamp. A decisive check can confirm part of the hunch and reject the rest; report both.
Translate taste into examples and observations. For "smooth," identify the interaction and visible delay. For "gorgeous," inspect the reference and name the composition, motion, or typography worth preserving. Quantification helps where a metric represents the experience; a proxy metric does not replace the experience itself.
Distinguish explicit requirements from inferred preferences. Do not downgrade "use X" to a preference merely because the user wrote casually. If the instruction conflicts with feasibility, explain the conflict and resolve it before choosing an incompatible design.
Explore the Alternatives That Matter
The Double Diamond offers a useful rhythm: widen the problem frame, narrow it, explore solutions, choose. Revisit the frame when evidence changes it. No phase requires a separate artifact or confirmation.
Generate alternatives along meaningful dimensions: ownership of state, migration cost, runtime behavior, user effort, or reversibility. Different names for the same mechanism do not create real choice. Consider reuse, configuration, or removing the need when those paths still meet the requested outcome. Include an unconventional direction when the obvious options share an untested assumption; do not invent a wildcard to fill a slot.
Compare viable options in the dimensions relevant to this decision:
| Approach | What improves | Carrying cost | Main uncertainty | Decisive check |
|---|---|---|---|---|
| [Mechanism] | [User or system outcome] | [Maintenance, runtime, migration] | [What could invalidate it] | [Experiment or evidence] |
Keep ambition and mechanism separate. Simplifying the machinery should preserve the useful destination. A small implementation that proves only connectivity may miss the actual product; an elaborate one may bury it. Use expected lifetime and likely change boundaries to judge architecture, rather than equating fewer lines with better design.
Before extending a design, ask where each responsibility belongs. A decision repeated across callers may need one owner. A wrapper may instead be enforcing a valuable boundary. Remove indirection after understanding its contract, not because forwarding looks trivial.
Test the Uncertainty Before Polishing
Choose the next action by its ability to change the decision. A compatibility check, representative benchmark, or rough interaction prototype can settle more than another design paragraph.
| Evidence gap | Next move |
|---|---|
| An API or model capability may have changed | Open current primary documentation and inspect the installed version |
| Performance determines feasibility | Test a representative workload with a baseline and explicit resource limits |
| Several independent domains affect the choice | Delegate bounded research when permitted, or batch independent reads locally |
| Stakeholders value different outcomes | Surface the actual value tradeoff for the user |
| A favored approach has weak support | Seek a concrete counterexample or failure condition |
Independent opinions can expose assumptions, but agreement is not proof. Reviewers may share training, sources, or framing. Resolve consequential disagreements through code, source material, or an experiment. State when evidence remains inconclusive.
Decide and Preserve the Reason
Recommend the best-supported direction with its principal tradeoff and the next action. Keep exploration open when that is the requested deliverable; do not force a build decision prematurely. Continue authorized work once the direction is clear. A remaining product or risk decision belongs with the user, but implementation details do not require a new consent question.
For a durable decision, record the choice, rationale, rejected alternative worth remembering, evidence, and condition that would trigger reconsideration. Preserve deliberately open decisions and user corrections verbatim when paraphrase would narrow them. Use configured project memory rather than creating duplicate decision ledgers.
Route unresolved factual questions to research, complex execution to plan, and a clear bounded change to implement. These are optional compositions, not a mandatory pipeline.
Evidence and Limits
Reviewed 2026-09-04. The Design Council's Double Diamond describes iterative divergence and convergence; it does not prescribe option counts or divide judgment between humans and models. Treat it as a design aid, not an effectiveness benchmark.
The OpenAI Astra guidance recommends explicit instruction precedence and follow-through because conflicting skill guidance can cause unnecessary pauses. Apply that to workflow clarity without assuming every host exposes the same capabilities.
Anti-Patterns
| Anti-pattern | Better move |
|---|---|
| Brainstorm before every code edit | Explore only unresolved direction |
| Ask the user to reconfirm known constraints | Carry prior authorization and decisions forward |
| Offer options that differ only cosmetically | Compare different mechanisms or tradeoffs |
| Treat reviewer consensus as validation | Check the claim against independent evidence |
| Polish an approach with an untested premise | Run the feasibility check first |
| Turn an anecdote into a universal rule | Retain the mechanism and state its conditions |
What This Skill is NOT
- A prerequisite for implementation, debugging, or routine fixes.
- A requirement to produce a spec, a fixed number of options, or a final approval question.
- A substitute for the user's product judgment or current technical evidence.
FAQ
What does the brainstorm skill do?
Use this skill when exploring an open product or architecture question before choosing an approach. Activates on mentions of brainstorm, ideate, design session, explore options, what should we build, how should we approach, let's think about, new project, architecture decision, or design exploration. Skip it for a clear implementation request.
How do I install brainstorm?
Run npx skills add https://github.com/hyperb1iss/hyperskills --skill brainstorm in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/brainstorm/ (personal) or .claude/skills/brainstorm/ (project).
Which AI agents can use brainstorm?
Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.
Is brainstorm safe to install?
No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.
Who maintains brainstorm?
It is published by hyperb1iss in hyperb1iss/hyperskills. It has 611 recorded installs.
More from hyperb1iss/hyperskills
tui-design
hyperb1iss/hyperskills
Use this skill when designing terminal user interfaces, creating TUI layouts, choosing TUI color schemes, implementing keyboard navigation, building terminal dashboards, or working with any TUI framework. Activates on mentions of TUI design, terminal UI, Ratatui layout, Ink components, Textual widgets, Bubbletea views, terminal color palette, keybinding design, panel layout, split panes, terminal dashboard, box-drawing characters, sparklines, progress bars, modal dialogs, focus management, or terminal accessibility.
orchestrate
hyperb1iss/hyperskills
Use this skill when coordinating independent agents with explicit ownership, dependencies, integration, and verification. Activates on mentions of swarm, parallel agents, multi-agent, orchestrate, fan-out, wave dispatch, research army, unleash, dispatch agents, or parallel work.
research
hyperb1iss/hyperskills
Use this skill when gathering and evaluating evidence for a technical decision, SOTA analysis, or codebase investigation. Activates on mentions of research, investigate, evaluate options, what's the best, compare alternatives, state of the art, deep dive, explore the landscape, or find out how.
codex-review
hyperb1iss/hyperskills
Use this skill for code reviews using the Codex CLI from a Claude-hosted session. Activates on mentions of codex review, code review with codex, codex check, gpt review, codex exec review, run codex, review my code, review this PR, review changes, peer review, or second opinion.
plan
hyperb1iss/hyperskills
Use this skill when decomposing complex work into verifiable tasks and dependencies before or during implementation. Activates on mentions of write a plan, create a plan, break this down, task decomposition, implementation plan, what are the steps, plan the work, spec this out, or decompose this feature.
implement
hyperb1iss/hyperskills
Use this skill when writing code, building features, fixing bugs, refactoring, or performing multi-step implementation work. Activates on mentions of implement, build this, code this, start coding, fix this bug, refactor, make changes, develop this feature, coding task, write the code, or start building.
Popular code quality & workflow skills
grill-me
mattpocock/skills
A relentless interview to sharpen a plan or design.
improve-codebase-architecture
mattpocock/skills
Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.
handoff
mattpocock/skills
Compact the current conversation into a handoff document for another agent to pick up.
domain-modeling
mattpocock/skills
Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a GLOSSARY.md, or recording or editing an ADR.
codebase-design
mattpocock/skills
Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.
diagnosing-bugs
mattpocock/skills
Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.