
Brainstorm Ideas
- 105 installs
- 451 repo stars
- Updated July 21, 2026
- borghei/claude-skills
brainstorm-ideas is a skill that runs structured product ideation using the Product Trio approach and Opportunity Solution Trees to generate and prioritize product ideas.
About
This skill runs structured product ideation for both new and existing products. It generates 5 ideas each from Product Manager, Designer, and Engineer perspectives (15 total), then prioritizes the top 5 using a weighted scoring model. Developers use it during early product discovery to frame a problem space and turn desired outcomes into ranked, documented ideas.
- Generates 15 product ideas across PM, Designer, and Engineer perspectives (Product Trio)
- Uses Teresa Torres' Opportunity Solution Tree to link outcomes to solutions
- Scores and ranks the top 5 ideas on a weighted 5-criterion model
Brainstorm Ideas by the numbers
- 105 all-time installs (skills.sh)
- Ranked #1,341 of 3,282 Productivity & Planning skills by installs in the Skillselion catalog
- Data as of Aug 5, 2026 (Skillselion catalog sync)
brainstorm-ideas capabilities & compatibility
- Capabilities
- idea generation · opportunity mapping · idea prioritization
- Use cases
- research · planning · project management
- Pricing
- Free
What brainstorm-ideas says it does
Structured product ideation for both new product creation and existing product enhancement.
Generate 5 ideas from each of the three perspectives (15 total):
From the 15 generated ideas, select the top 5 using this scoring model:
npx skills add https://github.com/borghei/claude-skills --skill brainstorm-ideasAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 105 |
|---|---|
| repo stars | ★ 451 |
| Last updated | July 21, 2026 |
| Repository | borghei/claude-skills ↗ |
What it does
Frame a problem space and generate ranked, documented product ideas before committing to a build.
Who is it for?
Product teams exploring greenfield opportunities or enhancing a live product with an outcome-driven, prioritized idea set.
Skip if: Detailed technical implementation planning or writing code.
When should I use this skill?
You need to generate and rank product ideas tied to a measurable outcome.
What you get
A prioritized top-5 idea set with scores, assumptions, and suggested validation for each.
- prioritized ideas table
- detailed idea cards
- opportunity solution tree
By the numbers
- 15 ideas generated (5 per perspective)
- top 5 ideas prioritized
- 5-criterion weighted scoring model
Files
Product Ideation Expert
Overview
Structured product ideation for both new product creation and existing product enhancement. This skill combines the Product Trio approach (PM + Designer + Engineer perspectives) with Teresa Torres' Opportunity Solution Tree framework to generate, evaluate, and prioritize product ideas systematically.
When to Use
- New Product Ideation -- Exploring greenfield opportunities where the focus is on core value delivery, speed to validate, and market differentiation.
- Existing Product Enhancement -- Identifying opportunities within a live product using the Opportunity Solution Tree to connect desired outcomes to concrete solutions.
Methodology
Phase 1: Frame the Problem Space
Before generating ideas, establish clarity on the context:
1. Define the Target Outcome -- What measurable result are we trying to achieve? (e.g., increase activation rate by 15%, reduce churn by 10%) 2. Identify the Target Segment -- Who specifically are we solving for? Include behavioral and situational context, not just demographics. 3. Map Known Constraints -- Budget, timeline, technical platform, regulatory requirements, team capacity.
Phase 2: Product Trio Ideation
Generate 5 ideas from each of the three perspectives (15 total):
Product Manager Perspective (5 ideas) Focus: Business value, market positioning, customer pain points, strategic alignment
- What problems do customers report most frequently?
- Where are competitors weak that we could be strong?
- Which segments are underserved by current solutions?
- What would make customers willing to pay more or switch?
- How does this connect to our strategic objectives?
Designer Perspective (5 ideas) Focus: User experience, workflows, accessibility, delight, friction reduction
- Where do users drop off or struggle in current flows?
- What tasks take too many steps or too much cognitive load?
- How could we surprise users with unexpected value?
- What accessibility gaps exist that exclude potential users?
- Where can we reduce time-to-value for new users?
Engineer Perspective (5 ideas) Focus: Technical feasibility, scalability, platform capabilities, integration opportunities
- What new capabilities does our tech stack enable?
- Which features could we build quickly with high impact?
- Where could automation replace manual processes?
- What data do we have that we are not leveraging?
- Which technical debt, if resolved, would unlock new possibilities?
Phase 3: Approach by Product Type
For New Products
Apply these lenses to each idea:
| Lens | Question |
|---|---|
| Core Value | Does this idea deliver a single, clear value proposition? |
| Speed to Validate | Can we test the core assumption in under 2 weeks? |
| Differentiation | Why would someone choose this over existing alternatives? |
| Market Timing | Is the market ready for this? What tailwinds exist? |
| Scalability | Can this grow beyond the initial use case? |
For Existing Products (Opportunity Solution Tree)
Follow Teresa Torres' Continuous Discovery Habits framework:
Desired Outcome
├── Opportunity 1 (unmet need / pain point / desire)
│ ├── Solution A
│ ├── Solution B
│ └── Solution C
├── Opportunity 2
│ ├── Solution D
│ └── Solution E
└── Opportunity 3
├── Solution F
└── Solution G1. Start with the outcome -- The metric or business result you want to move. 2. Map opportunities -- Interview-driven insights about what customers need, want, or struggle with. 3. Generate solutions per opportunity -- Each opportunity gets multiple potential solutions. 4. Compare and select -- Evaluate solutions within the same opportunity branch, not across branches.
Phase 4: Prioritize Top 5
From the 15 generated ideas, select the top 5 using this scoring model:
| Criterion | Weight | Scale |
|---|---|---|
| Customer Impact | 30% | 1-10 |
| Strategic Alignment | 25% | 1-10 |
| Feasibility | 20% | 1-10 |
| Speed to Validate | 15% | 1-10 |
| Differentiation | 10% | 1-10 |
Weighted Score = (Impact x 0.30) + (Strategy x 0.25) + (Feasibility x 0.20) + (Speed x 0.15) + (Differentiation x 0.10)
Phase 5: Document Each Idea
For each of the top 5 prioritized ideas, produce:
| Field | Description |
|---|---|
| Name | Short, memorable name for the idea |
| Description | 2-3 sentence summary of what it is |
| Reasoning | Why this idea ranks highly -- connect to outcome and evidence |
| Source Perspective | PM, Designer, or Engineer |
| Key Assumptions | 2-3 assumptions that must be true for this to succeed |
| Suggested Validation | How to test the riskiest assumption first |
| Effort Estimate | T-shirt size (XS / S / M / L / XL) |
Output Format
Prioritized Ideas Table
| Rank | Name | Source | Score | Effort | Top Assumption |
|---|---|---|---|---|---|
| 1 | ... | PM | 8.4 | M | ... |
| 2 | ... | Design | 7.9 | S | ... |
| 3 | ... | Eng | 7.6 | L | ... |
| 4 | ... | PM | 7.2 | S | ... |
| 5 | ... | Design | 6.8 | M | ... |
Detailed Idea Cards
For each idea, fill in the template from assets/ideation_workshop_template.md.
Supplementary Techniques
When the trio needs additional stimulus:
- SCAMPER -- Substitute, Combine, Adapt, Modify, Put to other use, Eliminate, Reverse. Apply to existing products or competitor features.
- How Might We (HMW) -- Reframe problems as opportunity questions. "Users churn after trial" becomes "How might we demonstrate value before the trial ends?"
- Crazy 8s -- 8 sketches in 8 minutes per person. Forces breadth over depth.
- Worst Possible Idea -- Generate deliberately bad ideas, then invert them to find hidden good ones.
See references/ideation-frameworks.md for detailed descriptions of each technique.
Integration with Other Discovery Skills
- After ideation, move top ideas to
identify-assumptions/to map and prioritize assumptions. - Use
brainstorm-experiments/to design validation experiments for key assumptions. - Run
pre-mortem/before committing to build, to surface hidden risks.
References
- Teresa Torres, Continuous Discovery Habits (2021)
- Marty Cagan, Inspired (2018)
- Jake Knapp, Sprint (2016)
- Michael Michalko, Thinkertoys (2006) -- SCAMPER origin
Troubleshooting
| Problem | Likely Cause | Resolution |
|---|---|---|
| Ideation session produces only incremental ideas, no breakthrough thinking | Anchoring bias -- team defaults to what they know; PM perspective dominates | Explicitly rotate perspectives (Designer first, then Engineer); use "Worst Possible Idea" technique to break anchoring; invite an outsider to challenge assumptions |
| Prioritization scores cluster tightly, making ranking impossible | Scoring criteria are too similar, or the team is avoiding differentiation | Add a forced-rank step after weighted scoring; increase weight spread between criteria; use pairwise comparison for the top 5 |
| Opportunity Solution Tree has too many branches to be actionable | Team brainstormed opportunities without filtering by evidence | Require each opportunity to link to at least 2 user interview quotes or data points; prune branches without evidence |
| Stakeholders reject prioritized ideas because "the real problem is different" | Problem framing was done without stakeholder input; target outcome not validated | Run a problem framing workshop with stakeholders before ideation; validate the target outcome with data before generating solutions |
| Same ideas keep resurfacing across sessions | Previous ideation results not documented or accessible; no "already considered" registry | Maintain an idea backlog with status (explored, parked, rejected with rationale); review it at the start of each session |
| Engineer perspective ideas are too implementation-focused | Engineers default to "how to build" rather than "what to build" | Reframe the prompt: "What new capability would our tech stack enable for users?" rather than "What should we build next?" |
| Validation suggestions are too expensive or slow | Team defaults to full A/B tests when lighter methods exist | Introduce pretotyping and Wizard-of-Oz as first validation options; use the brainstorm-experiments/ skill for experiment design |
Success Criteria
- Each ideation session produces at least 15 ideas across all three Product Trio perspectives (minimum 3 per perspective)
- Top 5 prioritized ideas each have a documented riskiest assumption and a validation plan
- At least 60% of prioritized ideas can begin validation within 2 weeks using lightweight methods
- Stakeholders rate the ideation output as "relevant to strategic objectives" at 4+/5
- Ideas that proceed to validation have a clear connection to the target outcome (traceable through the Opportunity Solution Tree)
- Ideation cadence is maintained (at minimum quarterly for existing products, monthly during new product exploration)
- At least 1 idea per quarter advances from ideation through validation to backlog commitment
Scope & Limitations
In Scope: Structured ideation facilitation using Product Trio approach, Opportunity Solution Tree mapping, idea prioritization with weighted scoring, SCAMPER and HMW supplementary techniques, idea documentation with validation plans, integration with downstream discovery skills.
Out of Scope: Assumption testing and experiment design (hand off to brainstorm-experiments/ and identify-assumptions/), detailed product requirements (hand off to execution/create-prd/), market research and competitive analysis, financial modeling for ideas.
Limitations: Ideation quality is bounded by the diversity of perspectives in the room -- remote-only sessions may reduce creative energy. Scoring models provide structured comparison but are not objective truth; they encode the biases of the scorers. Opportunity Solution Trees require ongoing user research to populate -- they are not a substitute for customer interviews.
Integration Points
| Integration | Direction | What Flows |
|---|---|---|
identify-assumptions/ | Ideas -> Assumptions | Top 5 ideas feed into assumption mapping for risk assessment |
brainstorm-experiments/ | Ideas -> Experiments | Riskiest assumptions from ideas become experiment candidates |
pre-mortem/ | Ideas -> Risk | Selected ideas run through pre-mortem before build commitment |
execution/create-prd/ | Ideas -> PRD | Validated ideas become PRD inputs with problem statement and success metrics |
execution/brainstorm-okrs/ | OKRs -> Ideas | Team OKRs define the target outcomes that frame ideation sessions |
execution/prioritization-frameworks/ | Ideas -> Prioritization | Scored ideas feed into RICE or other frameworks for backlog ordering |
Ideation Workshop Template
Workshop Details
| Field | Value |
|---|---|
| Date | YYYY-MM-DD |
| Facilitator | |
| Product Trio | PM: / Designer: / Engineer: |
| Target Outcome | |
| Product Type | New Product / Existing Product |
| Time Allocated | 90 minutes |
---
Agenda
| Time | Activity | Duration |
|---|---|---|
| 0:00 | Context setting -- share outcome, constraints, known research | 10 min |
| 0:10 | Silent ideation -- each person writes 5 ideas | 15 min |
| 0:25 | Round-robin sharing -- present ideas, clarify only | 20 min |
| 0:45 | Cluster related ideas on board | 10 min |
| 0:55 | Break | 5 min |
| 1:00 | Score and prioritize -- select top 5 | 15 min |
| 1:15 | Document top 5 idea cards | 15 min |
---
Idea Canvas
Copy this card for each idea.
Idea Card
| Field | Details |
|---|---|
| Idea Name | |
| Source Perspective | PM / Designer / Engineer |
| Problem Statement | What problem does this solve? |
| Proposed Solution | 2-3 sentence description |
| Target User/Segment | Who specifically benefits? |
| Key Assumptions | 1. / 2. / 3. |
| Reasoning | Why is this idea valuable? What evidence supports it? |
| Effort Estimate | XS / S / M / L / XL |
---
All Ideas (Pre-Prioritization)
PM Perspective Ideas
| # | Idea Name | Brief Description |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 |
Designer Perspective Ideas
| # | Idea Name | Brief Description |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 |
Engineer Perspective Ideas
| # | Idea Name | Brief Description |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 |
---
Prioritization Matrix
Score each idea 1-10 on each criterion. Compute the weighted score.
| Idea Name | Impact (30%) | Strategy (25%) | Feasibility (20%) | Speed (15%) | Differentiation (10%) | Weighted Score |
|---|---|---|---|---|---|---|
Formula: Score = (Impact x 0.30) + (Strategy x 0.25) + (Feasibility x 0.20) + (Speed x 0.15) + (Differentiation x 0.10)
---
Top 5 Prioritized Ideas
| Rank | Name | Source | Weighted Score | Effort | Top Assumption to Test |
|---|---|---|---|---|---|
| 1 | |||||
| 2 | |||||
| 3 | |||||
| 4 | |||||
| 5 |
---
Next Steps
| Action | Owner | Due Date |
|---|---|---|
Map assumptions for top 5 ideas (use identify-assumptions skill) | ||
Design validation experiments (use brainstorm-experiments skill) | ||
Run pre-mortem on top 1-2 ideas (use pre-mortem skill) | ||
| Schedule follow-up review session |
---
Notes
Capture any additional context, constraints, or observations from the session.
Example: Northwind SaaS — Product Trio Ideation for B2B Onboarding Redesign
Real-world scenario showing how to apply this skill end-to-end.
Context
Northwind SaaS (Series-B B2B payments platform, ~140 employees) has a leaky onboarding funnel. Of merchants who sign up, only 38% reach "first successful transaction" within 7 days. Customer success says the manual hand-holding it takes to get a merchant live is unsustainable — they cannot scale it past the next 200 merchants. The Activation team has 1 quarter to move the metric.
The PM, Maria Chen, has 4 weeks before quarterly planning. Rather than walking in with her own list of ideas, she is running a Product Trio ideation session with the lead designer (Liang) and the lead engineer (Reza). The brainstorm-ideas skill is being applied to generate 15 ideas across the trio, then converge on a small set tied to specific opportunities in the existing-product Opportunity Solution Tree.
Inputs
- Metric: 7-day activation rate (first successful transaction within 7 days of signup)
- Baseline: 38%; target: 55% within one quarter
- Customer success data: 6 named friction patterns from recent CS calls
- 14 customer interview transcripts from the last 90 days
- Team: Maria (PM), Liang (Designer), Reza (Engineer)
- Constraint: 1 quarter to ship; can use feature flags; cannot rebuild the auth system
- Constraint: cannot increase CS headcount
Applying the skill
1. Framed the problem before brainstorming. Defined outcome (55% 7-day activation), segment (new merchants in tiers 1-2 self-serve), and constraints (no auth rebuild, no CS headcount add). The team did NOT start generating ideas until the frame was locked. 2. Ran the Product Trio session in 3 silent rounds. Each role generated 5 ideas independently (no group-think) before sharing. This is the discipline the skill names — Brainstorming-then-Sharing produces wider idea spread than open discussion. 3. Scored each of 15 ideas against the existing-product lens. Did not pick winners by feel. 4. Built the Opportunity Solution Tree. The 15 ideas were rolled up into 3 opportunities (interview-grounded), then ideas became candidate solutions within those branches. 5. Compared within branches, not across them. Per skill: choose between Solution A vs B for the same opportunity. Never compare Solution A (Opportunity 1) against Solution F (Opportunity 3) because they answer different customer needs. 6. Picked 2 bets to validate, not to ship. The session output is what to test next quarter, not what to build.
The artifact
================================================================
ONBOARDING REDESIGN — PRODUCT TRIO IDEATION OUTPUT
Date: 2026-05-22
PM: Maria Chen
Designer: Liang Zhou
Engineer: Reza Karimi
Outcome: 7-day activation from 38% -> 55% by 2026-08-31
================================================================
PART 1 — PROBLEM FRAME
Outcome: 7-day activation rate (% of new merchants who complete
first successful transaction within 7 days of signup)
Baseline: 38%
Target: 55%
Target segment: Tier 1-2 self-serve merchants (US-based,
<$100K projected annual GMV, no dedicated CS rep)
~600 new signups/month
Constraints:
- Cannot rebuild auth system (compliance review pending)
- No CS headcount addition
- 1 quarter (12 weeks) to ship
- Feature flags available
- Must be reversible (kill switch within 1 sprint)
PART 2 — 15 IDEAS FROM THE TRIO
==========================================
PM PERSPECTIVE (Maria) — 5 ideas
==========================================
PM-1 Tiered onboarding by GMV projection
Ask one question on signup: projected monthly GMV.
Route enterprise candidates to a 60-min onboarding
call with sales engineering. Route self-serve to a
streamlined 5-min flow. Today everyone gets the same
30-min wizard.
PM-2 Industry-specific templates
Top-10 merchant industries each get a one-click
"preset" of products, tax categories, and webhook
defaults. Today everyone starts from a blank slate
regardless of vertical.
PM-3 "Sandbox first" — let merchants test before going live
Default new accounts to test mode. First transaction
in test mode counts as activation milestone 1.
Production switch is intentional, gated on success.
PM-4 Activation-bound pricing incentive
"Process your first $100 in week 1 -> first month
transaction fees waived." Aligns merchant time with
our outcome.
PM-5 Account manager assignment for hovering merchants
Identify merchants who hit the "stuck" pattern (signed
up, no test transaction by day 3) and proactively
assign a CS rep for one 15-min call. Costly per
account; reserved for top-decile by GMV projection.
==========================================
DESIGNER PERSPECTIVE (Liang) — 5 ideas
==========================================
D-1 Progress bar that doesn't lie
Today the progress bar shows 5 steps even though the
hard step (compliance verification) takes 24-72 hours
and is invisible. Show all dependencies with realistic
timing so merchants don't bounce thinking it's broken.
D-2 "Send to my developer" handoff
80% of merchants have someone else integrate the API.
A first-class flow to send a pre-filled developer-
handoff email with credentials, sample code, and a
direct calendar link to integrations support.
D-3 Live receipts feed during integration
As the merchant's developer tests, the merchant sees
a real-time activity feed: "Test charge of $1.00 just
came in from your sandbox." Today they refresh blindly.
D-4 Friction-killing 1-page checklist
One page. 7 boxes. Tickable. Replaces the 11-tab
wizard. Empty boxes are the most powerful prompt in UX.
D-5 "Why we need this" inline explainer
Every form field that asks for sensitive data (SSN,
bank routing) gets an inline microcopy explaining
why and citing the regulator. Reduces abandonment at
the compliance step.
==========================================
ENGINEER PERSPECTIVE (Reza) — 5 ideas
==========================================
E-1 Pre-fill from a single tax-ID lookup
With one tax ID, we can pre-fill business name,
address, structure type via a public lookup API.
Cuts 8 fields to 1. Already used internally for
enterprise; just plumb it into self-serve.
E-2 Async compliance with optimistic activation
Today compliance must clear before any transaction.
Change to: allow test-mode transactions immediately,
production transactions once compliance clears.
Merchant's perceived activation time drops from
24-72 hours to minutes.
E-3 Webhook auto-discovery from popular platforms
If the merchant has a Shopify/WooCommerce/Magento
store, OAuth into it and auto-configure the webhook.
Today this is 14 manual steps.
E-4 Daily activation-cohort report to CS
Engineering effort to build a daily report of
day-3 stuck merchants for CS. Powers PM-5 above.
E-5 API key auto-rotation kill-switch
Side effect: removes one merchant fear of "what if
something goes wrong with the test key, do I lose
everything?" Reduces psychological friction.
PART 3 — OPPORTUNITY SOLUTION TREE
Outcome: 7-day activation rate 38% -> 55%
Opportunity 1: Compliance step blocks activation
perception time even when work is done
(Evidence: 8 of 14 interviews; CS data shows 60% of
day-3 stuck merchants are waiting on compliance)
Solutions:
E-2 Async compliance with optimistic activation
D-1 Honest progress bar with real timing
D-5 Inline "why we need this" microcopy
Opportunity 2: Self-serve merchants get lost in a
wizard built for enterprise integration teams
(Evidence: 5 of 14 interviews; activation rate by tier
shows self-serve is 22 pts below enterprise)
Solutions:
PM-1 Tiered onboarding by GMV
PM-2 Industry-specific templates
PM-3 Sandbox-first default
D-4 One-page tickable checklist
D-2 Send-to-developer handoff
E-1 Tax-ID single-field pre-fill
E-3 Webhook auto-discovery
Opportunity 3: Merchant -> developer handoff loses
momentum
(Evidence: 6 of 14 interviews mentioned "I had to wait
for my dev"; activation rate where merchant != integrator
is 12 pts lower)
Solutions:
D-2 Send-to-developer handoff (also above)
D-3 Live receipts feed during integration
E-3 Webhook auto-discovery (also above)
Opportunity 4: Top-decile merchants would benefit from
proactive CS touch
(Evidence: 3 of 14 interviews; ROI questionable for
mid-tier; reserved for high-projection merchants)
Solutions:
PM-5 Account manager assignment for hovering merchants
E-4 Daily activation-cohort report to CS
Opportunity (declined): Activation-bound pricing incentive
PM-4 sits outside the tree because the interview signal
does not support price-as-a-blocker. Merchants did NOT
cite cost in interviews. PM-4 is a marketing experiment,
not an activation product change. Documented and parked.
PART 4 — SCORING WITHIN BRANCHES
Score each candidate solution on a 1-5 scale:
Core Value Does this single solution clearly remove a
named friction?
Speed Can we validate in <2 weeks?
Differentiation Does this beat Stripe / Adyen for the same
segment?
Timing Is the team ready to ship this in 12 weeks?
Scalability Does this scale beyond the test cohort?
OPPORTUNITY 1 — Compliance friction
Solution CV Sp Df Ti Sc Total
E-2 Async compliance 5 3 4 4 5 21
D-1 Honest progress bar 4 5 2 5 5 21
D-5 Inline microcopy 3 5 3 5 5 21
Tied at 21. Tie-breaker: E-2 is structurally the only
one that changes activation TIME, not just perception.
Choose E-2.
OPPORTUNITY 2 — Self-serve gets lost
Solution CV Sp Df Ti Sc Total
E-1 Tax-ID pre-fill 4 5 3 5 5 22
D-4 One-page checklist 4 4 3 4 5 20
PM-1 Tiered onboarding by GMV 5 3 3 3 5 19
PM-3 Sandbox-first default 5 3 4 4 5 21
PM-2 Industry templates 4 3 4 2 4 17
D-2 Send-to-developer handoff 4 3 3 4 4 18
E-3 Webhook auto-discovery 4 2 4 3 5 18
Top: E-1 (22), PM-3 (21), D-4 (20). Choose PM-3
(sandbox-first) because it pairs with E-2 above — same
underlying philosophy of "let them experience success
before the slow compliance step gates them."
OPPORTUNITY 3 — Merchant-developer handoff
D-2 already chosen via opp 2. Defer the rest.
OPPORTUNITY 4 — Proactive CS for top decile
PM-5 + E-4 combo. Reza estimates E-4 is a one-sprint
build. But this is bottlenecked on CS capacity, not on
product. Park for next quarter unless 7-day activation
doesn't move with bets 1 + 2.
PART 5 — BETS THIS QUARTER
The team commits to validating two bets:
BET A: Async compliance + optimistic activation (E-2)
Solves Opportunity 1.
Hypothesis: shifting to async compliance moves 7-day
activation +8 pts for merchants who would otherwise
wait 24+ hours for compliance.
BET B: Sandbox-first default flow (PM-3)
Solves Opportunity 2.
Hypothesis: making test-mode the default cuts
merchant time-to-first-test-transaction from
median 6 hours to median 30 minutes, lifting 7-day
activation +6 pts.
Combined target: 38% + 14 pts = 52% (close to the 55%
goal). The Quarter 4 work will be Opportunity 3 (handoff)
unless one of these underperforms.
Both bets ship behind feature flags. Both have kill criteria
defined in their own experiment briefs.
PART 6 — WHAT WE DID NOT PICK AND WHY
PM-4 (pricing incentive)
Not supported by interview evidence. Parked.
D-3 (live receipts feed)
High delight value but doesn't move the metric.
Candidate for Q4.
PM-2 (industry templates)
High effort for 10 verticals; phased follow-up.
PM-5 + E-4 (proactive CS)
Bottlenecked on CS capacity; revisit Q4.
E-5 (auto-rotation)
Quality improvement, not activation lever. Goes to
backlog.
Documenting the no-pick set is as important as the picks.
These are not bad ideas — they are not the ideas for THIS
outcome in THIS quarter.Why this works
- Silent independent generation before group discussion. Each of the three roles generated 5 ideas alone before sharing. This is the single move that produces 15 distinct ideas instead of 5 with three people nodding.
- The Opportunity Solution Tree is interview-grounded. Each opportunity cites how many of the 14 interviews supported it. The skill warns against opportunities invented by the team without customer evidence — and this output cites the evidence row by row.
- Compared solutions WITHIN branches, not across. PM-3 (sandbox-first) competed against E-1 and D-4 because all three address Opportunity 2. PM-3 did NOT compete against E-2 (async compliance) — they address different opportunities and both can be bets.
- Declined PM-4 explicitly and named why. The pricing incentive sounds clever but had zero interview support. A weaker session would have kept it in the bucket "because it might work." Naming it as parked and naming the reason is the discipline.
- Picked bets, not the whole list. Two bets, with clear hypotheses. Not "we're going to ship 7 of these." The combined hypothesis (52% vs target 55%) is honest about the remaining gap.
- Anti-pattern avoided: scoring before opportunity mapping. A weaker team scores 15 ideas on a generic RICE matrix and picks the top 3. That ignores the structural fact that 3 ideas solving the same friction are redundant; you want 1 idea per friction.
What's next
- Both bets become lean experiments designed in `../brainstorm-experiments/`, each with its own XYZ hypothesis and kill criteria.
- The 14 customer interviews underpinning the opportunity tree should also be synthesized via `../interview-synthesis/` into a shareable opportunity-tree Mermaid diagram.
- Each bet that ships gets a full PRD via `../../execution/create-prd/`.
- The activation funnel is monitored via `../../execution/activation-funnel/` — these bets target the activation step specifically.
- Pre-mortem the bigger of the two bets (E-2 async compliance) using `../pre-mortem/` before commit.
- Assumption-map both bets using `../identify-assumptions/` so we know what could falsify each.
Ideation Frameworks Reference
Product Trio Methodology
The Product Trio is a cross-functional team of three roles collaborating continuously on product discovery:
- Product Manager -- Owns the "why" and "what." Brings business context, customer research, strategic goals, and market intelligence.
- Designer -- Owns the experience. Brings user empathy, interaction patterns, visual communication, and usability expertise.
- Engineer -- Owns the "how." Brings technical feasibility, system knowledge, data awareness, and build/buy/partner perspective.
Why Three Perspectives Matter
Each role has a distinct blind spot:
- PMs can overweight business value and underweight user experience.
- Designers can overweight delight and underweight technical cost.
- Engineers can overweight feasibility and underweight customer need.
The trio structure ensures every idea is stress-tested from all three angles before it advances.
Running a Trio Ideation Session
1. Timebox: 60-90 minutes maximum. 2. Diverge first: Each person generates 5 ideas independently (15 minutes, silent). 3. Share and clarify: Present ideas round-robin (20 minutes). No critique yet. 4. Cluster: Group related ideas on a board (10 minutes). 5. Converge: Dot-vote or score to select top 5 (15 minutes). 6. Document: Capture idea cards for top 5 (15 minutes).
---
Opportunity Solution Tree (Teresa Torres)
The Opportunity Solution Tree (OST) is a visual framework from Continuous Discovery Habits that connects business outcomes to customer opportunities to solutions.
Structure
Desired Outcome (metric to move)
├── Opportunity A (customer need, pain, or desire)
│ ├── Solution 1
│ ├── Solution 2
│ └── Solution 3
├── Opportunity B
│ ├── Solution 4
│ └── Solution 5
└── Opportunity C
└── Solution 6Key Principles
- One outcome at a time. Focus the tree on a single measurable outcome.
- Opportunities come from research. Interview customers weekly to discover opportunities; do not brainstorm them.
- Solutions compete within a branch. Compare solutions that address the same opportunity, not across different opportunities.
- Small experiments, not big bets. Test assumptions behind solutions before building full features.
When to Use
- Existing products with an active user base and interview pipeline.
- Teams that have a clear outcome metric assigned by leadership.
- Continuous discovery (ongoing), not one-off ideation events.
---
SCAMPER Technique
SCAMPER is a structured creativity checklist. Apply each prompt to an existing product, feature, or competitor offering:
| Letter | Prompt | Example Question |
|---|---|---|
| S | Substitute | What component, material, or process could we replace? |
| C | Combine | What features or products could we merge? |
| A | Adapt | What idea from another industry could we borrow? |
| M | Modify | What could we enlarge, shrink, or change the shape of? |
| P | Put to other use | Who else could use this? What other problem could it solve? |
| E | Eliminate | What could we remove and still deliver value? |
| R | Reverse | What if we did the opposite? What if we reversed the order? |
Tips for SCAMPER Sessions
- Apply each letter as a separate round (2 minutes per letter).
- Use a specific subject: "Our onboarding flow" not "our product."
- Combine SCAMPER with Product Trio: each person applies SCAMPER from their role's perspective.
---
How Might We (HMW) Questions
HMW is a reframing technique that converts problems, pain points, and observations into open-ended opportunity questions.
Formula
"How might we [verb] [desired change] for [user segment]?"
Examples
| Observation | HMW Question |
|---|---|
| Users abandon checkout at shipping cost screen | How might we reduce shipping cost anxiety before checkout? |
| Engineers spend 30% of sprint fixing regressions | How might we catch regressions before they reach production? |
| New users do not discover the API within the first week | How might we introduce the API during onboarding? |
Rules for Good HMW Questions
1. Not too broad. "How might we make users happy?" is useless. 2. Not too narrow. "How might we add a tooltip to the settings gear icon?" is a solution, not a question. 3. Implies no solution. The question should invite multiple possible answers. 4. Grounded in evidence. Each HMW should trace back to a real observation or data point.
---
Idea Evaluation Criteria
When comparing ideas, use these five criteria:
1. Customer Impact (Weight: 30%)
- How many users are affected?
- How severe is the current pain?
- How much better is the proposed experience?
2. Strategic Alignment (Weight: 25%)
- Does this advance a company or team OKR?
- Does it strengthen our competitive position?
- Is it consistent with our product vision?
3. Feasibility (Weight: 20%)
- Can we build this with current technology and team skills?
- Are there external dependencies or blockers?
- What is the technical risk?
4. Speed to Validate (Weight: 15%)
- Can we test the core assumption in under 2 weeks?
- Is there an existing proxy metric we can measure?
- Can we run a lightweight experiment before building?
5. Differentiation (Weight: 10%)
- Does this create a unique advantage competitors cannot easily copy?
- Does it leverage a proprietary asset (data, network, expertise)?
- Will users perceive this as meaningfully different?
Scoring
Rate each criterion 1-10. Compute weighted score:
Score = (Impact x 0.30) + (Strategy x 0.25) + (Feasibility x 0.20)
+ (Speed x 0.15) + (Differentiation x 0.10)Ideas scoring 7.0+ are strong candidates. Ideas scoring below 5.0 should be deprioritized unless they have exceptional strategic value.
Red Flags: Brainstorm Ideas
Common ways this skill's output goes wrong — concrete examples, why they're bad, and how to fix them. Pair with the SKILL.md and Troubleshooting table.
How to use this document
When you have just finished an ideation session, scan the red flags below before publishing the idea list or moving to prioritization. Each red flag shows a bad and good version.
---
Red Flag 1: Ideation Theater (15 Ideas, 1 Used)
Symptom. The session produced 15 ideas across PM/Designer/Engineer perspectives. Two weeks later, the team is building the idea the PM walked in with.
Why it's bad. Ideation theater wastes the team's time and undermines trust in the discovery process. If the decision was pre-made, the workshop was just performance. The Product Trio approach exists to change the decision, not to ratify it.
Bad example:
"We ran a great ideation session — 15 ideas! Decided to go with the one the PM had originally proposed."
Good example:
"Ideation produced 15 ideas. After Opportunity Solution Tree scoring, top 3 candidates: A (PM's original), B (Designer-originated), C (Engineer-originated). Trio voted 2-1 for B based on confidence-of-evidence. PM dissent recorded; we'll experiment with B and revisit if data calls for A."
How to catch it. Did the chosen idea originate from one perspective or did the session genuinely change the selection? If the PM's idea won every time across multiple sessions, the process is theater.
---
Red Flag 2: HiPPO Override (Highest Paid Person's Opinion Wins)
Symptom. Ideation produces 12 ideas; the VP or executive shows up at the end and picks their favorite, overriding the team's evidence-based ranking.
Why it's bad. HiPPO override defeats the purpose of involving the trio. The team learns that opinion outranks evidence, stops contributing real ideas, and starts predicting what the HiPPO wants. Continuous discovery dies.
Bad example:
Trio recommends Idea B based on customer evidence. VP attends review, picks Idea D ("I have a hunch"). Build proceeds on D.
Good example:
Trio recommends B. VP disagrees, prefers D. Resolution: VP signs a "VP override" note documenting their reasoning, success criteria, and a check-back date. If D fails, the override is reviewed. The team's recommendation stays in the record as the dissenting view."
How to catch it. When an executive overrides the team, is the override documented with criteria? If not, accountability evaporates.
---
Red Flag 3: Ideas Are Just Features, Not Solutions to Opportunities
Symptom. Ideation produces a feature list ("dark mode, AI assistant, calendar integration") with no connection to a customer opportunity or outcome.
Why it's bad. Torres' Opportunity Solution Tree requires solutions to be anchored to a named opportunity, which is anchored to a desired outcome. Disconnected feature lists are wish lists; they ship, get adoption, and do not move the metric.
Bad example:
Idea list: 1. Dark mode. 2. AI assistant. 3. Calendar sync. 4. Slack notifications. 5. Mobile app.
Good example:
Outcome: increase weekly active usage 20%. Opportunity: 'Users forget to come back during workday.' Solutions: (a) calendar-based reminders, (b) Slack daily digest, (c) browser extension. Each idea scored on impact-to-opportunity, not generic appeal.
How to catch it. For each idea, can you name the opportunity it addresses? If multiple ideas address the same opportunity, that is healthy. If you cannot connect an idea to an opportunity, it is freelancing.
---
Red Flag 4: Single-Perspective Ideation (Only PM Voice)
Symptom. Brainstorm includes PM only, or PM + Designer but no Engineer. Ideas are biased toward what PM-thinking considers possible.
Why it's bad. Product Trio exists because each perspective surfaces different ideas. Engineers see leverage in existing platform capability. Designers see flows and interaction patterns. PMs see customer evidence and business levers. Missing one perspective produces a flat, narrower idea set.
Bad example:
Brainstorm: PM solo. 14 ideas, all customer-facing features. No leverage of existing infrastructure surfaced.
Good example:
Brainstorm: PM, designer, engineer. 15 ideas. Eng surfaced 'enable the existing event-stream for this use case — 3 days of work, unlocks 3 use cases'. PM never would have thought of it."
How to catch it. Was the full trio present? If not, the idea set is incomplete.
---
Red Flag 5: Ideating Before the Problem Space Is Framed
Symptom. "Let's brainstorm" — no clear target outcome, no defined segment, no constraints. Ideas range from a chrome extension to a B2B integration to a re-onboarding flow.
Why it's bad. Unframed ideation is fast but produces unranked, incomparable ideas. The Phase 1 framing in the SKILL.md (outcome, segment, constraints) exists because ideas are only useful relative to a frame. Skipping framing is how teams produce 20 ideas none of which can be compared.
Bad example:
Workshop opens: "Today we'll brainstorm ideas for the product." 90 minutes of suggestions.
Good example:
Workshop opens: "Outcome: reduce time-to-first-value from 12 min to 4 min. Segment: SMB self-serve trials in week 1. Constraints: $0 infra spend, 6 engineer-weeks. Generate ideas under this frame."
How to catch it. Is the frame written on the wall before ideation starts? If not, you are about to produce unrankable ideas.
---
Red Flag 6: SCAMPER as Performance, Not Catalyst
Symptom. Team mechanically goes through each SCAMPER letter (Substitute, Combine, Adapt, Modify, Put to other use, Eliminate, Reverse) for every concept, producing 49 cells of mediocre output.
Why it's bad. SCAMPER is a catalyst — apply selectively to break thinking patterns when stuck. Mechanically applying every letter to every concept produces volume, not insight, and trains the team to value process over outcome.
Bad example:
"We applied SCAMPER to our onboarding. 7 letters x 5 stages = 35 ideas listed."
Good example:
"We were stuck after generating 8 standard ideas. Applied 'Eliminate' specifically: what if we removed the entire setup wizard? Surfaced 2 strong ideas (defer setup until first use; pre-populate with sample data). 'Substitute' did not generate anything useful, skipped."
How to catch it. SCAMPER cells with no real insight should be empty, not filled with filler.
---
Red Flag 7: Voting Before Evidence
Symptom. Team votes on ideas using dots or rankings before discussing customer evidence. Most-voted idea wins.
Why it's bad. Voting without evidence is opinion aggregation, not discovery. The Opportunity Solution Tree exists to anchor decisions to evidence. Voting first lets the most charismatic advocate win regardless of customer signal.
Bad example:
"Dot vote on the 15 ideas. Idea D won with 7 dots. Building D."
Good example:
"For each idea, name the customer evidence that suggests it would work. Idea D: 'Sounds good in meetings, no interview quotes support it.' Idea B: '3 interviews surfaced this exact need.' B advances to experiment design despite D having more emotional appeal."
How to catch it. When you ranked ideas, did you list evidence for each? If not, you ranked on vibes.
---
Red Flag 8: How Might We (HMW) at Wrong Altitude
Symptom. HMW is either too narrow ("How might we change the button color?") or too broad ("How might we delight users?"). Either way, ideation under it is constrained or unfocused.
Why it's bad. HMW altitude controls ideation scope. Too narrow = micro-tweaks only. Too broad = unrankable ideas. The right altitude opens 5-15 distinct solution directions.
Bad example:
HMW: "How might we use AI?" (Too broad — produces grab-bag of AI features.) Or: "How might we change the upgrade button copy?" (Too narrow — only produces variations of one tactic.)
Good example:
HMW: "How might we help SMB users reach the activation moment within 5 minutes of signup?" Specific enough to constrain, broad enough to admit multiple solution approaches.
How to catch it. Does the HMW open 5-15 genuinely different solution directions? If fewer, narrow scope; if too many, raise altitude.
---
Red Flag 9: No Confidence Score on Ideas
Symptom. Idea list has impact estimates but no measure of how confident the team is in those estimates.
Why it's bad. Two ideas with equal impact estimates may have very different confidence levels — one based on customer interviews, the other on a single team member's hunch. Confidence is a separate dimension that affects sequencing.
Bad example:
"Idea A: high impact. Idea B: high impact. Both high impact, pick either."
Good example:
"Idea A: high impact, high confidence (3 customer interviews, market data). Idea B: high impact, low confidence (one stakeholder hunch). Sequence: build A first; design experiment to raise confidence on B before building."
How to catch it. Does each idea have a confidence score (or evidence column)? If not, you cannot distinguish proven bets from hunches.
---
Red Flag 10: Ideating Without Constraints
Symptom. "What's the best thing we could build?" — no budget, no timeline, no platform constraints. Ideas include "a fully autonomous AI agent" alongside "a button color change."
Why it's bad. Unconstrained ideation is sci-fi creative writing. Constraints are not limitations on creativity; they are the structure that produces buildable ideas. Skipping constraints produces a list mostly composed of ideas the team cannot ship.
Bad example:
Open prompt: "Best ideas for next year?" Output mixes 6-month features with 5-year moonshots.
Good example:
Constraints declared: 1 quarter timeline, current platform, 3-engineer team. Ideas that violate constraints are tagged "out of scope, parked for separate planning."
How to catch it. Are constraints written down before ideation? If not, parts of the output will be unbuildable.
---
Red Flag 11: Mistaking Quantity for Quality
Symptom. Team measures the brainstorm by idea count. "We generated 47 ideas!" is celebrated; whether any are good is unexamined.
Why it's bad. Quantity is a proxy for divergent thinking, but it does not guarantee quality. 47 ideas where 40 are slight variations is worse than 12 ideas spanning genuinely different approaches.
Bad example:
"Great session: 47 ideas." (38 of them are minor variations of 'add a tooltip to X'.)
Good example:
"12 ideas spanning 5 distinct approaches: feature additions (3), removals (2), workflow changes (3), platform reuse (2), partner integrations (2). Each approach has at least one strong candidate."
How to catch it. Cluster the ideas by approach. If most ideas fall in one cluster, divergence was insufficient.
---
Red Flag 12: Ideas with No Owner for the Next Step
Symptom. Workshop ends. The 15 ideas live on a Miro board. Two weeks later, no one has done anything with them. By week 4, they are forgotten.
Why it's bad. The output of ideation is not the ideas — it is the next steps. Without an owner for each candidate idea (or the top N), ideation is a feel-good session that produces no action.
Bad example:
"Workshop done. 15 ideas captured. Will follow up." (Two months later, no follow-up.)
Good example:
"Workshop output: top 3 ideas. Owner per idea: PM (idea A) will design a smoke test by Friday; designer (idea B) will prototype by next sprint; engineer (idea C) will spike feasibility by week 3. Review meeting in 4 weeks."
How to catch it. Each surviving idea must have an owner and a next step. If the doc ends with "we'll figure it out", the workshop fizzled.
---
Red Flag Quick Reference
| # | Anti-pattern | One-line check |
|---|---|---|
| 1 | Ideation Theater | Did the chosen idea differ from the PM's pre-walk-in idea? |
| 2 | HiPPO Override | When overridden, is the override documented with criteria? |
| 3 | Ideas Are Just Features | Each idea anchored to a named opportunity? |
| 4 | Single-Perspective | Full PM + Designer + Engineer trio present? |
| 5 | No Framing | Outcome + segment + constraints written before ideation? |
| 6 | SCAMPER as Performance | SCAMPER cells with no insight left empty? |
| 7 | Voting Before Evidence | Evidence listed per idea before voting? |
| 8 | HMW Wrong Altitude | Does HMW open 5-15 distinct solution directions? |
| 9 | No Confidence Score | Each idea has impact AND confidence? |
| 10 | Unconstrained | Constraints declared up front? |
| 11 | Quantity Over Quality | Ideas span multiple approach clusters? |
| 12 | No Owner for Next Step | Each surviving idea has owner + next step + date? |
Related Reading
- SKILL.md Troubleshooting section (for symptom -> root cause -> resolution)
- references/opportunity-solution-tree.md (if present)
- brainstorm-experiments/references/red-flags.md (for experiment design)
- identify-assumptions/references/red-flags.md (for connecting ideas to assumptions)
#!/usr/bin/env python3
"""Idea Scorer - Score and rank product ideas using weighted criteria.
Reads a list of ideas with scores across 5 criteria and produces a
weighted ranking with recommendations for validation.
Usage:
python idea_scorer.py --ideas ideas.json
python idea_scorer.py --ideas ideas.json --json
python idea_scorer.py --example
"""
import argparse
import json
import sys
DEFAULT_WEIGHTS = {
"customer_impact": 0.30,
"strategic_alignment": 0.25,
"feasibility": 0.20,
"speed_to_validate": 0.15,
"differentiation": 0.10,
}
def load_data(path: str) -> dict:
with open(path, "r") as f:
return json.load(f)
def score_ideas(data: dict) -> dict:
ideas = data.get("ideas", [])
weights = data.get("weights", DEFAULT_WEIGHTS)
context = data.get("context", {})
results = []
for idea in ideas:
name = idea.get("name", "Untitled")
scores = idea.get("scores", {})
weighted_score = 0
for criterion, weight in weights.items():
raw = scores.get(criterion, 5)
raw = max(1, min(10, raw))
weighted_score += raw * weight
weighted_score = round(weighted_score, 2)
# Validation suggestion based on weakest score
weakest = min(scores.items(), key=lambda x: x[1]) if scores else ("unknown", 5)
validation_focus = {
"customer_impact": "Run 5 customer interviews to validate the pain point severity.",
"strategic_alignment": "Map this idea to a specific OKR and get stakeholder confirmation.",
"feasibility": "Run a technical spike (2-3 days) to validate core assumptions.",
"speed_to_validate": "Design a Wizard-of-Oz or concierge test for rapid validation.",
"differentiation": "Conduct competitive analysis on the top 3 alternatives.",
}.get(weakest[0], "Validate the riskiest assumption first.")
results.append({
"rank": 0,
"name": name,
"source": idea.get("source", "Unknown"),
"description": idea.get("description", ""),
"weighted_score": weighted_score,
"scores": scores,
"effort": idea.get("effort", "M"),
"riskiest_assumption": idea.get("riskiest_assumption", "TBD"),
"validation_suggestion": validation_focus,
"weakest_criterion": weakest[0],
})
results.sort(key=lambda x: x["weighted_score"], reverse=True)
for i, r in enumerate(results, 1):
r["rank"] = i
return {
"context": context,
"weights": weights,
"total_ideas": len(results),
"ideas": results,
"top_5": results[:5],
}
def print_report(result: dict) -> None:
ctx = result.get("context", {})
if ctx:
print(f"\nIdea Scoring: {ctx.get('target_outcome', 'Product Ideation')}")
else:
print(f"\nIdea Scoring Results")
print("=" * 70)
print(f"\nRanking ({result['total_ideas']} ideas):")
print(f" {'Rank':>4} {'Name':<25} {'Source':<10} {'Score':>6} {'Effort':<6} {'Weakest'}")
print(f" {'-'*4} {'-'*25} {'-'*10} {'-'*6} {'-'*6} {'-'*20}")
for idea in result["ideas"]:
name = idea["name"][:23] + ".." if len(idea["name"]) > 25 else idea["name"]
print(f" {idea['rank']:>4} {name:<25} {idea['source']:<10} {idea['weighted_score']:>6.2f} {idea['effort']:<6} {idea['weakest_criterion']}")
print(f"\nTop 5 Details:")
for idea in result["top_5"]:
print(f"\n #{idea['rank']} {idea['name']} (Score: {idea['weighted_score']:.2f})")
if idea["description"]:
print(f" {idea['description'][:80]}")
print(f" Riskiest Assumption: {idea['riskiest_assumption']}")
print(f" Validation: {idea['validation_suggestion']}")
print()
def print_example() -> None:
example = {
"context": {"target_outcome": "Reduce time-to-value from 14 days to 3 days"},
"ideas": [
{
"name": "Guided Onboarding Wizard",
"source": "PM",
"description": "Step-by-step wizard for first-time setup",
"effort": "M",
"riskiest_assumption": "Users will complete the wizard rather than skip it",
"scores": {"customer_impact": 9, "strategic_alignment": 8, "feasibility": 7, "speed_to_validate": 6, "differentiation": 5},
},
{
"name": "Smart Defaults Engine",
"source": "Engineer",
"description": "Auto-configure settings based on industry and company size",
"effort": "L",
"riskiest_assumption": "We can accurately predict useful defaults from limited signup data",
"scores": {"customer_impact": 7, "strategic_alignment": 7, "feasibility": 5, "speed_to_validate": 4, "differentiation": 8},
},
{
"name": "Interactive Demo Mode",
"source": "Designer",
"description": "Pre-populated demo environment users can explore before committing",
"effort": "S",
"riskiest_assumption": "Exploring a demo translates to higher activation",
"scores": {"customer_impact": 6, "strategic_alignment": 6, "feasibility": 8, "speed_to_validate": 9, "differentiation": 6},
},
],
}
print(json.dumps(example, indent=2))
def main():
parser = argparse.ArgumentParser(description="Score and rank product ideas.")
parser.add_argument("--ideas", type=str, help="Path to ideas JSON file")
parser.add_argument("--json", action="store_true", help="Output as JSON")
parser.add_argument("--example", action="store_true", help="Print example and exit")
args = parser.parse_args()
if args.example:
print_example()
return
if not args.ideas:
parser.error("--ideas is required")
data = load_data(args.ideas)
result = score_ideas(data)
if args.json:
print(json.dumps(result, indent=2))
else:
print_report(result)
if __name__ == "__main__":
main()
#!/usr/bin/env python3
"""Opportunity Tree Builder - Generate Opportunity Solution Trees from structured data.
Reads outcome, opportunity, and solution data and produces a structured
tree visualization with coverage analysis.
Usage:
python opportunity_tree_builder.py --tree tree.json
python opportunity_tree_builder.py --tree tree.json --json
python opportunity_tree_builder.py --example
"""
import argparse
import json
import sys
def load_data(path: str) -> dict:
with open(path, "r") as f:
return json.load(f)
def build_tree(data: dict) -> dict:
outcome = data.get("outcome", "Undefined Outcome")
opportunities = data.get("opportunities", [])
tree_nodes = []
total_solutions = 0
opportunities_without_evidence = []
opportunities_without_solutions = []
for opp in opportunities:
opp_name = opp.get("name", "Unknown")
evidence = opp.get("evidence", [])
solutions = opp.get("solutions", [])
if not evidence:
opportunities_without_evidence.append(opp_name)
if not solutions:
opportunities_without_solutions.append(opp_name)
solution_nodes = []
for sol in solutions:
sol_name = sol.get("name", "Unknown")
effort = sol.get("effort", "M")
confidence = sol.get("confidence", "Medium")
status = sol.get("status", "Proposed")
total_solutions += 1
solution_nodes.append({
"name": sol_name,
"effort": effort,
"confidence": confidence,
"status": status,
})
tree_nodes.append({
"opportunity": opp_name,
"evidence_count": len(evidence),
"evidence_sources": evidence[:3],
"solution_count": len(solutions),
"solutions": solution_nodes,
})
# Analysis
avg_solutions_per_opp = round(total_solutions / len(opportunities), 1) if opportunities else 0
recs = []
if opportunities_without_evidence:
recs.append(f"{len(opportunities_without_evidence)} opportunity(ies) without evidence. Conduct user interviews to validate: {', '.join(opportunities_without_evidence[:3])}")
if opportunities_without_solutions:
recs.append(f"{len(opportunities_without_solutions)} opportunity(ies) without solutions. Run ideation sessions for: {', '.join(opportunities_without_solutions[:3])}")
if avg_solutions_per_opp < 2:
recs.append("Average solutions per opportunity is low. Aim for 3+ solutions per opportunity to enable comparison.")
single_solution_opps = [n["opportunity"] for n in tree_nodes if n["solution_count"] == 1]
if single_solution_opps:
recs.append(f"Opportunities with only 1 solution (risky -- add alternatives): {', '.join(single_solution_opps[:3])}")
return {
"outcome": outcome,
"total_opportunities": len(opportunities),
"total_solutions": total_solutions,
"avg_solutions_per_opportunity": avg_solutions_per_opp,
"tree": tree_nodes,
"gaps": {
"without_evidence": opportunities_without_evidence,
"without_solutions": opportunities_without_solutions,
},
"recommendations": recs,
}
def print_tree(result: dict) -> None:
print(f"\nOpportunity Solution Tree")
print("=" * 60)
print(f"Outcome: {result['outcome']}")
print(f"Opportunities: {result['total_opportunities']} | Solutions: {result['total_solutions']} | Avg: {result['avg_solutions_per_opportunity']:.1f}/opp")
for node in result["tree"]:
evidence_str = f" ({node['evidence_count']} evidence)" if node["evidence_count"] > 0 else " (NO EVIDENCE)"
print(f"\n +-- {node['opportunity']}{evidence_str}")
for sol in node["solutions"]:
status_icon = {"Proposed": "?", "Testing": "~", "Validated": "+", "Rejected": "x"}.get(sol["status"], "?")
print(f" [{status_icon}] {sol['name']} (Effort: {sol['effort']}, Confidence: {sol['confidence']})")
if not node["solutions"]:
print(f" (no solutions yet)")
if result["recommendations"]:
print(f"\nRecommendations:")
for i, r in enumerate(result["recommendations"], 1):
print(f" {i}. {r}")
print()
def print_example() -> None:
example = {
"outcome": "Reduce time-to-value from 14 days to 3 days",
"opportunities": [
{
"name": "Users don't know what to do after signup",
"evidence": ["Interview #3: 'I signed up but had no idea what to do next'", "Analytics: 60% drop-off before first action"],
"solutions": [
{"name": "Guided onboarding wizard", "effort": "M", "confidence": "High", "status": "Testing"},
{"name": "Contextual tooltips", "effort": "S", "confidence": "Medium", "status": "Proposed"},
{"name": "Welcome video series", "effort": "S", "confidence": "Low", "status": "Proposed"},
],
},
{
"name": "Initial configuration is too complex",
"evidence": ["Support tickets: 40% about setup", "Interview #7: 'Too many settings before I can do anything'"],
"solutions": [
{"name": "Smart defaults based on industry", "effort": "L", "confidence": "Medium", "status": "Proposed"},
{"name": "Setup template library", "effort": "M", "confidence": "High", "status": "Proposed"},
],
},
{
"name": "Value not visible until data accumulates",
"evidence": [],
"solutions": [],
},
],
}
print(json.dumps(example, indent=2))
def main():
parser = argparse.ArgumentParser(description="Build Opportunity Solution Trees.")
parser.add_argument("--tree", type=str, help="Path to tree data JSON file")
parser.add_argument("--json", action="store_true", help="Output as JSON")
parser.add_argument("--example", action="store_true", help="Print example and exit")
args = parser.parse_args()
if args.example:
print_example()
return
if not args.tree:
parser.error("--tree is required")
data = load_data(args.tree)
result = build_tree(data)
if args.json:
print(json.dumps(result, indent=2))
else:
print_tree(result)
if __name__ == "__main__":
main()
#!/usr/bin/env python3
"""SCAMPER Generator - Generate SCAMPER ideation prompts for product features.
Takes a feature or product description and generates structured prompts
across all 7 SCAMPER dimensions to stimulate creative thinking.
Usage:
python scamper_generator.py --feature "User onboarding flow"
python scamper_generator.py --feature "User onboarding flow" --json
python scamper_generator.py --input input.json
"""
import argparse
import json
import sys
SCAMPER_DIMENSIONS = {
"Substitute": {
"description": "What components, materials, or processes can be replaced?",
"prompts": [
"What if we replaced {feature} with a completely different approach?",
"What technology could substitute for the current implementation?",
"What if a different user action triggered this instead?",
"Could we substitute the manual step with automation?",
"What if we replaced the UI with a conversational interface?",
],
},
"Combine": {
"description": "What features, ideas, or processes can be merged?",
"prompts": [
"What if {feature} was combined with another feature users commonly use together?",
"Could we merge this step with the previous or next step?",
"What if we bundled this with the user's most common next action?",
"Could two separate screens become one unified experience?",
"What data from another part of the product could enhance this?",
],
},
"Adapt": {
"description": "What can be borrowed from other products or contexts?",
"prompts": [
"What would {feature} look like if designed by a gaming company?",
"How do social media apps solve a similar problem?",
"What pattern from e-commerce could we adapt here?",
"How would this work if adapted for a mobile-first context?",
"What approach do our top competitors use that we could improve upon?",
],
},
"Modify": {
"description": "What can be magnified, minimized, or changed in form?",
"prompts": [
"What if {feature} was 10x simpler with fewer options?",
"What if we made the output 10x more detailed/comprehensive?",
"What would change if we served power users instead of beginners?",
"How would this change if the time constraint was halved?",
"What if we changed the frequency (daily -> real-time, or weekly -> on-demand)?",
],
},
"Put to other use": {
"description": "Can this feature serve a different purpose or audience?",
"prompts": [
"Who else (beyond the current users) would benefit from {feature}?",
"Could this feature serve an internal team's need as well?",
"What if we exposed this as an API for third-party developers?",
"Could the data generated by this feature power a different insight?",
"What if this became a standalone product instead of a feature?",
],
},
"Eliminate": {
"description": "What can be removed, simplified, or made unnecessary?",
"prompts": [
"What if we removed {feature} entirely -- what would users do instead?",
"Which step in the current flow adds the least value?",
"What if we eliminated all optional fields and kept only required ones?",
"Could we remove a decision point by making it automatic?",
"What would happen if we eliminated the confirmation step?",
],
},
"Reverse": {
"description": "What if we reversed the order, roles, or direction?",
"prompts": [
"What if the user received the output of {feature} first, then provided input?",
"What if the system did the work and the user only reviewed/approved?",
"What if we reversed the sequence of steps?",
"What if instead of the user finding content, the content found the user?",
"What if we started from the end goal and worked backward?",
],
},
}
def generate_scamper(feature: str) -> dict:
"""Generate SCAMPER prompts for a feature."""
dimensions = []
for name, dim in SCAMPER_DIMENSIONS.items():
prompts = [p.replace("{feature}", feature) for p in dim["prompts"]]
dimensions.append({
"dimension": name,
"description": dim["description"],
"prompts": prompts,
})
return {
"feature": feature,
"total_prompts": sum(len(d["prompts"]) for d in dimensions),
"dimensions": dimensions,
"instructions": "For each prompt, generate 1-2 concrete ideas. Then select the top 3-5 ideas across all dimensions for further evaluation.",
}
def print_report(result: dict) -> None:
print(f"\nSCAMPER Ideation: {result['feature']}")
print("=" * 60)
print(f"Total Prompts: {result['total_prompts']}")
print(f"\n{result['instructions']}")
for dim in result["dimensions"]:
print(f"\n--- {dim['dimension'].upper()} ---")
print(f" {dim['description']}")
for i, prompt in enumerate(dim["prompts"], 1):
print(f" {i}. {prompt}")
print()
def main():
parser = argparse.ArgumentParser(description="Generate SCAMPER ideation prompts.")
parser.add_argument("--feature", type=str, help="Feature or product to apply SCAMPER to")
parser.add_argument("--input", type=str, help="Path to JSON with feature description")
parser.add_argument("--json", action="store_true", help="Output as JSON")
args = parser.parse_args()
feature = args.feature
if args.input:
with open(args.input, "r") as f:
data = json.load(f)
feature = data.get("feature", feature)
if not feature:
parser.error("--feature or --input is required")
result = generate_scamper(feature)
if args.json:
print(json.dumps(result, indent=2))
else:
print_report(result)
if __name__ == "__main__":
main()
Related skills
FAQ
How many ideas does it generate?
It generates 5 ideas from each of the PM, Designer, and Engineer perspectives, 15 total, then prioritizes the top 5.
What frameworks does it use?
The Product Trio approach and Teresa Torres' Opportunity Solution Tree, plus SCAMPER and How Might We as supplementary techniques.