explore · diff

git:20261003.02542fa to git:20261004.932439b

36 added, 27 removed. Audit A to A.

---

name: explore

- description: Think an idea through before planning: read the repo, weigh options, clarify choices; writes no files.

+ description: "Think an idea through before planning: read the repo, weigh options, clarify choices; writes no files."

user-invocable: true

---

# /explore

- `/explore` starts [the change loop](../../../wiki/development/the-change-loop.md): compare real options and firm up scope before `/plan` writes a proposal. Find related work with `openspec list --json` and `openspec context --json` ([the CLI contract](../plan/references/openspec-cli.md#select-one-root)) and read what they point to.

+ Start [the change loop](../../../wiki/development/the-change-loop.md): compare options and settle scope before `/plan`. Find related work with `openspec list --json` and `openspec context --json` ([CLI contract](../plan/references/openspec-cli.md#select-one-root)); read their pointers.

- `/explore` **writes nothing**, not even the answers: [`/plan`](../plan/SKILL.md) logs them in the proposal's Decision log. **It always runs before `/plan`**, except for [review-page notes](../plan/SKILL.md#review-notes): you invoke it, or `/plan` invokes it in [bounded mode](#when-plan-invokes-explore).

+ **Write nothing**; [`/plan`](../plan/SKILL.md) logs answers. Explore precedes planning except [review-page notes](../plan/SKILL.md#review-notes); use [bounded mode](#when-plan-invokes-explore) under `/plan`.

+ ## Investigate the relevant flow

+ Read owning docs and source; trace trigger, result, and constraints. For non-code, read the process and authoritative sources. Discover facts; separate observations from inferences. Use proportional, authorized read-only checks; no prototypes or local builds. Name unavailable evidence and a later check.

+ For consequential choices, compare viable approaches, outcomes, costs; recommend with evidence. Invent no alternatives for settled or mechanical requests. Before handoff, check material assumptions and failures against the flow; revise contradictions. Speculative or cheaply changed concerns need no questions.

## Questions during standalone exploration

- Ask material questions [the shared way](references/asking-the-user.md), in small groups answerable together: two or three, one when only one matters. Wait for answers before dependent follow-ups. Skip settled questions; use as many groups as needed. Keep findings in chat, [drawn](../plan/references/drawings.md) where a picture shows the flow, options, or costs.

+ Ask [the shared way](references/asking-the-user.md): two or three related ready choices, one if alone, within tool capacity. Track decisions and prerequisites in chat. Investigate missing facts; hold only dependent choices and ask independent ones as the host permits. Never ask the person to guess facts.

- **The 80/20 test:** ask only where a wrong guess makes the artifacts *wrong*, not merely *different*: scope, observable behavior, compatibility, acceptance criteria. Assume and record naming, placement, wording, and anything a reviewer can cheaply change later.

+ Update dependencies after answers or evidence. Explain changed premises; reopen only affected decisions. Keep findings in chat, [drawn](../plan/references/drawings.md) when useful.

+ **The 80/20 test:** ask where a wrong guess makes the plan *wrong*, not merely *different*: scope, observable behavior, compatibility, acceptance criteria. Assume naming, placement, wording, and cheaply changed details, with reasons.

## Search memory before asking

- Before the first question, search once on the intent's key terms and load the areas of the paths you expect to touch:

+ Before asking, search intent terms and likely paths once:

```bash

node "$(git rev-parse --show-toplevel)/.claude/skills/memory/scripts/memory.mjs" search <terms>

node "$(git rev-parse --show-toplevel)/.claude/skills/memory/scripts/memory.mjs" areas <paths>

```

- Don't ask what a live fact answers: state it, with its age and author, as an assumption the user can correct. When [the store is unreachable](../memory/SKILL.md#read), say so and continue.

+ Use live facts as correctable assumptions, naming age and author. [Memory unreachable](../memory/SKILL.md#read)? Say so; continue.

## Check for other work

- Once the work is known to change repo files, look at this repo's other work once, so two chats don't plan the same thing unaware:

+ For repo edits, check other work once:

```bash

node "$(git rev-parse --show-toplevel)/.claude/skills/explore/scripts/other-work.mjs"

```

- It prints this repo's other live workspaces (name, branch, active plans, changed files, `busy` when an agent runs there, `pr` when one is open) and open pull requests not opened by a bot. Compare them to the request by meaning, not file names: two plans about the installer overlap before either touches a file.

+ Lists live workspaces and non-bot PRs. Compare intent, not files: plans can overlap before edits.

- - **An overlap:** name the other work and why it overlaps, then put [the overlap ask](../plan/references/new-workspace.md#ask-once) in the next question group, or alone when nothing else is open.

- - **No overlap:** say nothing about the check.

- - **A `notes` line:** say it in one line and go on.

+ - **Overlap:** name the work and why; add [the overlap ask](../plan/references/new-workspace.md#ask-once) to the next group, or ask alone.

+ - **No overlap:** say nothing.

+ - **A `notes` line:** say it in one line and continue.

- Skip it for work that changes no repo file, or that this conversation already checked.

+ Skip if checked here or no repo edits.

## The exit round

- When the work's shape is clear, put the open material decisions in a final group, [like every other ask](references/asking-the-user.md):

+ Resolve remaining material choices [the shared way](references/asking-the-user.md):

- - **Ask only what passes [the 80/20 test](#questions-during-standalone-exploration)**, no more questions per group than the tool supports.

- - **Several separate parts?** Ask whether to open a new workspace for each other part ([how](../plan/references/new-workspace.md#ask-once)).

- - **An answer opens another such choice?** Ask a follow-up group, not a guess; stop once none is open.

- - **Never re-ask a settled choice**, nested calls included; with nothing open, go to the summary.

- - **Fill minor gaps with supported assumptions and reasons.**

+ - Apply [80/20](#questions-during-standalone-exploration) and tool capacity; ask only ready choices.

+ - **Separate parts?** Ask about a new workspace for each ([how](../plan/references/new-workspace.md#ask-once)).

+ - **Answers open another choice?** Follow up; stop once none remains.

+ - Never repeat settled choices, nested calls included, except affected ones after changed premises.

+ - Keep unanswered material preferences open, never disguised as assumptions or evidence gaps. Preserve authorized defaults and [the fallback when nobody can answer](references/asking-the-user.md#which-tool-carries-it).

+ - Use supported minor assumptions with reasons. Evidence gaps may remain if an approach is coherent; otherwise name the prerequisite, never guess.

- This limits clarification, not action authorization or delivery gates. Then hand off:

+ Clarification limits preserve authorization and delivery gates. Summarize outcome, approach, reasons over a serious alternative, minor assumptions, and evidence limits; no extra sign-off.

- - **Bounded mode** returns to `/plan` by [the steps below](#when-plan-invokes-explore).

- - **Standalone**, summarize and end with [the next step](references/asking-the-user.md#end-every-reply-with-the-next-step). On *Plan it*, invoke `/plan`, whose bounded pass asks only what is still open; never start `/plan` without that answer.

+ - **Bounded:** return by [the steps below](#when-plan-invokes-explore).

+ - **Standalone:** [offer next steps](references/asking-the-user.md#end-every-reply-with-the-next-step). Only *Plan it* starts `/plan`; its bounded pass asks open choices.

## When `/plan` invokes `/explore`

- `/plan` runs this skill in **bounded mode** before drafting, even via `/apply` or `/ship`:

+ Planning uses **bounded mode**, including via `/apply` or `/ship`:

- 1. **Read the conversation** for the intent, the answers, and which choices are already settled.

- 2. **Search memory, [check for other work](#check-for-other-work) unless it already ran for this work, then investigate only the gap**, which may be empty. `/plan` does not search again.

- 3. **Run [the exit round](#the-exit-round) only for choices still open.** Resolve pending answers before dependent planning; when nobody can answer, use [the fallback](references/asking-the-user.md#which-tool-carries-it).

- 4. **Summarize** the answers and assumptions, then **return to `/plan`**.

+ 1. Reuse the conversation's intent, answers, and findings.

+ 2. Search memory and [other work](#check-for-other-work) unless checked; investigate only new material gaps. `/plan` never repeats searches.

+ 3. Run [the exit round](#the-exit-round) for open choices; await dependent answers, retaining authorized/unattended defaults.

+ 4. Return the summary to `/plan`.