
Identify Assumptions
- 94 installs
- 451 repo stars
- Updated July 21, 2026
- borghei/claude-skills
Identify Assumptions is a Claude skill that surfaces, categorizes, and prioritizes product assumptions across 4-8 risk categories using devil's-advocate analysis.
About
Identify Assumptions is a Claude skill that surfaces, categorizes, and prioritizes the assumptions behind product decisions. It extends Teresa Torres' four risk categories with four more for new products and uses a devil's-advocate approach from PM, Designer, and Engineer perspectives, then ranks assumptions on an impact-times-risk matrix. A product team uses it after ideation and before committing to build.
- Extends Teresa Torres' 4 risk categories to 8 for new products
- Devil's-advocate surfacing from PM, Designer, and Engineer views
- Impact-times-risk matrix prioritizes which assumptions to test first
Identify Assumptions by the numbers
- 94 all-time installs (skills.sh)
- Ranked #1,389 of 3,282 Productivity & Planning skills by installs in the Skillselion catalog
- Data as of Aug 5, 2026 (Skillselion catalog sync)
identify-assumptions capabilities & compatibility
Free; optional local Python script, no API keys.
- Capabilities
- identify assumptions · executive mentor
- Use cases
- planning · research · project management
- Pricing
- Free
What identify-assumptions says it does
Assumption mapping expert that identifies, categorizes, and prioritizes product assumptions across 4-8 risk categories using devil's advocate analysis.
This skill extends Teresa Torres' four risk categories with four additional categories for new products
Risk Score = Impact x (1 - Confidence)
npx skills add https://github.com/borghei/claude-skills --skill identify-assumptionsAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 94 |
|---|---|
| repo stars | ★ 451 |
| Last updated | July 21, 2026 |
| Repository | borghei/claude-skills ↗ |
What it does
Surface and prioritize the riskiest product assumptions to test before committing to build.
Who is it for?
Product teams surfacing and ranking the riskiest assumptions after ideation and before committing to build.
Skip if: Writing code or running the validation experiments themselves.
When should I use this skill?
After ideation and before build, when a decision feels right but is unvalidated, or when the team disagrees on risk.
What you get
A categorized, impact-times-risk-ranked list of assumptions with the riskiest queued for testing first.
- Categorized assumption list with impact and confidence
- Impact-times-risk prioritization and suggested tests
By the numbers
- 4-8 risk categories
- 3 devil's-advocate perspectives (PM, Designer, Engineer)
- 5-phase methodology
Files
Assumption Mapping Expert
Overview
Systematically identify, categorize, and prioritize the assumptions underlying your product decisions. This skill extends Teresa Torres' four risk categories with four additional categories for new products, and uses a devil's advocate approach from PM, Designer, and Engineer perspectives to surface hidden assumptions.
When to Use
- After ideation, before committing to build.
- When a product decision "feels right" but has not been validated.
- When the team disagrees on risk or priority -- assumptions make disagreements explicit.
- Before designing experiments -- test the riskiest assumptions first.
Risk Categories
Core 4 Categories (Existing Products)
These four categories come from Teresa Torres' Continuous Discovery Habits and cover the primary risks for features within an established product:
| Category | Question It Answers | Example Assumption |
|---|---|---|
| Value | Will customers want this? | "Users will prefer AI-generated summaries over manual note-taking." |
| Usability | Can customers figure out how to use it? | "Users will understand the drag-and-drop interface without a tutorial." |
| Viability | Can the business sustain this? | "The feature will generate enough upgrades to justify the engineering cost." |
| Feasibility | Can we build this? | "Our current infrastructure can handle real-time processing at scale." |
Extended 8 Categories (New Products)
For new products, four additional risk categories become critical:
| Category | Question It Answers | Example Assumption |
|---|---|---|
| Ethics | Should we build this? Are there unintended harms? | "Collecting location data will not create privacy concerns for our target segment." |
| Go-to-Market | Can we reach and acquire customers? | "Our target segment actively searches for solutions on Google, making SEO viable." |
| Strategy & Objectives | Does this align with where we want to go? | "Entering the SMB market will not dilute our enterprise positioning." |
| Team | Do we have the right people and skills? | "Our team can learn the required ML skills within the project timeline." |
Methodology
Phase 1: Devil's Advocate Assumption Surfacing
For each product idea or decision, adopt three adversarial perspectives:
PM Devil's Advocate "I challenge whether this is worth building."
- Is there real demand, or are we projecting our own preferences?
- Will this move the metric we care about?
- Can we sustain this economically?
- Does this align with strategy, or is it a distraction?
Designer Devil's Advocate "I challenge whether users will actually use this."
- Will users discover this feature?
- Can they complete the task without help?
- Does this add complexity that hurts the overall experience?
- Are we designing for edge cases and assuming they are common?
Engineer Devil's Advocate "I challenge whether we can build and maintain this."
- Do we have the technical skills and infrastructure?
- What are the hidden dependencies and integration risks?
- Can this scale if it succeeds?
- What is the ongoing maintenance burden?
Phase 2: Categorize Each Assumption
For each assumption surfaced, assign:
| Field | Options |
|---|---|
| Description | Clear, specific statement of what must be true |
| Risk Category | Value / Usability / Viability / Feasibility / Ethics / Go-to-Market / Strategy / Team |
| Confidence | High (we have strong evidence) / Medium (some evidence, not conclusive) / Low (gut feeling or no evidence) |
| Impact | 1-10 scale (if this assumption is wrong, how bad is it?) |
Phase 3: Prioritize Using Impact x Risk Matrix
Calculate a risk score for each assumption:
Risk Score = Impact x (1 - Confidence)Where confidence maps to: High = 0.8, Medium = 0.5, Low = 0.2
| Impact | Confidence | Risk Score | Meaning |
|---|---|---|---|
| 9 | Low (0.2) | 7.2 | Critical -- test immediately |
| 9 | High (0.8) | 1.8 | Important but well-understood |
| 3 | Low (0.2) | 2.4 | Low priority |
| 3 | High (0.8) | 0.6 | Ignore |
Phase 4: Classify into Quadrants
Place each assumption on a 2x2 matrix:
HIGH IMPACT
|
Proceed with | Test Now
Confidence | (highest priority)
|
──────────────────────┼──────────────────────
|
Defer | Investigate
(low priority) | (may be important)
|
LOW IMPACT
LOW RISK ◄─────┼─────► HIGH RISK| Quadrant | Impact | Risk | Action |
|---|---|---|---|
| Test Now | High | High | Design an experiment immediately |
| Proceed | High | Low | Move forward with monitoring |
| Investigate | Low | High | Gather more data, may upgrade to Test Now |
| Defer | Low | Low | Accept the risk, revisit if context changes |
Phase 5: Suggest Tests
For each "Test Now" assumption, recommend a validation approach:
| Assumption Type | Suggested Test Methods |
|---|---|
| Value assumptions | Customer interviews, fake door test, landing page test |
| Usability assumptions | Usability test (5 users), prototype walkthrough |
| Viability assumptions | Financial modeling, pricing experiment, unit economics analysis |
| Feasibility assumptions | Technical spike, proof of concept, architecture review |
| Ethics assumptions | Ethics review board, user consent study, regulatory consultation |
| Go-to-Market assumptions | Channel experiment, SEO keyword test, paid ad test |
| Strategy assumptions | Strategy review with leadership, competitive analysis |
| Team assumptions | Skills assessment, hiring timeline analysis, training feasibility |
Python Tool: assumption_tracker.py
Track and prioritize assumptions using the CLI tool:
# Run with demo data
python3 scripts/assumption_tracker.py --demo
# Run with custom input
python3 scripts/assumption_tracker.py input.json
# Output as JSON
python3 scripts/assumption_tracker.py input.json --format jsonInput Format
{
"assumptions": [
{
"description": "Users will prefer AI summaries over manual notes",
"category": "value",
"confidence": "low",
"impact": 9
}
]
}Output
Sorted by risk priority with quadrant classification and suggested actions.
See scripts/assumption_tracker.py for full documentation.
Output Format
Assumption Registry
| # | Assumption | Category | Confidence | Impact | Risk Score | Quadrant |
|---|---|---|---|---|---|---|
| 1 | ... | Value | Low | 9 | 7.2 | Test Now |
| 2 | ... | Feasibility | Medium | 8 | 4.0 | Test Now |
| 3 | ... | Usability | High | 7 | 1.4 | Proceed |
| 4 | ... | GTM | Low | 3 | 2.4 | Investigate |
Action Plan for "Test Now" Assumptions
For each assumption in the Test Now quadrant, document:
- Assumption description
- Why it is high risk
- Suggested validation method
- Owner and timeline
Use assets/assumption_map_template.md for the full template.
Integration with Other Discovery Skills
- Use
brainstorm-ideas/to generate ideas whose assumptions you will map. - Feed "Test Now" assumptions into
brainstorm-experiments/for experiment design. - Run
pre-mortem/to catch risks that assumption mapping might miss (especially elephants).
Troubleshooting
| Symptom | Likely Cause | Resolution |
|---|---|---|
| All assumptions classified as "Test Now" | Impact scores inflated or confidence levels consistently set to "low" | Calibrate impact scoring with team; use relative ranking (force distribution across quadrants) |
| Validation fails with category error | Category string does not match valid set exactly | Use lowercase: value, usability, viability, feasibility, ethics, gtm, strategy, team |
| Risk scores cluster around the same value | Impact and confidence values lack variance across assumptions | Use the full 1-10 impact scale; challenge the team to differentiate high vs. medium vs. low confidence with evidence |
| Team generates fewer than 10 assumptions | Devil's Advocate perspectives not applied systematically | Run all three perspectives (PM, Designer, Engineer) independently before combining; use the prompts in Phase 1 |
| "Defer" quadrant is empty | All assumptions scored as high impact, or low-impact assumptions not captured | Include operational and edge-case assumptions; not every assumption is existential |
| Suggested tests are too generic | Tool uses category-level test suggestions, not assumption-specific ones | Use the category suggestion as a starting point; tailor the test method using brainstorm-experiments/ skill |
| Assumptions not updated after experiments | No feedback loop from experiment results back to assumption tracker | Re-run assumption_tracker.py with updated confidence levels after each experiment completes |
Success Criteria
- All product decisions have at least 8-15 explicit assumptions documented before build commitment
- Every "Test Now" assumption has an assigned owner, validation method, and timeline
- Risk scores are calculated consistently using the Impact x (1 - Confidence) formula
- Assumptions are re-scored after each validation experiment (confidence levels update)
- At least 80% of "Test Now" assumptions are validated or invalidated before major build decisions
- Assumption map is reviewed and updated at every product discovery cycle (weekly or bi-weekly)
- The team can articulate the top 3 riskiest assumptions for any active initiative
Scope & Limitations
In Scope:
- Systematic assumption identification using PM/Designer/Engineer devil's advocate perspectives
- 8-category risk classification (Value, Usability, Viability, Feasibility, Ethics, Go-to-Market, Strategy, Team)
- Quantitative risk scoring using Impact x (1 - Confidence) formula
- Quadrant classification (Test Now, Proceed, Investigate, Defer) with suggested validation methods
- Assumption registry with priority sorting and action plan generation
Out of Scope:
- Running validation experiments (see
brainstorm-experiments/skill) - Product strategy or roadmap decisions (see
execution/outcome-roadmap/) - Technical feasibility deep-dives or architecture reviews (see
engineering/skills) - Financial modeling for viability assumptions (see
finance/domain skills)
Important Caveats:
- Confidence levels (high/medium/low) map to fixed numeric values (0.8/0.5/0.2). This is a simplification; real confidence is continuous.
- The quadrant threshold for "high impact" is set at 7/10. Adjust this threshold for your risk tolerance.
- Assumption mapping is most effective when done collaboratively (Product Trio), not by a single person.
Integration Points
| Integration | Direction | Description |
|---|---|---|
brainstorm-ideas/ | Receives from | Ideas generated become the subjects whose assumptions are mapped |
brainstorm-experiments/ | Feeds into | "Test Now" assumptions become hypotheses for experiment design |
pre-mortem/ | Complements | Pre-mortem catches risks that assumption mapping may miss (especially elephants) |
execution/create-prd/ | Feeds into | Validated assumptions populate the PRD Assumptions section (Section 7) |
execution/brainstorm-okrs/ | Feeds into | Viability assumptions inform OKR key result selection and confidence levels |
senior-pm/ | Feeds into | High-impact assumptions feed into portfolio risk registers |
Tool Reference
assumption_tracker.py
Tracks, scores, and prioritizes product assumptions using an Impact x Risk matrix with quadrant classification.
| Flag | Type | Default | Description |
|---|---|---|---|
input_file | positional | (optional) | Path to JSON file with assumptions array |
--demo | flag | off | Run with built-in sample data (8 assumptions across all categories) |
--format | choice | text | Output format: text or json |
Input fields per assumption:
description(required): Clear statement of what must be truecategory(required): One ofvalue,usability,viability,feasibility,ethics,gtm,strategy,teamconfidence(required): One ofhigh,medium,lowimpact(required): Integer 1-10
References
- Teresa Torres, Continuous Discovery Habits (2021)
- David J. Bland & Alexander Osterwalder, Testing Business Ideas (2019)
- Ash Maurya, Running Lean (2012)
- Marty Cagan, Inspired (2018)
Assumption Map Template
Context
| Field | Value |
|---|---|
| Product / Feature | |
| Date | YYYY-MM-DD |
| Facilitator | |
| Participants | PM: / Designer: / Engineer: |
| Product Type | New Product / Existing Product |
| Categories Used | 4 (existing) / 8 (new product) |
---
Assumption Registry
| # | Assumption | Category | Confidence | Impact (1-10) | Risk Score | Quadrant |
|---|---|---|---|---|---|---|
| 1 | Value | Low / Med / High | ||||
| 2 | Usability | Low / Med / High | ||||
| 3 | Viability | Low / Med / High | ||||
| 4 | Feasibility | Low / Med / High | ||||
| 5 | Ethics | Low / Med / High | ||||
| 6 | Go-to-Market | Low / Med / High | ||||
| 7 | Strategy | Low / Med / High | ||||
| 8 | Team | Low / Med / High |
Risk Score Formula: Impact x (1 - Confidence), where High=0.8, Medium=0.5, Low=0.2
Quadrant Assignment:
- Test Now: Impact >= 7 AND Confidence = Low or Medium
- Proceed: Impact >= 7 AND Confidence = High
- Investigate: Impact < 7 AND Confidence = Low
- Defer: Impact < 7 AND Confidence = Medium or High
---
Risk Category Quick Reference
Core 4 (All Products)
| Category | Key Question | Devil's Advocate Prompt |
|---|---|---|
| Value | Will customers want this? | "What if nobody actually has this problem?" |
| Usability | Can they figure it out? | "What if users cannot complete the task without help?" |
| Viability | Does the business case work? | "What if this costs more to maintain than it generates?" |
| Feasibility | Can we build it? | "What if the technical complexity is 3x our estimate?" |
Extended 4 (New Products Only)
| Category | Key Question | Devil's Advocate Prompt |
|---|---|---|
| Ethics | Should we build this? | "What if this harms users we did not consider?" |
| Go-to-Market | Can we reach customers? | "What if our target segment is unreachable at viable CAC?" |
| Strategy | Does this align with our direction? | "What if leadership changes priorities next quarter?" |
| Team | Do we have the right people? | "What if the key skill gap takes 6 months to fill?" |
---
Prioritization Matrix (Impact vs. Risk)
10 ┌─────────────────┬─────────────────┐
│ │ │
│ PROCEED │ TEST NOW │
I │ (move forward │ (experiment │
M │ with tripwire)│ immediately) │
P 7 ├─────────────────┼─────────────────┤
A │ │ │
C │ DEFER │ INVESTIGATE │
T │ (accept risk) │ (gather data) │
│ │ │
1 └─────────────────┴─────────────────┘
HIGH confidence LOW confidence
(low risk) (high risk)Place each assumption's number on the matrix above.
---
Action Plan: Test Now Assumptions
| # | Assumption | Why High Risk | Validation Method | Owner | Timeline | Status |
|---|---|---|---|---|---|---|
| Not Started | ||||||
| Not Started | ||||||
| Not Started |
---
Tripwires: Proceed Assumptions
| # | Assumption | Monitoring Metric | Tripwire Threshold | Review Date |
|---|---|---|---|---|
---
Notes
Capture reasoning, debates, and additional context from the mapping session.
Assumption Mapping Guide
Teresa Torres' Four Risk Categories
Teresa Torres identifies four types of risk that every product decision carries. These categories originate from her book Continuous Discovery Habits and are the standard framework for assumption mapping in continuous product discovery.
Value Risk
Question: Will customers want this? Will they choose it over alternatives?
What to look for:
- Assumptions about the severity or frequency of the problem.
- Assumptions about how customers currently solve the problem.
- Assumptions about willingness to switch from the current solution.
- Assumptions about perceived value relative to price.
Red flags:
- "Everyone has this problem" -- usually not true. Define the specific segment.
- "Users told us they want this" -- stated preference does not equal revealed preference.
- "No one else is doing this" -- could mean no demand, not just no competition.
Usability Risk
Question: Can customers figure out how to use this? Will they complete the task successfully?
What to look for:
- Assumptions about user mental models and expectations.
- Assumptions about discoverability of features.
- Assumptions about required knowledge or skill level.
- Assumptions about error recovery and edge cases.
Red flags:
- "It is intuitive" -- intuitive to the team that built it, maybe not to users.
- "We will add a tutorial" -- tutorials are a band-aid for poor usability.
- "Power users will figure it out" -- even power users have limited patience.
Viability Risk
Question: Can the business sustain this? Does the economics work?
What to look for:
- Assumptions about revenue impact or cost savings.
- Assumptions about customer acquisition cost and lifetime value.
- Assumptions about operational cost of maintaining the feature.
- Assumptions about regulatory or legal compliance.
Red flags:
- "We will monetize later" -- without a path, later often means never.
- "The marginal cost is zero" -- infrastructure, support, and maintenance are rarely zero.
- "Legal will be fine with it" -- check early, not after building.
Feasibility Risk
Question: Can we build this with our current team, technology, and timeline?
What to look for:
- Assumptions about technical complexity and unknowns.
- Assumptions about third-party dependencies (APIs, vendors, partners).
- Assumptions about data availability and quality.
- Assumptions about performance, scalability, and reliability requirements.
Red flags:
- "It is just a simple API call" -- integration is rarely simple.
- "We have done something similar before" -- similar is not identical.
- "It will take two weeks" -- engineer estimates are systematically optimistic.
---
Extended 8-Category Model for New Products
When building something entirely new, four additional risk categories become relevant. These are often overlooked because they fall outside the traditional product development frame.
Ethics Risk
Question: Should we build this? Could it cause harm?
Assumptions to surface:
- Data collection will not violate user privacy expectations.
- The product will not create negative externalities for non-users.
- Algorithmic decisions will not exhibit bias against protected groups.
- Users will give informed consent for how their data is used.
- The product will not enable harmful use cases.
When to prioritize: Any product involving personal data, AI/ML, health, finance, or vulnerable populations.
Go-to-Market Risk
Question: Can we reach and acquire our target customers?
Assumptions to surface:
- The target segment is reachable through specific channels.
- Customer acquisition cost will be below lifetime value.
- The value proposition can be communicated in a headline.
- Word-of-mouth or viral mechanics will contribute to growth.
- Sales cycle length is within our runway tolerance.
When to prioritize: Any new product without an existing distribution channel or customer base.
Strategy and Objectives Risk
Question: Does this align with where the company wants to go?
Assumptions to surface:
- This product/feature advances a current company objective.
- Leadership will continue to fund this initiative through completion.
- This does not cannibalize or conflict with other products.
- The competitive landscape will remain favorable.
- Market timing is right (not too early, not too late).
When to prioritize: New products, pivots, or features that represent a strategic bet.
Team Risk
Question: Do we have the right people and skills to execute?
Assumptions to surface:
- The team has the technical skills required.
- Key personnel will remain available throughout the project.
- Cross-functional collaboration will be effective.
- The team can learn new skills within the project timeline.
- We can hire for skill gaps quickly enough.
When to prioritize: Projects requiring new technologies, new domains, or stretched teams.
---
Confidence Calibration Techniques
Confidence levels are subjective. Use these techniques to improve calibration:
Evidence-Based Confidence
| Confidence Level | Evidence Required |
|---|---|
| High | Direct quantitative data (analytics, A/B test results, sales data) from your own product/market |
| Medium | Qualitative evidence (5+ user interviews), analogous data from similar products, or industry benchmarks |
| Low | Team intuition, anecdotal evidence, or no evidence at all |
The Five Whys Test
For any assumption rated "High confidence," ask "Why do we believe this?" five times. If you cannot trace the confidence back to concrete evidence by the third "why," downgrade to Medium.
Pre-Mortem Check
Imagine the assumption turned out to be wrong. How surprised would you be?
- "I would be shocked" = High confidence (but verify you have evidence, not just conviction)
- "I would be disappointed but not shocked" = Medium confidence
- "I honestly do not know" = Low confidence
Calibration Exercise
Before mapping assumptions, run a quick calibration: have each team member independently rate confidence for 3-4 well-known assumptions (e.g., "Our homepage conversion rate is above 3%"). Compare ratings. If the team diverges significantly, discuss what evidence each person is using. This aligns the team's confidence scale before the real exercise.
---
Assumption Prioritization Matrix
The 2x2 Matrix
HIGH IMPACT
|
PROCEED | TEST NOW
(high confidence, | (low confidence,
high impact) | high impact)
|
──────────────────────┼──────────────────────
|
DEFER | INVESTIGATE
(high confidence, | (low confidence,
low impact) | low impact)
|
LOW IMPACT
HIGH CONFIDENCE ◄──┼──► LOW CONFIDENCEDecision Rules
| Quadrant | Action | Timeline |
|---|---|---|
| Test Now | Design and run an experiment within the current sprint/cycle | This week |
| Proceed | Move forward but set a monitoring tripwire | Ongoing |
| Investigate | Gather more information; may promote to Test Now | Next cycle |
| Defer | Accept the risk; revisit only if context changes | Backlog |
Tripwires for "Proceed" Assumptions
Even high-confidence assumptions can be wrong. Set tripwires:
- "If churn exceeds 8% in the first month, revisit the value assumption."
- "If support tickets about this feature exceed 20/week, revisit the usability assumption."
---
Connection to Experiment Design
Assumption mapping feeds directly into experiment design:
1. Identify assumptions (this skill). 2. Prioritize to find "Test Now" assumptions. 3. Design experiments (use brainstorm-experiments/ skill) targeting the riskiest assumptions. 4. Run experiments and update confidence levels based on results. 5. Re-prioritize -- the map is a living document.
Mapping Assumptions to Experiment Types
| Assumption Category | Best Experiment Types |
|---|---|
| Value | Customer interviews, fake door tests, landing pages, pre-orders |
| Usability | Usability testing (5 users), prototype walkthroughs, first-click tests |
| Viability | Pricing experiments, unit economics modeling, willingness-to-pay surveys |
| Feasibility | Technical spikes, proof of concept, architecture reviews |
| Ethics | Ethics review, user consent studies, bias audits |
| Go-to-Market | Channel experiments, SEO keyword tests, paid ad campaigns |
| Strategy | Leadership alignment sessions, competitive analysis |
| Team | Skills assessments, trial projects, pair programming sessions |
#!/usr/bin/env python3
"""
Assumption Tracker CLI Tool
Tracks, scores, and prioritizes product assumptions using an Impact x Risk
matrix. Classifies assumptions into quadrants: Test Now, Proceed, Investigate,
or Defer.
Usage:
python3 assumption_tracker.py input.json [--format json|text]
python3 assumption_tracker.py --demo [--format json|text]
Input JSON format:
{
"assumptions": [
{
"description": "Users will prefer AI summaries over manual notes",
"category": "value",
"confidence": "low",
"impact": 9
}
]
}
Categories: value, usability, viability, feasibility, ethics, gtm, strategy, team
Confidence: high, medium, low
Impact: 1-10
Requires: Python 3.7+ (standard library only)
"""
import argparse
import json
import sys
from typing import Any
VALID_CATEGORIES = {
"value", "usability", "viability", "feasibility",
"ethics", "gtm", "strategy", "team",
}
VALID_CONFIDENCE = {"high", "medium", "low"}
CONFIDENCE_NUMERIC = {
"high": 0.8,
"medium": 0.5,
"low": 0.2,
}
CATEGORY_LABELS = {
"value": "Value",
"usability": "Usability",
"viability": "Viability",
"feasibility": "Feasibility",
"ethics": "Ethics",
"gtm": "Go-to-Market",
"strategy": "Strategy & Objectives",
"team": "Team",
}
SUGGESTED_TESTS = {
"value": "Customer interviews, fake door test, landing page test, pre-order experiment",
"usability": "Usability test (5 users), prototype walkthrough, first-click test",
"viability": "Financial modeling, pricing experiment, unit economics analysis",
"feasibility": "Technical spike, proof of concept, architecture review",
"ethics": "Ethics review board, user consent study, regulatory consultation",
"gtm": "Channel experiment, SEO keyword test, paid ad test",
"strategy": "Strategy review with leadership, competitive analysis",
"team": "Skills assessment, hiring timeline analysis, training feasibility study",
}
def calculate_risk_score(impact: int, confidence: str) -> float:
"""Calculate risk score = impact * (1 - confidence_numeric)."""
conf_value = CONFIDENCE_NUMERIC.get(confidence.lower(), 0.5)
return round(impact * (1.0 - conf_value), 2)
def classify_quadrant(impact: int, confidence: str) -> str:
"""Classify assumption into a prioritization quadrant."""
high_impact = impact >= 7
low_confidence = confidence.lower() in ("low", "medium")
if high_impact and low_confidence:
return "Test Now"
elif high_impact and not low_confidence:
return "Proceed"
elif not high_impact and confidence.lower() == "low":
return "Investigate"
else:
return "Defer"
def validate_assumption(assumption: dict[str, Any], index: int) -> list[str]:
"""Validate a single assumption entry. Returns list of error messages."""
errors = []
if not assumption.get("description"):
errors.append(f"Assumption {index}: missing 'description'")
category = assumption.get("category", "").lower()
if category not in VALID_CATEGORIES:
errors.append(
f"Assumption {index}: invalid category '{category}'. "
f"Valid: {', '.join(sorted(VALID_CATEGORIES))}"
)
confidence = assumption.get("confidence", "").lower()
if confidence not in VALID_CONFIDENCE:
errors.append(
f"Assumption {index}: invalid confidence '{confidence}'. "
f"Valid: {', '.join(sorted(VALID_CONFIDENCE))}"
)
impact = assumption.get("impact")
if not isinstance(impact, (int, float)) or impact < 1 or impact > 10:
errors.append(f"Assumption {index}: 'impact' must be a number 1-10")
return errors
def process_assumptions(assumptions: list[dict[str, Any]]) -> dict[str, Any]:
"""Process all assumptions and return analysis results."""
processed = []
for assumption in assumptions:
category = assumption["category"].lower()
confidence = assumption["confidence"].lower()
impact = int(assumption["impact"])
risk_score = calculate_risk_score(impact, confidence)
quadrant = classify_quadrant(impact, confidence)
processed.append({
"description": assumption["description"],
"category": category,
"category_label": CATEGORY_LABELS.get(category, category),
"confidence": confidence,
"impact": impact,
"risk_score": risk_score,
"quadrant": quadrant,
"suggested_test": SUGGESTED_TESTS.get(category, "Further investigation needed"),
})
# Sort by risk score descending
processed.sort(key=lambda x: -x["risk_score"])
# Summary
quadrant_counts = {"Test Now": 0, "Proceed": 0, "Investigate": 0, "Defer": 0}
category_counts: dict[str, int] = {}
for item in processed:
quadrant_counts[item["quadrant"]] += 1
cat = item["category_label"]
category_counts[cat] = category_counts.get(cat, 0) + 1
return {
"total": len(processed),
"summary": {
"by_quadrant": quadrant_counts,
"by_category": category_counts,
},
"assumptions": processed,
}
def format_text(results: dict[str, Any]) -> str:
"""Format results as human-readable text."""
lines = []
lines.append("=" * 70)
lines.append("ASSUMPTION TRACKER - PRIORITIZED ANALYSIS")
lines.append("=" * 70)
# Summary
lines.append("")
lines.append(f"Total assumptions: {results['total']}")
lines.append("")
lines.append("By Quadrant:")
for quadrant, count in results["summary"]["by_quadrant"].items():
marker = " <<<" if quadrant == "Test Now" and count > 0 else ""
lines.append(f" {quadrant:15s} {count}{marker}")
lines.append("")
lines.append("By Category:")
for category, count in sorted(results["summary"]["by_category"].items()):
lines.append(f" {category:25s} {count}")
# Detailed list sorted by risk score
lines.append("")
lines.append("-" * 70)
lines.append("ASSUMPTIONS (sorted by risk score, highest first)")
lines.append("-" * 70)
for i, a in enumerate(results["assumptions"], 1):
lines.append("")
lines.append(f" #{i} [{a['quadrant'].upper()}]")
lines.append(f" Description: {a['description']}")
lines.append(f" Category: {a['category_label']}")
lines.append(f" Confidence: {a['confidence'].capitalize()}")
lines.append(f" Impact: {a['impact']}/10")
lines.append(f" Risk Score: {a['risk_score']}")
lines.append(f" Suggested Test: {a['suggested_test']}")
# Action plan for Test Now
test_now = [a for a in results["assumptions"] if a["quadrant"] == "Test Now"]
if test_now:
lines.append("")
lines.append("=" * 70)
lines.append("ACTION PLAN: TEST NOW (highest priority)")
lines.append("=" * 70)
for i, a in enumerate(test_now, 1):
lines.append(f"")
lines.append(f" {i}. {a['description']}")
lines.append(f" Category: {a['category_label']} | Risk Score: {a['risk_score']}")
lines.append(f" Test with: {a['suggested_test']}")
lines.append("")
lines.append("=" * 70)
return "\n".join(lines)
def get_demo_data() -> dict[str, Any]:
"""Return sample input data for demonstration."""
return {
"assumptions": [
{
"description": "Users will prefer AI-generated summaries over manual note-taking",
"category": "value",
"confidence": "low",
"impact": 9,
},
{
"description": "Our infrastructure can handle real-time processing for 10K concurrent users",
"category": "feasibility",
"confidence": "medium",
"impact": 8,
},
{
"description": "Users will understand the drag-and-drop interface without a tutorial",
"category": "usability",
"confidence": "high",
"impact": 7,
},
{
"description": "The feature will generate enough upgrades to justify the 3-month engineering cost",
"category": "viability",
"confidence": "low",
"impact": 8,
},
{
"description": "Collecting usage data will not create GDPR compliance issues",
"category": "ethics",
"confidence": "medium",
"impact": 9,
},
{
"description": "Our target segment actively searches for solutions on Google",
"category": "gtm",
"confidence": "low",
"impact": 6,
},
{
"description": "This feature aligns with the company's Q3 objectives",
"category": "strategy",
"confidence": "high",
"impact": 5,
},
{
"description": "The team can learn the required ML skills within the project timeline",
"category": "team",
"confidence": "low",
"impact": 7,
},
]
}
def main():
parser = argparse.ArgumentParser(
description="Assumption Tracker: score and prioritize product assumptions.",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
python3 assumption_tracker.py --demo
python3 assumption_tracker.py --demo --format json
python3 assumption_tracker.py assumptions.json
python3 assumption_tracker.py assumptions.json --format json
Categories: value, usability, viability, feasibility, ethics, gtm, strategy, team
Confidence: high, medium, low
Impact: 1-10
""",
)
parser.add_argument(
"input_file",
nargs="?",
help="Path to JSON file with assumptions (omit if using --demo)",
)
parser.add_argument(
"--demo",
action="store_true",
help="Run with built-in sample data",
)
parser.add_argument(
"--format",
choices=["json", "text"],
default="text",
help="Output format (default: text)",
)
args = parser.parse_args()
if args.demo:
data = get_demo_data()
elif args.input_file:
try:
with open(args.input_file, "r") as f:
data = json.load(f)
except FileNotFoundError:
print(f"Error: File not found: {args.input_file}", file=sys.stderr)
sys.exit(1)
except json.JSONDecodeError as e:
print(f"Error: Invalid JSON in {args.input_file}: {e}", file=sys.stderr)
sys.exit(1)
else:
parser.print_help()
sys.exit(1)
assumptions = data.get("assumptions", [])
if not assumptions:
print("Error: No assumptions found in input data.", file=sys.stderr)
sys.exit(1)
# Validate
all_errors = []
for i, assumption in enumerate(assumptions, 1):
errors = validate_assumption(assumption, i)
all_errors.extend(errors)
if all_errors:
print("Validation errors:", file=sys.stderr)
for error in all_errors:
print(f" - {error}", file=sys.stderr)
sys.exit(1)
results = process_assumptions(assumptions)
if args.format == "json":
print(json.dumps(results, indent=2))
else:
print(format_text(results))
if __name__ == "__main__":
main()
Related skills
FAQ
What risk categories does it use?
Teresa Torres' Value, Usability, Viability, and Feasibility, plus Ethics, Go-to-Market, Strategy, and Team for new products.
How are assumptions prioritized?
By a risk score of Impact times (1 minus Confidence), then placed on a 2x2 impact-versus-risk matrix to decide Test Now, Proceed, Investigate, or Defer.