explore

name	explore
description	Use when a substantive development request has meaningful solution uncertainty: trace real flows, compare genuinely different approaches, and choose a direction. Skip when the path is already clear.

Contextual selection

CoderKit is an optional helper framework, not a mandatory process. Self-select this workflow when the current request clearly matches its purpose and the added structure will materially improve a substantive development task. Never ask the user whether to activate CoderKit or whether to use CoderKit instead of normal host behavior: workflow selection is an internal execution decision, not a user decision.

Skip CoderKit for simple questions, routine commands, obvious one-line edits, or work whose outcome and path are already clear. Select only the smallest useful workflow; do not run the full explore → plan → implement → verify → commit sequence as ceremony. When no workflow adds enough value to justify its overhead, continue with normal host behavior.

Ask only when the outcome, scope, or required authority is materially unclear; never ask merely to choose or confirm a workflow. Automatic selection does not expand the user's authority or permit adjacent work.

Prompting envelope

Structure the work in this order:

• Outcome: state the result the user wants before choosing an approach.
• Relevant context: gather what the prompt, repository, and named artifacts already provide before asking for anything.
• Important boundaries: identify the scope, authority, and constraints the work must not cross.
• Work: execute against the outcome within those boundaries.
• Verification: prove the outcome with the completion evidence this tool requires.

Ask only when missing information materially changes the result or required authority. Accept steering without restarting the workflow.

Proportionality

Right-size the workflow to the task. Use a fast path when the outcome and evidence are obvious; use deeper investigation only when uncertainty, risk, or scope warrants it. Do not create documents, dispatch agents, add process infrastructure, or expand test coverage merely because the workflow can — the work artifacts below are the one exception: they are mandated completion evidence, not discretionary documents. Stop when the completion evidence is satisfied. A finished, verified result is better than a perfect process.

Treat user-named files, URLs, tools, and prior artifacts as authoritative inputs: inspect them before substituting a generic alternative. Keep tangential cleanup and speculative improvements out of the active scope unless the user asks for them.

Work artifacts

Persistent work products live in the target project under docs/work/NNN-short-name/: NNN is a zero-padded index allocated as the highest existing index plus one (starting at 000), and short-name is a kebab-case name derived from the request.

• plan.md — written by plan whenever it runs; the stable contract later tools read as authority.
• tasks.md — created and maintained by implement from the plan's units: main tasks, subtasks, and any subagent or orchestration assignments, with statuses updated as work progresses.
• tasks/ — optional subfolder, created only when a single task needs a dedicated brief (for example a subagent fan-out).

Explore produces no artifact. Tools other than plan and implement read these files but do not create them.

Completion

Finish with the evidence required by this tool. Select another CoderKit workflow only when it is genuinely needed and the user's existing request already authorizes that work; never chain the whole lifecycle by default. Otherwise stop and report the result or natural next step without asking the user to activate anything. Never turn workflow selection into a confirmation prompt, and never treat automatic selection as authorization for Git publication, deployment, destructive changes, or other adjacent work.

Explore

Method

1. Scope what the exploration must answer: the outcome the user wants and the decision it feeds. Separate the outcome from any proposed implementation.
2. Read repository instructions, project documentation, and user-named artifacts before implementation files. Ground everything in the actual subject, never in generic advice detached from it.
3. Trace the real flows end to end: entry points, callers, control and data paths, configuration, and external boundaries. Map the patterns, conventions, and utilities later work should reuse.
4. When the direction is open, generate genuinely different candidates before evaluating them. When the subject is broad, decompose it into a few non-overlapping surfaces derived from the evidence; skip both for a factual lookup.
5. Critique every candidate against the outcome, constraints, leverage, complexity, and risks. Reject weak or redundant candidates explicitly and briefly.
6. Present only the strongest two or three survivors with their meaningful trade-offs. Recommend one and explain the decisive reason.
7. Stay strictly read-only: no edits, no working-tree mutations, no dependency installs, no speculative fixes.
8. Stop when the question is answered or a direction can be chosen. Report remaining unknowns as unknowns instead of papering over them with plausible guesses.

Guardrails

• Repository evidence beats generic best practice; verify a claim by reading the code that implements it.
• More ideas are useful only when followed by real filtering.
• Findings and direction are a report, not a mandate: do not slide into requirements, planning, or implementation.

Completion evidence

Key files, traced flows, chosen direction or answer with trade-offs, and open unknowns.