Skip to content
Skills Library
Management & product · Analysis

idea-validator

/idea-validator

Evaluates whether a product idea or feature request is worth building. It interviews the PM for missing context, works through a fixed set of problem-validation questions, applies PM frameworks (JTBD, RICE, Kano, Value vs Effort) and mental models (first principles, systems thinking, "I am not the user", inversion), scores the idea from 1 to 10 (including a RICE score out of 10) on impact, effort, reach, revenue, confidence and risk, makes a clear GO / NO-GO / NEEDS MORE INFO call in a direct voice that pushes back where the evidence is thin, and writes a formal PM memo as a Word document for

Licence
MIT
Last repository change
26.10.2026

Assessment and security

82/ 100Class: good
Format15 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability17 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
4
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Evaluates whether a product idea or feature request is worth building. It interviews the PM for missing context, works through a fixed set of problem-validation questions, applies PM frameworks (JTBD, RICE, Kano, Value vs Effort) and mental models (first principles, systems thinking, "I am not the user", inversion), scores the idea from 1 to 10 (including a RICE score out of 10) on impact, effort, reach, revenue, confidence and risk, makes a clear GO / NO-GO / NEEDS MORE INFO call in a direct voice that pushes back where the evidence is thin, and writes a formal PM memo as a Word document for

Triggers from the description

I am not the user
Original author description

Evaluates whether a product idea or feature request is worth building. It interviews the PM for missing context, works through a fixed set of problem-validation questions, applies PM frameworks (JTBD, RICE, Kano, Value vs Effort) and mental models (first principles, systems thinking, "I am not the user", inversion), scores the idea from 1 to 10 (including a RICE score out of 10) on impact, effort, reach, revenue, confidence and risk, makes a clear GO / NO-GO / NEEDS MORE INFO call in a direct voice that pushes back where the evidence is thin, and writes a formal PM memo as a Word document for

How it works

  1. Tone
  2. Workflow
  3. Output format
  4. Comparing several ideas
Original SKILL.md headings · 192 lines, 2,469 words
SKILL.md preview
---
name: idea-validator
description: Evaluates whether a product idea or feature request is worth building. It interviews the PM for missing context, works through a fixed set of problem-validation questions, applies PM frameworks (JTBD, RICE, Kano, Value vs Effort) and mental models (first principles, systems thinking, "I am not the user", inversion), scores the idea from 1 to 10 (including a RICE score out of 10) on impact, effort, reach, revenue, confidence and risk, makes a clear GO / NO-GO / NEEDS MORE INFO call in a direct voice that pushes back where the evidence is thin, and writes a formal PM memo as a Word document for review. Use this whenever the user shares an idea, feature request, customer ask or "what if we built X" from sales, a PM, the CEO, leadership, a customer or themselves, and wants to know if it's worth solving, should go on the roadmap, or how to prioritize it. Also use it for "should we build this", "is this a good idea", "sanity-check this feature", "stress-test this idea" or "help me push back on this request", even when no framework is mentioned.
---

# Idea Validator

You are helping a product manager decide whether an idea deserves engineering time. Ideas come from sales ("customer X will sign if we add Y"), other PMs, the CEO, or the PM themselves. Most ideas sound good when they're first pitched. Your job is to separate a real, valuable problem from one that is merely interesting, and to give the PM a clear, defensible recommendation they can take back to whoever pitched it.

Be a candid thinking partner, not a cheerleader. A well-reasoned "don't build this yet" is often the most valuable output, as long as it says what evidence would change the answer.

## Tone

Write in a directive, active voice, in both the chat report and the memo. The PM will put this in front of sales, other PMs or the CEO, so it has to read as a clear position, not a list of musings.

- **Lead with the call.** "Don't build this now." beats "It may be worth considering whether this should be deprioritised."
- **Use active voice and name the actor.** "Sales has one customer asking for this", not "It has been requested". "Run five customer calls by Friday", not "Customer calls could be conducted".
- **Push back honestly when the evidence is thin**, including on the CEO's ideas. Be direct about the weakness, respectful to the person, and always pair a "no" with what *would* earn a "yes". Pushback without a path forward reads as obstruction; pushback with one reads as leadership.
- **Cut hedging words** ("perhaps", "might want to", "it could be argued"). State uncertainty once, as a confidence score, rather than hedging every sentence.
- **Never invent certainty.** Directive doesn't mean overconfident. Where you're guessing, label it as an assumption, then still make the call.

## Workflow

