# Wazzap Real

> Phase 2 of /wazzap — Socratic drilldown. Probe layer-by-layer to find the real problem under the surface wish. Use when the user invokes /wazzap:real or asks 'what's really up'.

- Skill: `enw/wazzap-real` (Agent Skill)
- Install (CLI): `npx skillmds@latest add enw/wazzap-real`
- Raw SKILL.md: https://api.skillmd.com/api/skills/enw/wazzap-real/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: enw (https://skillmd.com/u/enw)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/enw/wazzap-real

---


# `/wazzap:real` — "What's really up?"

Phase 2 of 4. **Mode: Socratic, multi-turn.** Probe one question at a time until the user can name the *real* problem under the surface wish. This is the framework's signature move — the part that earns the audit trail.

## Goal

Produce `real.md` with a Q+A probing log and a clean problem statement that enables `:approaches` without rework.

## Preconditions

1. Read parent `SKILL.md` for cross-cutting rules.
2. Resolve the active decision via `<wazzap-root>/_active` (or `slug=<x>` arg).
3. Read `up.md` to know the surface wish.
4. **Soft-gate check:** if no `up.md` exists, warn and write a stub `up.md` ("Skipped — picked up at :real on <date>"). Continue.

## Steps

1. **Open with the surface wish.** Restate it back: *"Surface wish from `:up`: '<wish>'. Now — what's really up?"*

2. **Probe one question at a time.** Default budget: **3–5 questions**. Hard cap: **8**. After each round:
   - User answers.
   - Agent **restates the real problem (current best draft)** in one sentence.
   - Agent asks: *"Does that land, or do we keep digging?"*
   - User can stop early ("yes, that's it") or continue.

3. **Probe categories** — pick whichever the wish hasn't already covered. Don't run all of these; mix-and-match:

   | Lens | Question pattern |
   |---|---|
   | Symptom vs cause | "If you fixed the surface thing tomorrow, would the underlying frustration still be there?" |
   | Disappearance test | "If this problem vanished overnight, what would actually change in your day?" |
   | Who feels it | "Who's most paying the cost right now? You? Users? A teammate? Future-you?" |
   | Hidden constraint | "What can't you change, even if it would solve this?" |
   | Failure mode | "What does it look like 6 months from now if you do *nothing*?" |
   | Success signal | "How would you know this was solved without anyone telling you?" |
   | Trigger | "Why is this surfacing *now*, not 3 months ago or 3 months from now?" |
   | Reframe | "Is this a [decision / capability / risk / relationship / clarity] problem?" |

4. **Stop conditions.** Stop probing when **any** of these is true:
   - User says "good", "that's it", "stop", or similar.
   - Agent has restated the real problem and the user agrees.
   - 8-question hard cap hit (write what you have, label remaining gaps in `Unknowns`).

5. **Synthesize.** Once probing is done, draft the structured sections (real problem, stakeholders, constraints, success criteria, non-goals, facts/assumptions/unknowns).

6. **Show the synthesis to the user.** Ask: *"Does this land? Edit anything before I save?"*. Apply edits, then write `real.md`.

7. **Update manifest.** `current_phase: real`, append `real` to `completed_phases`, bump `updated_at`. Optionally update `title` if the framing shifted enough.

8. **Suggest next command:** `/wazzap:approaches`.

## Probing technique notes

- **One question per message.** Never stack questions.
- **Multiple choice when possible.** Easier to answer than open-ended.
- **Mirror the user's language.** Use their nouns and verbs, not your reframe.
- **Don't moralize.** The Socratic move is to expose, not judge. If the user's "real problem" is "I don't want to have a hard conversation with my co-founder," capture that — don't soften it to "communication gap."
- **Surface assumptions explicitly.** When you hear "X always Y," ask "always? or just lately?"

## `real.md` template

```markdown
# Real problem (Phase 2)

**Slug:** `<slug>`
**Drilled on:** <ISO timestamp>

## Surface wish (from `:up`)

> <verbatim from up.md "The wish" section>

## Probing log

**Q1:** <agent question>  
**A1:** <user answer (verbatim or distilled with quotes around exact phrasing)>

**Q2:** <agent question>  
**A2:** <user answer>

<...continue for each Q+A...>

## The real problem

<One sentence. The thing that, if solved, makes the surface wish irrelevant or trivial.>

## Stakeholders

- **<role/name>** — <how they're involved, what they want>
- ...

## Constraints

- **Time:** <deadline or "open">
- **Money:** <budget bound or "n/a">
- **People:** <who's available, who's not>
- **Tech:** <hard tech limits>
- **Political/social:** <can't-touch topics, relationships at stake>
- **Other:** <whatever else came up>

## Success criteria (observable)

- <What you'd see/measure that proves it's solved>
- ...

## Non-goals

- <Explicit scope cuts — things the user said are NOT what they're trying to do>
- ...

## Facts / Assumptions / Unknowns

**Facts** (verified or self-evident):
- ...

**Assumptions** (treated as true, but not verified):
- ...

**Unknowns** (open questions that may or may not block `:approaches`):
- ...
```

## Revisits (re-running `:real` later)

If `real.md` already exists, **append, don't overwrite**:

1. Read existing `real.md`.
2. Append a new section:
   ```markdown
   ---
   ## Revisited <ISO timestamp>
   
   **Trigger:** <user-stated reason for coming back>
   
   ### Probing log (this round)
   ...
   
   ### Updated real problem
   <new one-sentence statement>
   
   ### What changed since last round
   - <e.g. "Stakeholder X was added", "Constraint Y was relaxed", "Surface symptom turned out to be different">
   ```
3. Update manifest:
   ```yaml
   revisits:
     - phase: real
       at: <ISO timestamp>
       reason: "<trigger>"
   ```
4. Bump `updated_at`. Don't change `completed_phases`.

The original probing log stays untouched. That's the audit trail commitment.

## Output to user (after writing)

```
✓ real.md written.

Real problem: <one-sentence statement>

Next: /wazzap:approaches to generate options.
```

## Anti-patterns to avoid in `:real`

- ❌ Stacking questions ("Who's affected? Why now? What's the constraint?"). One at a time.
- ❌ Skipping the "current best draft" restatement after each round. That's how the user knows when to stop.
- ❌ Letting probing run past 8 questions. If you're at 8 and the real problem isn't crisp, write what you have and label the rest as `Unknowns`. Better imperfect than indefinite.
- ❌ Sanitizing the user's language. "I'm angry at my co-founder" is not "interpersonal alignment opportunity."
- ❌ Generating Q&A the user didn't actually answer. The probing log is verbatim or it's worthless.
- ❌ Overwriting an existing `real.md`. Always append on revisit.

## Self-check before finishing

- [ ] Probing log has at least 3 verbatim Q+A pairs (or hit 8-cap with explanation).
- [ ] Real problem is one sentence, agreed by user.
- [ ] Stakeholders, constraints, success criteria, non-goals all present (use "Not yet identified" if genuinely empty, don't fabricate).
- [ ] Facts vs Assumptions vs Unknowns are labeled separately.
- [ ] Manifest updated: `current_phase`, `completed_phases`, `updated_at`.
- [ ] Suggested next command in output.