Pm Problem Statement

Problem Statement Skill

How this skill behaves (read first)

This is a generative skill, and a problem statement is where most product work quietly goes wrong. Claude's default is to restate a request as a problem and move on — producing the four classic failures: a solution in disguise ("users need a better search"), a vagueness ("the UX is bad," "the process is inefficient"), a business outcome posing as a problem ("we need to increase revenue"), or a symptom mistaken for the cause (churn is up → "fix churn"). Each one locks the team into solving the wrong thing, well. A good problem statement is a gap a real user experiences, in context, grounded in evidence, measurable, and free of any named solution. So this skill gates:

1. Establish what you actually have — a validated problem, or a prompt / signal / request / metric that only looks like one.
2. Apply the always-true core — separate problem from solution/symptom/goal, find the true cause, make it specific and measurable, ground it in evidence, bridge user and business.
3. Surface the context-dependent decisions (which definition tool, how much measurability now, reasoned vs. evidence-validated cause, scope) with trade-offs.

Then it hands off to pm-okr-metric-validity-audit (the measurable element) and pm-assumption-rigor-audit (the assumed root cause) for validation.

Scope: this skill owns the problem-statement artifact. It defers the broader problem-finding process to pm-discovery, hypothesis/experiment design to pm-assumption-testing, turning the statement into a full spec to pm-product-spec (audited by pm-spec-quality-audit), ranking which problem to tackle to pm-prioritization-rigor-audit / pm-prioritization, personas depth to pm-personas-jtbd, and user stories to pm-user-story.

Step 0 — Establish context before writing the statement

Ask if not known; state the assumption if proceeding without an answer:

• What do you actually have in hand? A moving metric, a feature request ("add X"), or a vague directive ("improve onboarding") is a signal or a solution, not a problem. Restate it without metrics, tools, or desired outcomes first. The test: could the sentence plausibly be said by the person experiencing the issue?
• Whose problem, and in what context? A problem needs a specific group, moment, and difficulty. "Improve engagement" becomes workable only as "new users abandon setup because the required steps are unclear."
• What evidence backs it — and is the cause known or assumed? Distinguish what you've verified from what you're inferring. The root cause at this stage is usually a reasoned claim, not a proven one.
• What is the statement feeding? A spec, a discovery effort, an OKR, or an interview/case answer — this sets how measurable and formal it needs to be.

The always-apply core (true for any problem statement)

• A problem is a gap, never a feature. It describes the distance between the current and desired state from the user's point of view, with no solution named. Translate "we need to add / we should build / the product lacks…" into a neutral description of what is difficult, slow, confusing, or risky. Test: if only one solution could address it, it's a solution in disguise — a real problem leaves room for several.
• Separate the problem from symptoms, goals, and constraints. A moving metric (churn, low adoption) is a symptom; "increase retention/revenue" is a goal or business outcome; budget and timeline are constraints. The problem sits underneath them — the user difficulty that causes the symptom. "We need to increase revenue" is never the problem.
• Find the true cause, not the surface. Use 5 Whys / reasoning to get from symptom to root. The cause must logically explain the symptom and survive being challenged ("the feature is already shown in onboarding, so 'users don't know it exists' doesn't hold — more likely it appears at the wrong moment"). Treat the cause as an explanation that has to stay consistent under questioning.
• Be specific and fact-based. "Users are unhappy" hides the cause and the impact. Name who is affected, when/where it happens, the concrete obstacle, and the measurable consequence. ❌ "We need to redesign the app." ✅ "Users fail to complete purchases because navigation between product and checkout pages is unclear."
• Make it measurable. Include a metric so success is checkable and scope is bounded ("decrease cart abandonment 15% within a month"). The measurable element doubles as a future key result. Without it, you can't know if you succeeded — but keep it a real outcome, not a vanity count.
• Ground it in evidence, not internal assumption. Verify the problem against user signals — interviews, support tickets, analytics, session replays — and synthesize patterns. Coding qualitative feedback into quantitative findings ("45% of reports mention a checkout error") turns opinion into evidence. A statement built only on what the team believes is the failure mode.
• Bridge user and business. Connect the user difficulty to its business impact (lost conversions, churn, cost, risk) so it earns attention — without treating user needs and business goals as competing. Translate a business problem into the user problem beneath it: "not enough signups" → why aren't users signing up (unclear value? complex flow? trust?).
• Test the statement before using it. Can design, engineering, and leadership each understand who is affected, why it matters, and what's wrong — without extra explanation, and without a solution baked in? If it keeps needing reinterpretation, it isn't done.

A workable structure: problem + consequence/impact + intended goal, carrying who / when-context / measurable element — or the 4 Ws (Who, What, Where, Why) for the user-centric framing.

The context-dependent decisions (surface, don't auto-apply)

Present each with its trade-off and a recommendation tied to Step 0; let the user choose. Running every framework on every prompt is the failure mode — reach for the tool that closes the specific gap.

Validate the result (orchestration)

Hand-offs name each lens by its installable skill name. Invoke one only if that skill is installed; if it isn't, this skill's own core already carries these rules — proceed without it rather than blocking.

After producing or revising, hand it to the audit lenses rather than declaring it done. These are candidate lenses — posture per docs/orchestration-policy.md, or route the whole artifact through pm-product-review. Here assumption-rigor is the always-relevant lens (auto-runs); the others are offered, tied to what the artifact actually contains. If the user invoked this skill for one specific thing, respect that scope.

• pm-assumption-rigor-audit (auto-runs) — the root cause is an assumption until validated. Is the riskiest cause-claim named honestly, and is the evidence behind it real (a pattern across sources) rather than a single anecdote or an internal belief?
• pm-okr-metric-validity-audit (offer — if it names a measurable element) — the measurable element: is it a real outcome that reflects the user's success, falsifiable, and not a vanity or gameable number? (This is also the metric that will likely become a key result.)

Composition (per docs/orchestration-policy.md §9): if discovery hasn't yet surfaced the underlying problems, that work (pm-discovery) is an upstream input; the test designed for the statement (pm-assumption-testing) and the spec it becomes (pm-product-spec) are downstream (offer to produce next, don't auto-generate). If the audits surface a conflict (e.g., the only available metric is a vanity number, or the cause can't be evidenced), resolve toward the purpose: a problem statement exists to point the whole team at the right problem — keep it true, specific, and provable, not convenient. For a full idea-to-plan build, pm-idea-to-plan is the compositional front door that sequences this step with the rest of the ladder and enforces evidence before the spec.

Common do/don't patterns

Source lessons (Uxcel)

• Identifying the True Problem
• Defining Problems for Effective Specifications
• Problem Definition Tools
• Framing the Problem into Hypotheses