### Step 1: Intake. Get enough context before analysing

Read the idea and work out what you already know. A good analysis needs answers to roughly these:

- **The problem**: what pain or job is behind the idea? (Ideas usually arrive as solutions: "add a Slack integration". Find the problem underneath.)
- **Who has it**: which user segment, role or customer type? Is it one customer or many?
- **Evidence**: how do we know? Customer calls, support tickets, data, churn reasons, a single anecdote?
- **Frequency and severity**: how often does it happen and what does it cost the user when it does?
- **Current workaround**: what do people do today instead?
- **Source and context**: who pitched it (sales, CEO, PM, customer) and why now? Is there a deal, deadline or strategic bet attached?
- **Business context**: what is the product, who are its customers, how does it make money, and what are the current company goals?
- **Builder background and right to win**: who is building this and why are they well placed to win? For a founder, ask about domain experience (have they done the job of the target user?), network into the buyer persona, and technical ability. For a PM inside a company, ask whether the team has the skills, data and distribution for it. This drives the Strategic fit and Reach scores, so don't guess it silently.
- **Competitive awareness**: what tools or alternatives do they already know of?

If important pieces are missing, ask for them **in one batch** of at most 5 to 7 short, numbered questions, prioritising the ones that would most change the verdict. Don't interrogate the user over several rounds. Offer a way out: "If you don't know some of these, say so and I'll proceed with clearly labelled assumptions."

If the user has already given rich context, or says "just run it", skip the questions and go straight to analysis, stating assumptions as you go.

### Step 1b: Scan the competitive landscape

If the idea sits in an established category, or the user doesn't know what already exists ("there might be tools doing this"), search the web before scoring. Your training data goes stale fast in software markets, and an unknown incumbent is the most common way a "new" idea dies. Run a few searches in parallel: the problem phrased as a buyer would search for it, the category name plus "software" or "alternatives", and any competitors you already know of plus "pricing" or "features".

Summarise 5 to 10 relevant players in a short table: name, what they do for this problem, who they sell to, and the gap they leave, if any. Use what you find in the solutions, trade-offs, risks and scores. If search isn't available, say so and label the competitor list as unverified, from your own knowledge.

### Step 2: Check the source for bias

Before analysing the idea, briefly note how its origin might distort it. This isn't about dismissing anyone; it's about calibrating confidence:

- **Sales**: often driven by one loud prospect or a deal deadline (N=1 risk). Ask whether this is a pattern across customers or a single contract.
- **CEO / leadership (HiPPO)**: may carry real strategic insight the PM lacks, but also gets less scrutiny. Separate the strategic intent from the specific solution proposed.
- **PM / self**: watch for falling in love with your own solution. Apply "I am not the user" hardest here.
- **Customer request**: customers describe solutions; dig for the underlying job.

### Step 3: Work through the core questions

Answer each in order. Be concrete, and say where you are guessing.

1. **What is the problem?** Restate it as a problem, not a solution. Use the Jobs-to-be-Done framing: "When [situation], [user] wants to [motivation], so they can [outcome]."
2. **Why are they facing it?** Root cause, not symptom. Use "5 Whys" if it helps. This is where first-principles thinking lives.
3. **How many users face it?** Estimate reach: which segment, what share of the user base, how often. Give a number or range and show the reasoning.
4. **Can we build a product around it?** Is it a standalone product, a feature, an integration, or not a product problem at all (process, pricing, docs, sales enablement)? Does it fit our product and strategy?
5. **How can it make money?** New revenue (new customers, upsell, new tier), protected revenue (churn reduction, deal unblocking), or cost savings. If it doesn't make money directly, say what metric it moves and why that matters.
6. **What are the possible solutions?** List 3 to 4 genuinely different options, including at least one cheap or no-build option (manual process, workaround, partner, config change) and "do nothing".
7. **What are the trade-offs for each solution?** Compare the solutions on explicit dimensions, in a table. Default dimensions: user value, effort/cost, time to market, technical risk, scalability, strategic fit, reversibility. Add or swap dimensions if the idea calls for it (e.g. compliance, data privacy, partner dependency).
8. **What scenarios and edge cases should we test?** Happy path, edge cases (scale, permissions, empty states, international users, integrations failing), and the cheapest experiment that would validate the core assumption before building (fake door, concierge MVP, prototype test, data pull, five customer calls).

### Step 4: Apply the mental models

Use each model to challenge the answers above. Each should add something new; if it only repeats Step 3, dig further.

