Skip to content
Skills Library
Management & product · Writing

problem-statement

/problem-statement

Write a crystal-clear problem statement that defines the user, pain, impact, and evidence before jumping to solutions. Produces a structured statement with user segment, current behavior, pain points, business impact, evidence, success criteria, and anti-scope. Use when aligning stakeholders on what to solve, before writing a PRD, when a team is jumping to solutions without defining the problem, or when framing a discovery initiative.

Repository
pm-skills ↗
Licence
MIT
Last repository change
23.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 23.08.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

Write a crystal-clear problem statement that defines the user, pain, impact, and evidence before jumping to solutions. Produces a structured statement with user segment, current behavior, pain points, business impact, evidence, success criteria, and anti-scope. Use when aligning stakeholders on what to solve, before writing a PRD, when a team is jumping to solutions without defining the problem, or when framing a discovery initiative.

Original author description

Write a crystal-clear problem statement that defines the user, pain, impact, and evidence before jumping to solutions. Produces a structured statement with user segment, current behavior, pain points, business impact, evidence, success criteria, and anti-scope. Use when aligning stakeholders on what to solve, before writing a PRD, when a team is jumping to solutions without defining the problem, or when framing a discovery initiative.

How it works

  1. Purpose
  2. Domain Context
  3. Context
  4. Instructions
  5. Output Format
  6. Notes
Original SKILL.md headings · 143 lines, 1,055 words
SKILL.md preview
---
name: problem-statement
description: "Write a crystal-clear problem statement that defines the user, pain, impact, and evidence before jumping to solutions. Produces a structured statement with user segment, current behavior, pain points, business impact, evidence, success criteria, and anti-scope. Use when aligning stakeholders on what to solve, before writing a PRD, when a team is jumping to solutions without defining the problem, or when framing a discovery initiative."
---

# Problem Statement: Define the Problem Before the Solution

## Purpose

You are an experienced product manager helping a team articulate a clear, evidence-based problem statement for **$ARGUMENTS**. A well-written problem statement is the foundation of every good product decision — it aligns stakeholders, focuses discovery, and prevents solution-first thinking.

## Domain Context

Problem statements sit at the very start of the product discovery process — before hypotheses, before experiments, before PRDs. In Teresa Torres's Opportunity Solution Tree framework, a problem statement maps to the **opportunity space**: it defines the unmet need the team will explore. Without a clear problem statement, teams build features nobody asked for, chase vanity metrics, or solve symptoms instead of root causes.

A strong problem statement follows this structure:

> "We believe **[user segment]** experiences **[problem]** when **[situation]**, which leads to **[impact]**. Currently, they **[workaround]**. Evidence: **[data points]**."

### What You'll Need

| Input | Required? | Example |
|-------|-----------|---------|
| Problem area or observation | ✅ Required | "Users abandon onboarding at step 3" |
| Target user segment | 🟡 Recommended | Mid-market SaaS teams, 50–200 employees |
| Supporting data or research | 🟡 Recommended | Analytics, survey results, interview notes |
| Business context or goals | ⚪ Optional | Q3 retention target, strategic initiative |

> **Don't have everything?** Start anyway — the skill will work with what you provide and flag where additional research would strengthen the statement.

## Context

You are writing a problem statement for **$ARGUMENTS**.

If the user provides files (analytics reports, interview transcripts, survey data, or product briefs), read them first to ground the problem statement in evidence.

## Instructions

### Phase 0: Context Confirmation

Before proceeding, review what's been provided in $ARGUMENTS and the conversation context. **Only ask about what's missing — don't re-ask what's already clear.**

1. **Summarize** what you understand from the provided context — restate the product, feature, or situation back to the user in 2-3 sentences.
2. **Identify gaps** — if any of the following are unclear, ask:
   - What problem or pain point are we articulating?
   - Who experiences this problem?
   - What evidence exists that this is a real and meaningful problem?
3. **Confirm**: _"Here's my understanding: [summary]. I plan to [brief description of what the skill will produce]. Does this look right, or would you like to adjust anything before I proceed?"_

If the user provides additional context, incorporate it. If the user confirms, proceed.

1. **Identify the user segment**:
   - Who exactly experiences this problem? Be specific — not "users" but "mid-market engineering managers onboarding new team members."
   - If the segment is unclear, propose 2–3 candidate segments and recommend which to focus on and why.

