Agent skill

assumption-mapping

Surface, prioritize, and track risky assumptions before investing significant effort. Use when starting a new project, before major feature work, when feeling uncertain about direction, when the user says "I think users want...", "we assume...", "probably...", or before any build decision that hasn't been validated with real users.

Stars 4
Forks 1

Install this agent skill to your Project

npx add-skill https://github.com/Abhsin/DesignSkills/tree/main/Skill/assumption-mapping

SKILL.md

Assumption Mapping

Surface hidden assumptions and prioritize which ones to validate before building.

When to Trigger

  • User is starting something new
  • User expresses uncertainty ("I think...", "probably...", "should work...")
  • User is about to invest significant effort
  • User mentions building without mentioning validation
  • User asks "what should I test first?"

Quick Start

Ask the user:

  1. "What are you building and for whom?"
  2. "What needs to be true for this to succeed?"

Then run the assumption extraction workflow below.

Core Workflow

Assumption Mapping Progress:
- [ ] Step 1: Extract assumptions from conversation
- [ ] Step 2: Categorize by type
- [ ] Step 3: Score risk and uncertainty
- [ ] Step 4: Prioritize for validation
- [ ] Step 5: Suggest validation methods

Step 1: Extract Assumptions

Listen for assumption signals in what the user says:

Signal phrase Hidden assumption
"Users want..." Desirability assumption
"We can build..." Feasibility assumption
"People will pay..." Viability assumption
"It's easy to..." Complexity assumption
"Everyone knows..." Knowledge assumption
"They'll figure out..." Usability assumption

Extract 5-10 assumptions. Frame each as a testable statement:

Bad: "Users like simple things" Good: "Users will complete onboarding in under 2 minutes without help"

Step 2: Categorize Assumptions

Assign each assumption to one category:

Category Question it answers
Desirability Do people want this?
Feasibility Can we build this?
Viability Can this sustain itself?
Usability Can people use this?
Ethical Should we build this?

Step 3: Score Each Assumption

Rate each assumption on two dimensions (1-5 scale):

Impact: If wrong, how badly does it hurt the project?

  • 1 = Minor inconvenience
  • 5 = Project fails completely

Uncertainty: How confident are we this is true?

  • 1 = We have strong evidence
  • 5 = Pure guess

Step 4: Prioritize

Create a 2x2 priority matrix:

                    HIGH IMPACT
                         │
     ┌───────────────────┼───────────────────┐
     │                   │                   │
     │   VALIDATE LATER  │  VALIDATE FIRST   │
     │   (Low risk)      │  (Critical)       │
     │                   │                   │
LOW  ├───────────────────┼───────────────────┤ HIGH
UNCERTAINTY              │              UNCERTAINTY
     │                   │                   │
     │   SKIP            │  MONITOR          │
     │   (Safe)          │  (Watch for       │
     │                   │   signals)        │
     │                   │                   │
     └───────────────────┼───────────────────┘
                         │
                    LOW IMPACT

Top-right quadrant = validate before building

Step 5: Suggest Validation Methods

For each critical assumption, suggest a lightweight validation:

Assumption type Fast validation (hours) Deeper validation (days)
Desirability 5 user interviews Landing page test
Feasibility Technical spike Prototype
Viability Competitor pricing research Willingness-to-pay interviews
Usability 3-person hallway test Usability study

See references/validation-methods.md for detailed methods.

Output Template

Automatically save the output to design/03-assumption-mapping.md using the Write tool while presenting findings in this format:

markdown
## Assumption Map for [Project Name]

### Critical Assumptions (Validate First)
| # | Assumption | Type | Impact | Uncertainty | Suggested Test |
|---|------------|------|--------|-------------|----------------|
| 1 | [statement] | [type] | [1-5] | [1-5] | [method] |

### Secondary Assumptions (Validate Later)
[Same table format]

### Safe Assumptions (Monitor)
[Bulleted list]

### Recommended Next Steps
1. [First validation to run]
2. [Second validation to run]

Adaptive Behavior

If user is new to assumption mapping:

  • Explain briefly why we do this (1 sentence)
  • Guide them through extraction with examples
  • Keep the output simple

If user is familiar:

  • Skip explanations
  • Jump to extraction
  • Offer the full matrix output

Gauge familiarity by asking: "Have you mapped assumptions before, or should I walk you through it?"

Handoff

Suggest next steps:

"Use this map to prioritize validation tests before full development. Want to proceed with /solution-scoping or test critical assumptions first?"

Note: File is automatically saved to design/03-assumption-mapping.md for context preservation.

Integration Points

This skill works well before:

  • problem-framing — if problem isn't clear yet
  • validation — to test the critical assumptions identified here
  • ideation — to generate solutions once assumptions are validated

References

  • references/validation-methods.md — Detailed validation techniques
  • references/examples.md — Complete worked examples

Expand your agent's capabilities with these related and highly-rated skills.

Abhsin/DesignSkills

heuristic-evaluation

Systematic usability evaluation using established heuristics (Nielsen's 10, Shneiderman's 8, or custom rubrics). Use when reviewing UI designs, screenshots, prototypes, or live products for usability issues. Triggers on "review this design", "what's wrong with this UI", "usability check", "evaluate this interface", or when user shares screenshots/mockups asking for feedback.

4 1
Explore
Abhsin/DesignSkills

prompt-export

Convert structured UX specs and product context into a sequenced prompts.md file for Claude Code. Use when a user has completed upstream design thinking (problem framing, PRD, UX spec) and needs to translate that into step-by-step prompts that coding agents can execute incrementally. This skill bridges design artifacts to code generation.

4 1
Explore
Abhsin/DesignSkills

solution-scoping

Prioritize features and define MVP boundaries based on problem framing and user models. Use when a user has validated their problem and understands their users but needs to decide what to build first. Outputs feature priorities, MVP scope, and explicit cuts that feed into PRD generation.

4 1
Explore
Abhsin/DesignSkills

prd-generation

Generate lean, actionable Product Requirements Documents from upstream design thinking artifacts or raw input. Use when a user needs to define what they're building with enough structure to guide development but without enterprise bloat. Outputs a PRD that feeds directly into UX specs and development prompts.

4 1
Explore
Abhsin/DesignSkills

problem-framing

Extract and structure fuzzy product ideas into validated problem statements, target users, and jobs-to-be-done. Use when a user has a raw idea, concept, or solution in mind but hasn't clearly articulated the problem, target user, or assumptions. This skill helps users communicate context to coding agents more effectively, reducing iteration cycles and "that's not what I meant" moments.

4 1
Explore
Abhsin/DesignSkills

ux-specification

Translate PRDs into detailed UX specifications including user flows, screen descriptions, components, and interaction patterns. Use when a user has a PRD and needs to define the concrete UI/UX before generating development prompts. Bridges product requirements to implementation details.

4 1
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results