pm-brainstorm — Structured product brainstorm Skill

pm-brainstorm — Structured product brainstorm

Part of the Personal Corp framework — running a one-person business through AI agents. Run a structured creative-divergence session on a specific product problem or opportunity. Not just listing ideas — challenges assumptions, borrows across domains, helps reach options you wouldn't have otherwise. Output is a screened idea list ready for next-step action.

Inputs

| Field | Required | Notes | |---|---|---| | Topic | yes | Problem to solve or opportunity to explore — more specific = better | | Background | no | Persona, current data, known constraints | | Mode | no | Full divergence / single framework only; default full | | Constraints | no | Tech, time, resource limits |

Good topic: "How might we make new users feel value within the first 5 minutes of first use?" Bad topic: "How do we improve the product?" (too vague)

Step 1 — Problem focus

Before diverging, sharpen the problem.

Probing checklist:

Who has this problem? Specific user types and scenarios
How is it solved today? Current alternative or workaround
Why does it matter? Consequence of inaction
What does success look like? What does a good solution look like
What constraints? Tech / time / resource bounds

Restate as a How Might We:

"How might we let {target user} more easily {achieve goal} in {scenario}?"

Step 2 — SCAMPER (7 lenses)

Run each lens once; aim for 1-2 ideas per lens.

| Lens | Core question | Direction | |---|---|---| | S — Substitute | What component can be substituted? | Different tech / interaction / entry point? | | C — Combine | Can we merge two features? | Merge steps / contexts / bundle features | | A — Adapt | What from elsewhere can we borrow? | Method from social apps? From productivity tools? | | M — Modify | What if we 10×'d or 0.1×'d this? | Minimal version? Maximal version? | | P — Put to other use | What other context could this serve? | Other personas? Other scenarios? | | E — Eliminate | What if we remove something? | Cut steps / fields / signup / friction? | | R — Rearrange | What if we reorder? | Try first / signup later? Reverse order? |

Total: 7-14 initial ideas.

Step 3 — 5-Whys root-cause divergence

From a user pain, descend to the root, then ideate from each layer.

Example:

Pain: new users churn on day 2

Why 1: They didn't find what they wanted on day 1
- Why 2: Feature entries are too deep
  - Why 3: Navigation is structured by product architecture, not user task
    - Why 4: No user-task analysis was done
      - Why 5 (root): Product design is detached from actual user scenarios
      - Idea: Run user-task analysis, restructure navigation by task
    - Idea: Add search / smart-recommendations entry point
  - Idea: Onboarding leads users directly to core feature
- Idea: Ask intent at signup, personalize home

Rules:

Probe to at least Why 3
Each Why can fork (one symptom may have multiple causes)
Generate 1-2 solutions per Why layer

Step 4 — Cross-domain inspiration

Don't copy competitors — look at what they do, then think "what could we do that's different".

Cross-domain prompts:

List 3-5 products that are not direct competitors but solve a similar user need
Note what's notable about each
Ask: if we transplanted this approach to our context, what would adapt? What would change?

Differentiation prompts:

Everyone does X → what if we do Y instead?
Competitor's X is criticized for Z → could we cut into the pain at Z?
Need users discuss heavily on social media but no competitor has shipped → opportunity?

Step 5 — Constraint-innovation

Deliberately set constraints to spark creativity.

| Constraint | Setup | Stimulus | |---|---|---| | Time | "Only 1 week of dev time" | Forces minimum viable approach | | Tech | "Use only existing stack" | Reveals new uses of existing capabilities | | Cost | "Zero dev investment" | Ops moves, config changes, copy tweaks | | Extreme | "Change one line of code" | Find the highest-leverage single point | | Inversion | "Let users design it" | Switch perspective |

1-2 ideas per constraint. Tighter constraints often produce more elegant ideas.

Step 6 — Reverse brainstorm

First think "how could we make this worse", then invert each idea.

Steps:

Restate as the inverse: "How might we make new users uninstall on day 1?"
List everything that would worsen the problem (often easier than positive ideation)
Invert each "make-worse" idea into an improvement

Example:

| Make-worse | Inverted | |---|---| | Require 20 fields at signup | Phone-only signup, progressive profile fill | | Home is full of ads | Home shows only goal-relevant content | | Hide all help entries | Surface guidance proactively at confusion points |

Reverse-brainstorm bypasses the "find the right answer" pressure — the divergence stage gets freer.

Step 7 — Impact / Effort screening

Drop all ideas into a 2×2:

| Quadrant | Impact | Effort | Strategy | Ideas | |---|---|---|---|---| | Quick Wins | High | Low | Validate first | {list} | | Big Bets | High | High | Worth investing, plan carefully | {list} | | Fill-ins | Low | Low | When idle | {list} | | Money Pits | Low | High | Drop | {list} |

Scoring:

Impact: size of pain solved × users affected
Effort: dev + design + integration test

Step 8 — Output

# Product Brainstorm

**Topic:** {problem}
**HMW:** How might we {restated as HMW}
**Date:** {today}
**Ideas generated:** {N} (kept after screening: {M})

## Idea List

| # | Idea | Pain solved | Source framework | Expected value | Effort | Quadrant | Validation |
|---|---|---|---|---|---|---|---|
| 1 | {desc} | {pain} | SCAMPER-Eliminate | High/Med/Low | High/Med/Low | Quick Win | {validation} |

## Top 3 Recommendations

### Idea 1: {name}
- **Description:** {detail}
- **Pain solved:** {specific pain}
- **Expected impact:** {quantified, e.g. "+5-10% D1 retention"}
- **Implementation path:** {brief tech / design approach}
- **Validation:** {how to validate fast — A/B test, gradual rollout, etc.}
- **Risk:** {risks and mitigation}

### Idea 2: {name}
…

### Idea 3: {name}
…

## Dropped Ideas (archived)
- {idea X}: dropped because — {reason}
- {idea Y}: dropped because — {reason}

## Next Actions
- [ ] {action 1}
- [ ] {action 2}

Brainstorm principles

Diverge before converge — no judgment during divergence; screen during convergence
Quantity drives quality — first hit 15+ ideas, then screen
Concrete beats abstract — "add a progress bar at signup step 3" beats "improve signup UX"
Allow extremes — extreme ideas, refined, often become great
Challenge assumptions — push back on "impossible" / "we've always done it this way"

Quality bar

≥ 10 ideas generated (sufficient divergence)
Each idea has a concrete description (not vague "optimize X")
Ideas come from ≥ 3 different frameworks
Top 3 have explicit validation methods
Output is decision-ready as input to the next step

Red lines

No rejection during divergence — never say "can't" / "impossible" while ideating
No empty advice — "improve UX" is fluff, not an idea
Doesn't replace decision — outputs options, not the choice

When input is incomplete

Topic too broad → narrow it (probe scenario and user)
Missing background → ideate on generic product logic, tag "recommend specific data for sharper output"
Single framework specified → use only that one, but suggest "more frameworks = more dimensions"

Related skills

/pm-prd — Top idea → PRD
/pm-prioritize — Idea list → formal ranking
/pm-user-stories — Ideas → developable Stories
/pm-feedback — Pain points from feedback → brainstorm fuel
/pm-competitive — Validate differentiation level

Agent Skills: pm-brainstorm — Structured product brainstorm

Install this agent skill to your local

Skill Files