2. **Define the problem clearly**:
   - Describe the pain in the user's language, not internal jargon.
   - Distinguish the **problem** (what's broken) from the **symptom** (what we observe) and the **cause** (why it happens).
   - A good problem statement is solution-agnostic — it should not imply or prescribe a solution.

3. **Articulate the impact**:
   - What happens to the user when this problem goes unsolved? (frustration, wasted time, lost money, missed goals)
   - What happens to the business? (churn, reduced activation, lower NPS, revenue at risk)
   - Quantify impact wherever possible.

4. **Document current behavior and workarounds**:
   - What do users do today to cope? (manual processes, competitor tools, ignoring the problem)
   - Workarounds reveal the intensity of the pain — if users invest effort to work around it, the problem is real.

5. **Gather and evaluate evidence**:
   - List all supporting data: analytics, interviews, support tickets, survey responses, market research.
   - Rate the strength of evidence: **Strong** (quantitative data, multiple sources), **Moderate** (qualitative patterns, single source), **Weak** (anecdotal, assumed).
   - Flag gaps where more research is needed.

6. **Run the "5 Whys" root cause analysis**:
   - Start with the observable symptom and ask "Why?" five times.
   - Each answer becomes the basis for the next "Why?"
   - The goal is to find the root cause, not just the surface issue.
   - Document the chain so the team can see the reasoning.

7. **Validate the problem statement**:
   - Apply these quality checks:
     - **Specific**: Could a new team member understand exactly who is affected and what's wrong?
     - **Evidence-based**: Is every claim supported by data or research?
     - **Solution-agnostic**: Does it avoid implying a particular solution?
     - **Actionable**: Could a team start discovery work from this statement?
     - **Scoped**: Is it narrow enough to solve in a reasonable timeframe?

## Output Format

```
## Problem Statement: [Short Title]

### Problem Statement
[One clear sentence following the framework: "We believe [user segment] experiences [problem] when [situation], which leads to [impact]."]

### User Segment
- **Who**: [Specific description]
- **Estimated size**: [How many users are affected]
- **How we know**: [Source of segment definition]

### Current Behavior
- What users do today: [Description]
- Workarounds in use: [List]
- Tools or alternatives used: [List]

### Pain Points
1. [Pain point 1 — with evidence]
2. [Pain point 2 — with evidence]
3. [Pain point 3 — with evidence]

### Business Impact
- **User impact**: [What users lose — time, money, trust]
- **Business impact**: [What the business loses — revenue, retention, growth]
- **Opportunity cost**: [What we can't do while this problem persists]

### Evidence
| Evidence | Source | Strength |
|----------|--------|----------|
| [Data point] | [Where it came from] | Strong / Moderate / Weak |

### Root Cause Analysis (5 Whys)
1. Why? → [Answer]
2. Why? → [Answer]
3. Why? → [Answer]
4. Why? → [Answer]
5. Why? → **Root cause**: [Answer]

### Success Criteria
- [How we'll know the problem is solved — measurable outcomes]

### What This is NOT (Anti-Scope)
- [Explicitly out of scope — problems we are not trying to solve]
- [Adjacent issues that should be addressed separately]
```

Save as markdown: `ProblemStatement-[topic]-[date].md`

## Notes

- A problem worth solving should have evidence from multiple sources — don't rely on a single anecdote.
- If you can't articulate the problem in one sentence, it's likely too broad — split it into sub-problems.
- Revisit the problem statement after early discovery — new evidence may sharpen or redirect it.
- Share the problem statement with engineering and design before jumping to solutions — alignment here saves weeks later.

---

Versions

RepositoryScoreLicence
This page · tarunccet/pm-skills100MIT
open-horizon-labs/repo-native-alignment100MIT
getcrew44/crew44100MIT

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

Downloads in the last 30 days: 0 · ranking

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

Similar skills

  • 100problem-framing-canvas
    Guide teams through MITRE's Problem Framing Canvas. Use when you need a clearer problem statement before jumping to solutions.
  • 100prd-v01-problem-framing
    Transform vague product ideas into evidence-anchored problem statements for PRD v0.1 Spark. Triggers on starting new products/features, validating market opportunities, drafting PRD Why sections, or requests like "frame the problem", "define pain points", "write problem…
  • 100021-problem-framing
    Use when a problem or issue needs explicit framing before deeper analysis begins — establishing the Problem statement, Current state, Desired state, Stakeholders, and Success criteria. This should trigger when an issue's Problem Framing point of view needs evaluation, or when a…
  • 100problem-framing
    Use when the user needs to sharpen a vague problem into pain points, reframed questions, and ranked opportunities before designing solutions. Triggers on "frame the problem", "pain points", "how might we", "HMW", "opportunity assessment", "what problem", and the same intent in any language.
  • 85pm-problem-statement
    Write or critique a product problem statement — turning a vague prompt, signal, or feature request into a clear, evidence-grounded, testable statement of the real problem before any solution. Separates the problem from solutions, symptoms, goals, and constraints; applies the…
  • 100problem-statement-builder
    Transform a raw problem hypothesis into a structured, testable Problem Statement using Jobs-to-be-Done (JTBD) framing. Use when working on product discovery, PRDs, user stories, OKRs, or backlog planning.

Feedback and reports

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