Skip to main content
skill CX Codex

oma-brainstorm · first-fluke, oma — Claude Code skill: design before planning

oma-brainstorm — a skill for exploring intent, constraints, and alternative approaches before planning or coding. Use it when you have an idea but the path forward is unclear.

MIT ★ 1,472 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add first-fluke/oh-my-agent
/plugin install oma@oh-my-agent
Open on GitHub

What oma-brainstorm does

oma-brainstorm pauses before the plan and the code. Instead of jumping into tasks, it asks clarifying questions one at a time, lays out two or three approaches with tradeoffs, and waits for approval at each design stage. This catches design mistakes that would otherwise ripple through the entire build.

The skill moves through phases: it first reads your project context, then asks targeted questions to understand what you need and why, proposes multiple approaches with pros and cons, and collects sign-off section by section. Once the design is approved, it saves the artifact to docs/plans/designs/ and hands off to planning. Skip this skill if requirements are already locked in—go straight to planning instead. If you need to write code, route to other agents; to review existing work, use QA.

What it helps with

  • pick the right approach before starting code
  • clarify vague or incomplete requirements
  • weigh multiple solutions against tradeoffs
  • document decisions in a design file for the team
  • move from idea to plan without false starts

Example prompts for the agent

  • I want to build an API for data sync, but should it use webhooks or polling?
  • Let's design an auth system for our app from scratch
  • Help me figure out caching strategy: Redis or in-process memory?

How to install oma-brainstorm

1Plugin marketplace

/plugin marketplace add first-fluke/oh-my-agent
/plugin install oma@oh-my-agent

This installs the whole oma plugin with all its skills

2Skills CLI (Vercel)

npx skills add first-fluke/oh-my-agent --skill oma-brainstorm -a claude-code

3Manually: put the files in place

~/.claude/skills/oma-brainstorm/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/oma-brainstorm/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about oma-brainstorm

How do I install oma-brainstorm in Claude Code?

Run /plugin marketplace add first-fluke/oh-my-agent, then /plugin install oma@oh-my-agent, then npx skills add first-fluke/oh-my-agent --skill oma-brainstorm -a claude-code. The skill loads from ~/.claude/skills/oma-brainstorm/SKILL.md.

What does oma-brainstorm do?

It guides design before code: asks one clarifying question at a time, presents two or three approaches with tradeoff analysis, gets your sign-off on each section, and saves a design document for handoff to planning.

When should I skip this skill?

If requirements are already clear, move to planning. If you're ready to implement, use other agents. To review code, call QA; to debug, use the debug agent.

Source text

SKILL.md · MIT
---
name: oma-brainstorm
description: Design-first ideation that explores user intent, constraints, and approaches before any planning or implementation. Use for brainstorming, ideation, exploring concepts, and evaluating approaches.
---

# Brainstorm - Design-First Ideation

## Scheduling

### Goal
Explore user intent, constraints, and alternative approaches before planning or implementation, then preserve an approved design for downstream planning.

### Intent signature
- User says they have an idea, want to brainstorm, compare approaches, explore concepts, or design before planning.
- Request is ambiguous enough that implementation or task planning would be premature.

### When to use
- Exploring a new feature idea before planning
- Understanding user intent and constraints before committing to an approach
- Comparing multiple design approaches with trade-offs
- When the user says "I have an idea" or "let's design something"
- Before invoking `/plan` for complex or ambiguous requests

### When NOT to use
- Requirements are already clear and well-defined -> use pm-agent directly
- Implementing actual code -> delegate to specialized agents
- Performing code reviews -> use QA Agent
- Debugging existing issues -> use debug-agent

### Expected inputs
- Early idea, ambiguous goal, product concept, design question, or set of constraints
- Existing project context when the idea must fit a codebase or product direction
- User preferences and approval gates

### Expected outputs
- Clarified intent and constraints
- Two or three approaches with tradeoffs and a recommended option
- Section-by-section approved design document
- Saved design artifact before handoff to planning

