# Probe Strategy Stress-test a plan before committing to it — relentless interrogation until every branch of the decision tree is resolved. Legend (from RFC2119): !=MUST, ~=SHOULD, ≉=SHOULD NOT, ⊗=MUST NOT, ?=MAY. **⚠️ See also**: [strategies/discuss.md](./discuss.md) | [strategies/interview.md](./interview.md) | [core/glossary.md](../glossary.md) > Inspired by [grill-me](https://github.com/mattpocock/skills/tree/main/grill-me) from [mattpocock/skills](https://github.com/mattpocock/skills). Adapted to directive's preparatory strategy pattern. --- ## When to Use - ~ Before committing to any significant design decision or architecture choice - ~ When a plan has been drafted but not yet stress-tested - ! When the user explicitly asks to be probed or challenged on their plan - ? Skip when the path forward is unambiguous and small in scope ## Core Principle The goal is not alignment — that's `discuss`. Probe is adversarial discovery. It assumes the plan has holes and sets out to find them. Every assumption is challenged, every edge case explored, every dependency branch walked until nothing is unresolved. Where `discuss` builds consensus, `probe` finds what's missing. --- ## Workflow ### Step 1: Establish the plan - ! Read whatever plan, design, or spec exists in the conversation context - ~ If no plan is in context, ask ONE question: "What's the plan you want me to probe?" - ~ If codebase context is relevant, explore it to answer what you can before asking - ⊗ Ask follow-up questions before reading available context ### Step 2: Interrogate relentlessly Walk the decision tree depth-first. For each unresolved branch: - ! Ask **ONE** focused question per message - ! For each question, provide your recommended answer with brief reasoning - ! If the codebase can answer a question, explore it instead of asking the user - ~ Follow the thread — if an answer opens new branches, pursue them before moving on - ⊗ Ask multiple questions at once - ⊗ Accept vague answers — push back: "What does that mean concretely?" - ⊗ Move to the next branch before the current one is fully resolved ### Question focus areas - ! **Assumptions** — "This assumes X is guaranteed — is it?" - ! **Edge cases** — "What happens when Y is empty / null / at the limit?" - ! **Dependencies** — "This requires Z to exist — what if it doesn't?" - ! **Failure modes** — "How does this fail? How is that surfaced to the user?" - ! **Scaling** — "Does this hold at 10× the expected volume?" - ~ **Security surface** — "Who can reach this? What's the blast radius if it's wrong?" - ~ **Reversibility** — "Can this decision be changed later? What's the migration cost?" ### Transition criteria (probe complete) - ! All major decision branches have been resolved - ! No open assumptions remain - ~ User has acknowledged the risks of any deliberately deferred decisions - ~ No new branches are surfaced by the last 2–3 questions --- ## Output ! Before writing output artifacts, follow the [Preparatory Guard](./artifact-guards.md#preparatory-guard-light). ### Mechanical guard (`deft probe-session`) Probe completion is enforced mechanically — not by prose alone. A per-clone session file at `.deft/probe-session.json` records whether the session is still `interrogate` or `complete`, plus the probe `target`, `currentBranch`, and `resolvedDecisions`. **Waiver (#3556):** The probe skill keeps the no-artifact guard and does not require `deft probe-session`. This strategy names `deft probe-session`. Silence is not agreement. - ! At probe start, record the session: `deft probe-session start --target ` - ! While interrogating, record locked/deferred/risk-accepted decisions and branch focus with `record` / `set-branch` subcommands as branches resolve - ! Before writing probe output or registering `completedStrategies.probe`, mark the session complete: `deft probe-session complete` - ! Immediately before artifact or plan registration, run the guard: - `deft probe-session guard-artifact --path xbrief/proposed/YYYY-MM-DD-{scope}-probe.xbrief.json` - `deft probe-session guard-plan-registration` - ⊗ Write probe artifacts or update `completedStrategies.probe` while the session state is still `interrogate` — the guard exits non-zero with an actionable recovery message **Recovery when the guard blocks handoff:** continue interrogation until the [transition criteria](#transition-criteria-probe-complete) are met, record decisions with `deft probe-session record`, run `deft probe-session complete`, then retry the guard before writing artifacts or updating `plan.xbrief.json`. `{scope}` is the project name from `PROJECT-DEFINITION.xbrief.json`, or the feature/component name if probing a sub-scope. Use the same value consistently throughout the session. Examples: `my-app-probe`, `auth-probe`. - ! Produce a `xbrief/proposed/YYYY-MM-DD-{scope}-probe.xbrief.json` scope xBRIEF with three mandatory narratives: - `LockedDecisions` — what was resolved and why (when the lock is an intentional under-build, include dual-path graduation fields: `now`, `later`, `graduationRef`, `trigger`, `status` — see [Graduation (Now+Later)](#graduation-nowlater-when-locking-an-under-build-2899)) - `SurfacedRisks` — concerns raised, even if not fully resolved - `DeferredDecisions` — explicitly acknowledged items with justification - ! Each entry in a narrative includes: **question asked**, **answer given**, **status** (locked / deferred / risk-accepted) - ! This xBRIEF is injected into all downstream work: planning, execution, verification - ! Persist significant decisions as xBRIEF narratives on the relevant plan items - ⊗ Write probe output to a hand-authored markdown file — use xBRIEF narratives for token-efficient, machine-consumable agent consumption (mirrors the [discuss](./discuss.md) and [research](./research.md) output contracts so the chaining-gate flow-through guarantee is mechanical, not aspirational) ! After emitting the probe scope xBRIEF to `xbrief/proposed/`, surface the GitHub-issue tracking hint from [emit-hints.md](./emit-hints.md) — name all three patterns (none / `--umbrella` / `--per-vbrief`). ## Graduation (Now+Later) when locking an under-build (#2899) Probe already separates **locked**, **deferred**, and **risk-accepted** branches. **Graduation** is a fourth case that must not collapse into `DeferredDecisions`: | Concept | Probe role | |---|---| | `LockedDecisions` (permanent) | Approach is decided and is the end-product path | | `DeferredDecisions` | *Undecided* open question with justification | | **Graduation** on a lock | *Decided* weaker **Now** + *decided* end-product **Later** | | rapid **graduate** | Strategy-level spike → fresh spec; not dual-path tracking here | Glossary naming for Graduation is owned by sibling work (#2907); this section is the Wave A probe contract. - ! When probe **locks** a temporary / weaker approach and the end-product approach is also decided, record the dual-path shape on that `LockedDecisions` entry (not as a `DeferredDecisions` open question): - `now` — what ships in the near path - `later` — end-product approach - `graduationRef` — GitHub issue and/or scope xBRIEF path for Later work - `trigger` — condition that makes Later required (free text) - `status` — `open` | `shipped` | `cancelled` (cancel with justification) - ! Permanent locks and true open questions do **not** gain graduation fields — do not ticket-spam every `DeferredDecisions` item into a graduation - ! `task scope:complete` on a Now story MUST NOT close linked graduation work; Later stays open until shipped or explicitly cancelled - ⊗ Accepting "we'll harden it later" as a locked under-build without dual-path fields, or filing it only as `DeferredDecisions` - ⊗ Closing graduation work solely because the MVP / Now story completed --- ## Then: Chaining Gate After the probe is complete and `xbrief/proposed/YYYY-MM-DD-{scope}-probe.xbrief.json` is written, return to the [chaining gate](./interview.md#chaining-gate). - ! On completion, register artifacts in `./xbrief/plan.xbrief.json`: - Update `completedStrategies`: increment `runCount` for `"probe"`, append artifact path (`xbrief/proposed/YYYY-MM-DD-{scope}-probe.xbrief.json`) - Append the path to the flat `artifacts` array - ! Return to [interview.md Chaining Gate](./interview.md#chaining-gate) - ! The `LockedDecisions`, `SurfacedRisks`, and `DeferredDecisions` narratives from `xbrief/proposed/YYYY-MM-DD-{scope}-probe.xbrief.json` MUST flow into subsequent strategies and spec generation: - Locked decisions become constraints in the specification - Surfaced risks become NFRs or explicit acceptance criteria - Deferred decisions appear as open questions in the spec - ⊗ End the session after probe without returning to the chaining gate or the invoking strategy's next-step menu ! **Standalone context:** If invoked from a standalone strategy (e.g. map's standalone next-step menu) rather than from the interview chaining gate, return to the invoking strategy's menu instead. --- ## Anti-Patterns - ⊗ Accepting "we'll figure it out later" without marking it as explicitly deferred - ⊗ Recording a *decided* weaker-Now + stronger-Later path only as `DeferredDecisions` (or chat) instead of dual-path graduation fields on the lock (#2899) - ⊗ Treating Now-story `scope:complete` as closure of linked graduation work (#2899) - ⊗ Asking generic checklist questions instead of following the decision tree - ⊗ Letting vague answers pass without pushing for concrete specifics - ⊗ Using codebase exploration as a substitute for asking the user about deliberate design choices - ⊗ Stopping when the conversation feels comfortable — stop when no new branches emerge - ⊗ Ending after probe without chaining back to the gate (chained mode; in standalone context, returning to the invoking strategy's menu satisfies the completion requirement per the [standalone-context rule](#then-chaining-gate)) - ⊗ Writing probe output to a plain markdown file (`{scope}-probe.md`) instead of the canonical `xbrief/proposed/YYYY-MM-DD-{scope}-probe.xbrief.json` scope xBRIEF — plain markdown bypasses the [Preparatory Guard](./artifact-guards.md#preparatory-guard-light) and breaks the downstream-consumer flow-through guarantee