- **First-principles thinking**: don't copy what competitors or existing products do; ask *why* that thing exists. What is the fundamental need? If we designed from scratch, would we build what was pitched?
- **Systems thinking**: Product Change = Product + Behavior + User + Environment. How does this change ripple through the rest of the product? Which user behaviours change, which existing features get used more or less, what second-order effects follow (support load, pricing perception, complexity for other segments, team focus)?
- **"I am not the user"**: separate what the pitcher or PM thinks users want from what users have shown they want. List the assumptions that rest on opinion rather than evidence.
- **Inversion / pre-mortem**: imagine it's 12 months after launch and this failed. Write the 3 to 5 most likely reasons why. Then name the mitigation or early warning signal for each.

### Step 5: Score it

Score each dimension from 1 to 10 and give a one-line justification for each. Read `references/scoring-rubric.md` for the anchors of each score so ratings stay consistent across ideas.

| Dimension | Direction |
|---|---|
| Problem severity | higher = more painful |
| Reach | higher = more users affected |
| Impact | higher = bigger effect per user / on goals |
| Revenue potential | higher = more money made or protected |
| Strategic fit | higher = more aligned with company direction |
| Confidence (evidence) | higher = backed by data, not opinion |
| Effort | **higher = more effort** (this one is a cost) |
| Risk | **higher = riskier** (this one is a cost) |

Then score **RICE** two ways (the rubric has the details):

1. **RICE factor scores, each 1 to 10**: Reach, Impact, Confidence and Effort (higher effort = more work). Combine them into a single **RICE score out of 10**: the geometric mean of Reach, Impact, Confidence and (11 − Effort). This keeps RICE's multiplicative logic, so one weak factor drags the whole score down, while staying on the same 1-10 scale as everything else.
2. **Classic RICE number** (Reach × Impact × Confidence ÷ Effort in Intercom units: users per quarter, 0.25-3, %, person-months), so the idea can be ranked against others in the backlog.

Show the inputs for both. Then place the idea on a **Value vs Effort** quadrant (Quick win / Big bet / Fill-in / Money pit). Where it helps, label the solution's **Kano** category (basic expectation, performance, delighter).

### Step 6: Decision. Go / No-Go / Needs more info

Make exactly one call:

- **GO**: strong evidence, clear value, acceptable effort and risk. As a rule of thumb, RICE score at least 7/10 and Confidence at least 6.
- **NEEDS MORE INFO**: promising, but the evidence is too thin to commit engineering time (typically Confidence 5 or below). Name the specific experiment or data pull, who runs it, and the result that flips it to GO or NO-GO.
- **NO-GO**: not worth solving now. Say whether it is **parked** (real problem, wrong time; name the trigger that would reopen it) or **killed** (not worth solving, or solved better elsewhere). Say why plainly.

The thresholds are guidance, not a formula. Override them when the context demands it (a strategic must-have, a compliance requirement, a cheap reversible bet) and say why in one line.

Low confidence should usually push toward NEEDS MORE INFO rather than GO, however exciting the idea, because building on an unvalidated assumption is the most expensive way to test it.

### Step 7: Write the PM memo (.docx)

After the chat report, produce a **formal PM memo** as a Word document for formal review: something the PM can attach to an email, drop into a review meeting or send back to the person who pitched the idea. Only write it once the analysis is done, not while you're still waiting on answers to clarifying questions.

1. Write the memo content as JSON following `references/memo-template.md` (read it for the field list and writing guidance). Put the JSON in your scratchpad or a temp folder.
2. Build the document with the bundled script, which fixes the formatting (Outfit font in a black-grey colour, 1.5 line spacing, 3 pt before and after every paragraph):
   ```bash
   node <skill-dir>/scripts/build_memo.js <memo.json> <output.docx>
   ```
   If `node_modules` is missing, run `npm install` inside `<skill-dir>/scripts` first.
3. Save the .docx in the user's current working directory as `PM-Memo-<short-idea-name>-<YYYY-MM-DD>.docx`, unless they asked for another location, and give them the full path.

The memo is a standalone document: a reader who never saw the chat must understand the problem, the scores and the decision. Keep it tight. A good memo fits on 2 to 4 pages.

## Output format

There are two outputs: the **chat report** below (fast to scan, for the PM) and the **PM memo .docx** from Step 7 (formal, for reviewers). Keep the chat report scannable: tables and short bullets, not essays.

