Skip to content
Skills Library
Management & product · Analysis

problem-definition

/problem-definition

Frame the real user or business problem (not a code/test bug) using Jobs-To-Be-Done, the 5-whys ladder, and problem-vs-symptom separation. Use when the user asks "are we solving the right problem", wants to write a problem statement, needs to separate problems from symptoms, wants to apply 5-whys to a product or organizational issue, suspects a brief conflates a feature with a problem, or wants to surface assumptions about what problem is actually being solved. NOT for ideating or brainstorming candidate solutions (use creative-problem-solving). NOT for diagnosing code, test, or CI bugs (use d

Repository
skillstack ↗
Licence
MIT
Last repository change
05.06.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
6
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

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

Frame the real user or business problem (not a code/test bug) using Jobs-To-Be-Done, the 5-whys ladder, and problem-vs-symptom separation. Use when the user asks "are we solving the right problem", wants to write a problem statement, needs to separate problems from symptoms, wants to apply 5-whys to a product or organizational issue, suspects a brief conflates a feature with a problem, or wants to surface assumptions about what problem is actually being solved. NOT for ideating or brainstorming candidate solutions (use creative-problem-solving). NOT for diagnosing code, test, or CI bugs (use d

Triggers from the description

are we solving the right problem
Original author description

Frame the real user or business problem (not a code/test bug) using Jobs-To-Be-Done, the 5-whys ladder, and problem-vs-symptom separation. Use when the user asks "are we solving the right problem", wants to write a problem statement, needs to separate problems from symptoms, wants to apply 5-whys to a product or organizational issue, suspects a brief conflates a feature with a problem, or wants to surface assumptions about what problem is actually being solved. NOT for ideating or brainstorming candidate solutions (use creative-problem-solving). NOT for diagnosing code, test, or CI bugs (use d

How it works

  1. When to Use
  2. When NOT to Use
  3. Decision Tree
  4. The three questions
  5. Problem vs symptom vs solution
  6. Jobs-To-Be-Done framing
  7. The 5-whys ladder
  8. Problem statement template
  9. Red flags — the problem is not yet defined
  10. Workflow
Original SKILL.md headings · 158 lines, 1,264 words
SKILL.md preview
---
name: problem-definition
description: >-
  Frame the real user or business problem (not a code/test bug) using
  Jobs-To-Be-Done, the 5-whys ladder, and problem-vs-symptom separation. Use
  when the user asks "are we solving the right problem", wants to write a
  problem statement, needs to separate problems from symptoms, wants to apply
  5-whys to a product or organizational issue, suspects a brief conflates a
  feature with a problem, or wants to surface assumptions about what problem
  is actually being solved. NOT for ideating or brainstorming candidate
  solutions (use creative-problem-solving). NOT for diagnosing code, test, or
  CI bugs (use debugging). NOT for ranking problems by priority (use
  prioritization).
---

# Problem Definition

Most products fail not because the solution was wrong, but because the problem was never sharpened. Teams jump from brief to build, skipping the step where they ask what problem they are actually solving, for whom, and why now.

## When to Use

- A brief or feature request needs to be unpacked into the underlying problem
- You suspect the team is solving the wrong problem
- You need to separate symptoms from root causes
- You want to apply 5-whys to a product or organizational issue
- You need to write a problem statement with assumptions and not-goals
- You want to surface hidden assumptions about what's being solved

## When NOT to Use

- Ideating or brainstorming candidate solutions (use creative-problem-solving)
- Diagnosing code, test, or CI bugs (use debugging)
- Ranking problems by priority (use prioritization)
- Writing a value proposition (use value-proposition-design)
- Identifying user needs (use user-needs-identification)

## Decision Tree

```
What problem framing problem do you have?
│
├─ Brief says "build X" — is X the problem?
│  ├─ X names a feature? → It's a solution, not a problem; apply JTBD
│  ├─ X names a metric? → It's a symptom; apply 5-whys
│  └─ X names a situation? → Closer; check for who/what/why-now gaps
│
├─ Symptom vs problem confusion
│  ├─ "Users churn in week one" → Symptom; 5-whys to find root cause
│  ├─ "Users can't get a working result in first session" → Problem ✅
│  └─ "Need a dashboard" → Solution in disguise; extract the job
│
├─ Writing a problem statement
│  ├─ Can't name a specific segment? → "Users" is too broad; narrow it
│  ├─ No current workaround documented? → You don't know how they cope yet
│  └─ No "why now" answer? → The problem may not be urgent enough to solve
│
└─ Validating an existing problem statement
   ├─ Names a feature as the problem? → Reframe as a job to be done
   ├─ Segment is "everyone"? → Too broad; narrow to a specific group
   └─ No assumptions listed? → Add 2-3 beliefs that, if wrong, invalidate the problem
```

## The three questions

Every well-defined problem answers these in one breath:

1. **Who** has the problem? (A specific segment, not "users.")
2. **What** are they trying to get done? (A job, not a feature.)
3. **Why** is it unsolved today? (Constraint, not just "nobody built it.")

If any of the three is missing or generic, stop and re-scope.

## Problem vs symptom vs solution

| Layer | Example |
|---|---|
| Symptom | "Users churn in the first week." |
| Problem | "New users cannot get a working result in their first session because setup requires three external accounts they do not have." |
| Solution | "Remove the account requirement for the first session." |

Teams debate solutions for weeks while the problem stays at the symptom layer. Force the climb from symptom to problem before discussing any solution.

## Jobs-To-Be-Done framing

A Job is what a user is hiring the product to do. Format:

> **When** [context / trigger], **I want to** [motivation], **so I can** [outcome].

Example:
> **When** I am onboarding a new hire, **I want to** give them a production-safe sandbox in one click, **so I can** unblock them without giving them prod credentials.

This framing separates the user's situation (context), motivation (what they are pulling toward), and expected outcome (success measure).

Three job dimensions exist and must be named separately — see `references/jtbd-framework.md`.

## The 5-whys ladder

Walk from stated problem to root problem by asking "why" five times. Each "why" should reveal a deeper constraint, not a synonym.

Example:

1. Users abandon the signup flow — **why?**
2. Because the email verification email is slow — **why?**
3. Because our queue worker is overloaded — **why?**
4. Because every signup triggers 12 side-effect emails — **why?**
5. Because marketing and product stacked their emails independently — **root problem: no shared transactional email policy.**

Stop when the next "why" becomes organizational ("because that's how it's always been") — that's the root cause. Full guidance in `references/five-whys-guide.md`.

## Problem statement template

```
PROBLEM STATEMENT

Who:        [specific segment]
Context:    [situation / trigger]
Job:        [what they are trying to get done]
Current:    [how they attempt it today]
Gap:        [where current fails — measurable]
Why now:    [reason this matters this quarter, not next]
Assumptions: [the 2-3 beliefs that, if wrong, invalidate the problem]
Not-goals:  [the adjacent problems we are explicitly not solving]
```

The `Assumptions` and `Not-goals` lines are the most often skipped and the most valuable. Assumptions surface what you are betting on; Not-goals prevent scope creep.

## Red flags — the problem is not yet defined

- The problem statement names a feature ("users need a dashboard").
- The affected segment is "users" or "everyone."
- The current workaround is not documented — you don't yet know how people cope without your product.
- The symptom and problem are not separated.
- Nobody can articulate why this matters this quarter.

If two or more of these are true, you do not yet have a problem — you have a brief. Go back to discovery.

## Workflow

1. **Restate the brief** in one paragraph without using the words "solution", "feature", or any proposed implementation.
2. **Identify the symptom** — the observable pain that triggered the conversation.
3. **Climb** with 5-whys until you hit a constraint you can name.
4. **Reframe as a Job** using the When/I-want-to/So-I-can template.
5. **Fill the template** including Assumptions and Not-goals.
6. **Challenge:** show the statement to someone outside the team and ask them to restate it. If they can't, it's not sharp enough.

## Anti-patterns

| Anti-Pattern | Problem | Solution |
|---|---|---|
| Solutioning the brief | Brief says "build X"; the problem behind X is never stated | Reframe: what job is X being hired for? What constraint makes X necessary? |
| Problem-as-feature | "Users need Slack integration" is a solution; the problem is a workflow broken by app-switching | Extract the job: "When I'm in my workflow, I want to notify the team, so I can..." |
| Segment of one | Problem defined around a single user interview and generalized without evidence | Validate with 3-5 more data points before committing resources |
| Symptom persistence | Problem statement names a metric ("reduce churn") instead of the underlying user situation | 5-whys from metric to root cause; restate as a job |
| Frozen not-goals | Not-goals never change as understanding improves | Revisit not-goals each iteration; they should evolve with understanding |
| No assumptions listed | Team proceeds without surfacing what they're betting on | List 2-3 assumptions; design a test for each |
| Skipping the current workaround | You don't know how users cope today, so you can't measure improvement | Document the workaround; the gap between workaround and ideal IS the problem |

## References

| File | Contents |
|---|---|
| `references/jtbd-framework.md` | Functional/emotional/social jobs, job hierarchy, interview prompts |
| `references/five-whys-guide.md` | 5-whys technique with worked examples, pitfalls, when to stop |
| `references/problem-statement-examples.md` | Good vs bad problem statements across SaaS, consumer, and internal tools |

## Related skills

- **user-needs-identification** — once the problem is framed, identify the jobs/needs behind it.
- **value-proposition-design** — once needs are understood, design the value proposition.
- **trade-off-analysis** — evaluate whether solving this problem is worth the cost of not solving others.
- **creative-problem-solving** — ideate solutions once the problem is defined.
Files in this package (6)
  • SKILL.md 8 KB
  • evals/evals.json 2 KB
  • evals/trigger-evals.json 2 KB
  • references/five-whys-guide.md 5 KB
  • references/jtbd-framework.md 5 KB
  • references/problem-statement-examples.md 7 KB

Versions

RepositoryScoreLicence
This page · viktorbezdek/skillstack100MIT
alexandrosandre/agentic-engineering90CC-BY-4.0

Database snapshot: 13.11.2026 · package version 986eabfff4ce (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

  • 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…
  • 100five-whys
    Ask "why" five times to drill past symptoms to the root cause of a problem — before designing a solution that treats the wrong thing. Use when a problem feels like a symptom of something deeper, before writing Sprint Questions, or when the team disagrees about what's causing a problem.
  • 100five-whys-root-cause
    Use when a problem keeps recurring, the first explanation is too shallow, or the action plan risks treating symptoms. Use when applying the Five Whys Root Cause consulting method and when a user asks for Five Whys Root Cause, method execution, structured diagnosis, or action planning.
  • 100root-cause-analysis
    Find the root cause of a problem, not just symptoms. Use when the user says "root cause", "why does this keep happening", "5 whys", "fishbone diagram", "cause analysis", "problem investigation", "defect analysis", "incident analysis", "A3 problem solving", "what's causing this",…
  • 100problem-statement
    Define the framing of a problem. Change the statement, change the solution space. Use when starting work, when solutions feel wrong, or when you suspect an X-Y problem.
  • 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.