### Dependencies
- Shared context loading, reasoning templates, clarification protocol, quality principles, and skill routing
- Downstream PM workflow for task decomposition after design approval

### Control-flow features
- Branches by ambiguity, user answers, approach comparison, and approval gates
- Asks one question at a time
- Stops before implementation or task planning

## Structural Flow

### Entry
1. Confirm that the request is exploratory rather than ready for implementation.
2. Load enough project context to understand constraints.
3. Start with intent and constraints, not solutions.

### Scenes
1. **PREPARE**: Explore context and frame the design question.
2. **ACQUIRE**: Ask clarifying questions one at a time.
3. **REASON**: Generate two or three approaches with tradeoffs.
4. **VERIFY**: Get user approval section by section.
5. **FINALIZE**: Save design and transition to planning when appropriate.

### Transitions
- If requirements become clear and implementation-ready, transition to PM planning.
- If user rejects an approach, revise before moving to detailed design.
- If implementation pressure appears early, defer it until design approval.

### Failure and recovery
- If the user cannot answer a question, propose assumptions and ask for confirmation.
- If scope expands, split the design into smaller sections.
- If alternatives collapse into one option, identify the real constraint causing that.

### Exit
- Success: approved design exists and is ready for planning.
- Partial success: open questions and assumptions are explicit.

## Logical Operations

### Actions
| Action | SSL primitive | Evidence |
|--------|---------------|----------|
| Read context and idea | `READ` | User prompt and project context |
| Ask targeted questions | `REQUEST` | Clarification phase |
| Compare approaches | `COMPARE` | Tradeoff matrix |
| Infer recommendation | `INFER` | Recommended option |
| Validate approval | `VALIDATE` | Section-by-section confirmation |
| Write design artifact | `WRITE` | `docs/plans/designs/` and memory |
| Transition to plan | `NOTIFY` | Handoff summary |

### Tools and instruments
- Context loading, reasoning templates, clarification protocol
- Project memory and `docs/plans/designs/` for persisted designs

### Canonical workflow path
```text
1. Ask one clarifying question at a time.
2. Present 2-3 approaches with tradeoffs and a recommended option.
3. Save the approved design to `docs/plans/designs/` before handing off to planning.
```

### Resource scope
| Scope | Resource target |
|-------|-----------------|
| `MEMORY` | User intent, assumptions, decisions |
| `CODEBASE` | Existing project context when relevant |
| `LOCAL_FS` | Approved design artifacts |

### Preconditions
- The user is still exploring or the request is ambiguous.
- The agent can ask clarifying questions before implementation.

### Effects and side effects
- Produces design decisions and persisted design docs.
- Influences downstream planning but does not implement code.

### Guardrails
1. **No implementation or planning before design approval** - brainstorm produces a design document, not code or task plans
2. **One question at a time** - ask clarifying questions sequentially, not in batches
3. **Always propose 2-3 approaches** - include a recommended option with trade-off analysis
4. **Section-by-section design** - present design incrementally with user confirmation at each step
5. **YAGNI** - do not over-engineer; design only what is needed for the stated goal
6. **Save design, then transition** - persist the approved design document before handing off to `/plan`

### Execution Phases
Follow the brainstorm workflow step by step:
1. **Phase 1 - Context**: Explore the existing codebase and understand the project landscape
2. **Phase 2 - Questions**: Ask clarifying questions one at a time to understand intent and constraints
3. **Phase 3 - Approaches**: Propose 2-3 approaches with a recommended option and trade-off matrix
4. **Phase 4 - Design**: Present the detailed design section by section, getting user approval at each step
5. **Phase 5 - Documentation**: Save the approved design to `docs/plans/designs/` and project memory
6. **Phase 6 - Transition**: Hand off to `/plan` for task decomposition

### Common Pitfalls
- **Jumping to solutions**: Asking "how" before fully understanding "what" and "why"
- **Too many questions at once**: Overwhelming the user with a wall of questions
- **Single approach bias**: Presenting only one option without alternatives
- **Over-engineering**: Designing for hypothetical future requirements instead of stated needs
- **Skipping confirmation**: Moving forward without explicit user approval on design decisions

