How to Identify and Prioritize Risky Assumptions Using the identify-assumptions Skill

The identify-assumptions skill family in the pm-skills repository provides a structured framework to surface hidden product risks through multi-perspective analysis and then rank them using an Impact × Risk matrix, outputting actionable validation experiments.

The identify-assumptions skill is a critical component of the Discover command (/discover) in the phuryn/pm-skills repository. This skill systematically uncovers hidden risks in product ideas before development begins, preventing costly rework by forcing teams to examine assumptions across Product, Design, and Engineering perspectives. Whether you are validating a new startup concept or stress-testing a feature for an existing product, learning how to identify and prioritize risky assumptions ensures you invest resources only in ideas with validated risk profiles.

Understanding the identify-assumptions Skill Variants

The framework provides two distinct skills tailored to different product lifecycle stages. Both follow the same analytical pattern but differ in scope and risk categories.

identify-assumptions-existing

Use this skill when stress-testing features for products that already ship. According to pm-product-discovery/skills/identify-assumptions-existing/SKILL.md, this variant examines four core risk categories: Value, Usability, Viability, and Feasibility. The model adopts three stakeholder perspectives—Product Manager, Designer, and Engineer—to enumerate why the idea might fail within each category.

identify-assumptions-new

Use this skill for brand-new concepts, startups, or ideas without a live product. As defined in pm-product-discovery/skills/identify-assumptions-new/SKILL.md, this variant expands the analysis to eight risk categories: the four core risks plus Ethics, Go-to-Market, Strategy & Objectives, and Team. This broader scope accounts for the higher uncertainty inherent in greenfield development.

How to Identify Risky Assumptions

When you invoke either skill through the /discover command, the model executes a three-step analytical process against your product description and attached artifacts (PRDs, research, or wireframes).

Step 1: Multi-Perspective Threat Modeling

The model first enumerates failure modes from the three perspectives. This forces cross-functional thinking that surfaces concerns a single role might miss. The Product Manager evaluates business value, the Designer examines usability constraints, and the Engineer flags technical feasibility risks.

Step 2: Assumption Extraction

Next, the model translates threats into explicit assumptions organized by risk category. For each category, it lists specific beliefs that must hold true for the product to succeed. For example, under Value, an assumption might state: "Users will pay $20/month for this feature."

Step 3: Confidence Scoring and Test Definition

Finally, the model assigns a confidence level (High, Medium, or Low) to each assumption and proposes a concrete validation experiment. The output is a markdown table that you can copy directly into Confluence, Notion, or your sprint backlog.

How to Prioritize Assumptions Using the Impact × Risk Matrix

Once you have the raw assumptions table, the next step is the prioritize-assumptions skill defined in pm-product-discovery/skills/prioritize-assumptions/SKILL.md. This skill transforms vague worries into a ranked priority list using quantitative scoring.

The Prioritization Logic

The skill evaluates each assumption across two dimensions:

• Impact: How significantly would the assumption, if true or false, affect the product's success?
• Risk (Uncertainty): How uncertain is the assumption? Lower confidence equals higher risk.

The model calculates a priority score by multiplying Impact by Risk (e.g., Impact 5 × Risk 4 = 20). It then sorts all assumptions from highest to lowest score.

Automated Experiment Recommendations

For the top-ranked assumptions, the skill automatically proposes lightweight experiments to reduce uncertainty. These might include user interviews, prototype tests, or technical feasibility spikes. This bridges the gap between risk identification and actionable sprint tickets.

End-to-End Workflow Integration

The assumption identification and prioritization skills operate as sequential stages within the /discover command pipeline. As documented in pm-product-discovery/commands/discover.md, the linear workflow follows this chain:

/discover
   ├─ brainstorm-ideas
   ├─ identify-assumptions-{existing|new}
   ├─ prioritize-assumptions
   └─ brainstorm-experiments

This structured flow ensures you first surface what could go wrong, then rank what matters most, and finally plan how to test the highest-risk assumptions. The methodology aligns with lean startup principles and assumption mapping techniques used by product teams worldwide.

Practical Implementation Example

While the pm-skills framework runs as an internal orchestration layer, the following Python example illustrates how you might invoke these skills programmatically against the skill endpoints:

import requests

def identify_assumptions(product_desc, is_new_product=False):
    """Run assumption identification for new or existing products."""
    skill_name = (
        "identify-assumptions-new" 
        if is_new_product 
        else "identify-assumptions-existing"
    )
    
    payload = {
        "skill": skill_name,
        "arguments": product_desc
    }
    
    response = requests.post(
        "http://localhost:8000/skill", 
        json=payload
    )
    return response.json()  # Returns markdown table of assumptions

def prioritize_assumptions(assumptions_table):
    """Score and rank assumptions using Impact × Risk matrix."""
    payload = {
        "skill": "prioritize-assumptions",
        "markdown": assumptions_table
    }
    
    response = requests.post(
        "http://localhost:8000/skill", 
        json=payload
    )
    return response.json()  # Returns ranked table + experiment suggestions

Summary

• Choose the correct variant: Use identify-assumptions-existing for shipped products (4 risk categories) and identify-assumptions-new for greenfield concepts (8 risk categories).
• Force three-perspective thinking: The skills require analysis from Product Manager, Designer, and Engineer viewpoints to ensure comprehensive risk coverage.
• Quantify uncertainty: The prioritize-assumptions skill applies an Impact × Risk matrix to transform subjective worries into ranked priorities.
• Generate immediate action items: The workflow outputs concrete experiments for high-risk assumptions, creating ready-to-execute validation tickets.
• Prevent costly rework: By identifying and prioritizing risky assumptions before code is written, teams avoid building features on unstable foundations.

Frequently Asked Questions

What is the difference between the existing and new product assumption skills?

The identify-assumptions-existing skill focuses on four core risks (Value, Usability, Viability, Feasibility) relevant to feature additions in mature products. The identify-assumptions-new skill expands this to eight categories including Ethics, Go-to-Market, Strategy & Objectives, and Team to address the broader uncertainty of new product launches. Both use the same three-perspective analytical framework but differ in scope as defined in their respective SKILL.md files.

How does the Impact × Risk matrix calculate priority scores?

According to pm-product-discovery/skills/prioritize-assumptions/SKILL.md, the matrix multiplies an Impact score (how much the assumption affects success) by a Risk score (the inverse of confidence). An assumption with Impact 5 and Risk 4 receives a priority score of 20. The skill sorts all assumptions by this score in descending order, ensuring the highest-risk, highest-impact items appear at the top of your validation backlog.

Can these skills be used outside of the /discover command?

Yes. While the skills are designed to chain together within the /discover command workflow, you can invoke identify-assumptions-existing, identify-assumptions-new, or prioritize-assumptions individually if you have access to the pm-skills runtime. Each skill accepts standard inputs (product descriptions in markdown format) and returns structured markdown tables that integrate with external documentation tools.

What makes an assumption "risky" in this framework?

An assumption is considered risky when it combines high uncertainty (low confidence) with high impact. The framework captures this through explicit confidence ratings (High/Medium/Low) assigned during the identification phase. Assumptions that prove false would invalidate the product concept or require significant pivots. The prioritization step specifically targets these high-impact, high-uncertainty assumptions for immediate validation.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}