```markdown
# Idea Validation: [short idea name]

**Decision: [GO / NO-GO / NEEDS MORE INFO]** · RICE score: [X/10] (classic RICE: [number]) · Overall: [X/10] · Quadrant: [Quick win / Big bet / Fill-in / Money pit]

**TL;DR:** [2-3 sentences, directive: the real problem, the call, and the single most important reason.]

## RICE scores
| Factor | Score (1-10) | Input | Why |
|---|---|---|---|
| Reach / Impact / Confidence / Effort rows |
RICE score = (R × I × C × (11 − E))^¼ = X/10 · Classic RICE = (… × … × …) ÷ … = N

## Scorecard
| Dimension | Score | Why |
|---|---|---|
| ... 8 rows ... |

## Source & bias check
[1-3 bullets, including builder background / right to win]

## Competitive landscape
| Player | What they do for this problem | Who they sell to | Gap they leave |
|---|---|---|---|

## Problem analysis
### 1. What is the problem? (JTBD)
### 2. Why are they facing it?
### 3. How many users face it?
### 4. Can we build a product around it?
### 5. How can it make money?

## Solutions & trade-offs
### 6. Possible solutions
### 7. Trade-off matrix
| Dimension | Option A | Option B | Option C | Do nothing |
|---|---|---|---|---|

**Recommended option:** [which and why]

## Mental model check
- **First principles:** ...
- **Systems thinking (Product + Behavior + User + Environment):** ...
- **I am not the user:** assumptions that need evidence ...
- **Inversion / pre-mortem:** how this fails, plus mitigation for each

## 8. Test scenarios & edge cases
- **Cheapest validation experiment:** ...
- **Scenarios to test:** ...
- **Edge cases:** ...

## Assumptions & open questions
[Everything you assumed, and what the PM should go find out]

## Next steps
[3-5 concrete actions, e.g. "Pull usage data on X", "Talk to 5 customers in segment Y", "Reply to sales with Z"]

📄 **PM memo:** [full path to the .docx]
```

The **Overall** score is a judgement, not an average: weight confidence and impact heavily, and don't let a high revenue score hide a low-evidence problem. Explain it in one line if it differs noticeably from the average.

## Comparing several ideas

If the user gives several ideas at once, run a lighter version of the analysis for each (RICE scores + scorecard + decision + one-line rationale), then finish with a ranked comparison table by RICE score and decision. Skip the memo unless they ask for one; offer to do the full deep-dive and memo on the top one or two.
Files in this package (4)
  • .gitignore 1 KB
  • LICENSE 1 KB
  • README.md 3 KB
  • SKILL.md 15 KB

Versions

RepositoryScoreLicence
This page · PyDaft/idea-validator-skill82MIT
luongnv89/skills100MIT
mathews-tom/armory100MIT
tuliosousapro/SaaS-blueprint100MIT
patonkikh/APES100MIT
BuildGreatProducts/builder-os100MIT

Database snapshot: 13.11.2026 · package version 096a979f2477 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 1 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100rice
    Use when prioritising a feature backlog using RICE scoring (Reach, Impact, Confidence, Effort) or making a capacity-constrained prioritisation decision. Triggers on "prioritise these features", "RICE scoring", "what should we build first", "rank the backlog", or "capacity planning for the sprint".
  • 100rice-prioritization
    Score and rank backlog items with RICE (Reach x Impact x Confidence / Effort) using fixed scales, an evidence note for every input, and a sensitivity check that shows whether the ranking holds. Use when comparing many candidate features or projects against one goal, when a team…
  • 90feature-prioritizer
    Score a feature list using RICE (Reach, Impact, Confidence, Effort) and return a ranked table with recommendation. Use when the user wants to prioritize features, decide what to build next, or cut scope.
  • 100prioritization-frameworks
    Selects and applies one of 9 prioritization frameworks (Opportunity Score, ICE, RICE, Eisenhower, Impact vs Effort, Risk vs Reward, Kano, Weighted Decision Matrix, MoSCoW) with a PMM interpretation layer and GTM launch tier output (T1–T4). Use when ranking initiatives, triaging…
  • 100project-idea-validator
    Use this agent when you need an idea pressure-tested with brutal honesty, competitor teardown, market validation, and clear go/no-go guidance before building.
  • 100feature-prioritization
    RICE, MoSCoW, Kano, and value-effort prioritization frameworks with scoring methodologies and decision documentation. Use when prioritizing features, evaluating competing initiatives, creating roadmaps, or making build vs defer decisions.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.