## References
Vendor-specific execution protocols are injected automatically by `oma agent:spawn`.
Source files live under `../_shared/runtime/execution-protocols/{vendor}.md`.
- Context loading: `../_shared/core/context-loading.md`
- Reasoning templates: `../_shared/core/reasoning-templates.md`
- Clarification protocol: `../_shared/core/clarification-protocol.md`
- Quality principles: `../_shared/core/quality-principles.md`
- Skill-to-agent mapping: `../_shared/core/skill-routing.md`

© First Fluke · MIT · first-fluke/oh-my-agent

Similar skills

All skills for Agent setup: memory, context, orchestration →

oma-brainstorm by other authors comes first.

oma-brainstorm First Fluke oma-brainstorm — a skill for Claude Code and Codex designed for early feature exploration before task planning. Clarifies ambiguous requests one question at a time and compares technical options. CX Codex +1 ★ 1,472repo stars brainstorm OrchestKit The brainstorm skill explores a design question with parallel agents, filters ideas for feasibility, and compares trade-offs. It does not build or fix code. CX Codex +1 133installs ce-brainstorm EveryInc ce-brainstorm turns vague ideas into a structured requirements plan through dialogue. Separates product decisions from code. CX Codex +1 4,200installs obsidian-brainstorm Eugeniu Ghelbur obsidian-brainstorm is a Claude Code command that interviews you about an idea one question at a time, then writes a design note with alternatives and a recommendation. CX Codex +1 ★ 5,412repo stars bmad-brainstorm aj-geddes bmad-brainstorm runs structured ideation sessions using SCAMPER, SWOT, and 5 Whys. Delivers an organized markdown report ready for project planning. CX Codex +1 130installs brainstorm-ideas-existing phuryn brainstorm-ideas-existing — a skill to brainstorm product ideas for an existing product from PM, Designer, and Engineer perspectives. Use it to generate features, solve identified opportunities, or ideate with your product trio. CX Codex +1 3,300installs egm-brainstorm official google egm-brainstorm is a Claude Code skill that turns raw concepts into hypotheses through clarifying questions and parallel critique before coding. CX Codex +1 601installs

From the same set69

The whole set →
oma-debug oma-debug — a skill for Claude Code and Codex isolates bugs, writes targeted fixes, and creates regression tests. Runs when tests fail, services crash, or code suffers from race conditions. CX Codex +1 ★ 1,472repo stars oma-qa The oma-qa skill for Claude Code and Codex reviews changes for security, performance, accessibility, and correctness. It checks a diff, runs relevant tools, and reports reproducible findings with fixes. CX Codex +1 ★ 1,472repo stars oma-search oma-search — a skill for Claude Code and Codex that routes queries across external documentation, web search, and remote code. It picks the matching retrieval channel and returns answers backed by citations. CX Codex +1 ★ 1,472repo stars oma-pm oma-pm is a Claude Code skill that turns product requirements into a prioritized task plan with dependencies and acceptance criteria. It prepares the plan before work is handed to specialist agents. CX Codex +1 ★ 1,472repo stars oma-pm oma-pm — a skill for Claude Code and Codex decomposes product requirements into scoped tasks with dependencies and acceptance criteria. Generates plan artifacts for specialist agents and orchestrators. CX Codex +1 ★ 1,472repo stars oma-design oma-design resolves a project's design direction and maintains DESIGN.md as the visual contract. Picks an external design skill — Interface Design, Taste, or Impeccable — for the task at hand. CX Codex +1 ★ 1,472repo stars oma-hwp oma-hwp converts Korean HWP, HWPX, and HWPML documents into Markdown or JSON for LLM prompts and retrieval pipelines. CX Codex +1 ★ 1,472repo stars oma-search The oma-search skill picks a search channel for docs, web research, code, or local project files, then labels external sources by domain trust. Use it when the right place to search is unclear. CX Codex +1 ★ 1,472repo stars

Project sponsors

Companies that keep this analytics open