| name | user-draft |
| description | Refine rough thoughts into a polished, ready-to-use artifact — either an improved prompt or a copy-pasteable /goal "<condition>". NL-detects which you want, runs a gaps→questions→polish pass, and checkpoints current state (task-handoff --loop) so a window pivot loses nothing. Invoke as /user-draft <your rough thoughts>. |
| user-invocable | true |
user-draft
Turn a rough idea into a finished artifact you can use immediately:
- prompt — a precise prompt/instruction for a model or agent
- goal — a copy-pasteable
/goal "<condition>" that keeps a session working until a checkable condition is met
One NL front door for both. user-draft figures out which you want, refines it through the same
discipline, and emits an artifact that self-orients the window you paste it into.
Deeper, eval-backed prompt-only audit lives in /review-prompt. user-draft is the fast everyday
front door; reach for /review-prompt when you want an exhaustive prompt critique.
Step 0 — detect intent (goal vs prompt)
Read the user's free-text thoughts and classify:
| Signal | → branch |
|---|
| "write/make a goal", "set a goal", "keep working until", "don't stop until", "objective", "until X is done", "/goal" | GOAL |
| "write/refine a prompt", "improve this", "make this clearer", "task for an agent", "ask the model to", "instruction" | PROMPT |
If no explicit keyword: classify by what the thought describes.
- Describes what "done" looks like (a stopping/completion state) → GOAL
- Describes what to do (an instruction/task) → PROMPT
If still genuinely ambiguous, ask exactly one disambiguating question — never guess silently,
never ask more than one. Then proceed.
Emit a one-line notice: user-draft: detected GOAL / user-draft: detected PROMPT so the user can correct.
Step 1 — checkpoint current state (cheap, gated)
The artifact you're about to produce may be pasted into a fresh window, where a stale
current.md would mis-orient it. So freshen it first — but only when there's real state
to preserve:
- If
<git-root>/.claude/task-state/current.md exists and represents active in-flight work
→ invoke task-handoff --loop (Skill tool). ~5s, local commit, no push.
- Else (fresh session, no active task, or nothing changed since last checkpoint)
→ skip silently. Do not write or commit a checkpoint for a clean slate.
This is the "do proper task-handoff activities before starting work" step. It is the only
thing that makes the baked preamble (Step 4) non-hollow — without a fresh checkpoint the
preamble points at stale state.
Step 2 — refine (shared flow)
Both branches run the same pass:
- Find the gaps. Ambiguities, missing constraints (format, scope, audience, edge cases),
assumed context, contradictions, weak verbs ("handle", "process", "deal with").
- Ask targeted questions. 3–5 focused questions, only the ones that meaningfully change the
output. Skip entirely if the input is already clear. Do not ask obvious questions.
- Polish per the branch below, after the user answers (or directly if no questions needed).
Preserve the user's voice and intent — refine, don't rewrite into a template.
Step 3a — PROMPT branch
Produce the improved prompt with:
- Concrete verbs replacing vague ones ("return" not "handle", "reject" not "deal with")
- Explicit constraints filled in from the answers (format, scope, audience)
- Scope boundary — what's in and out, stated explicitly
- One literal example pair — an actual input → actual output, not a description of one
- Negative examples where they prevent a known failure mode ("do NOT …")
Return the prompt in a fenced code block (see Step 4 for the preamble). Follow it with a 2–4 line
## Changes summary of what you tightened and why.
Step 3b — GOAL branch
Produce a /goal "<condition>" where the condition is a good stop criterion:
- Binary and checkable every turn by a fast model with tool access.
- Names concrete artifacts/criteria — "tests green", "PR #N merged", "file X exists",
"count == N", "
<cmd> exits 0". Not "the bot is better" or "code is clean" (unmeasurable →
the goal never resolves).
- Carries guardrails if the work needs them ("…without touching the public API").
Reject your own first draft if the condition isn't externally verifiable — rewrite until it is.
Return it in a copy block (see Step 4), then a one-line note on how the harness will check it.
Step 4 — bake a self-orienting preamble (gated)
Make the artifact orient whatever window it lands in — only if Step 1 actually checkpointed
active state. For a clean-slate draft, emit the bare artifact with no preamble (never tell a
fresh window to read a current.md that doesn't apply).
PROMPT branch — prepend one line inside the block:
Orient first: run /task-handoff --resume (reads .claude/task-state/current.md), then:
<the refined prompt>
GOAL branch — emit the resume line as a separate command above the goal (a slash command
can't carry a prose preamble), so the user runs them in order:
/task-handoff --resume
/goal "<condition>"
For same-window use the resume line is harmless to skip — note that inline.
Principles
- Shorter is better. Every line of the artifact earns its place.
- Specificity over generality. "return a JSON array" beats "return structured results";
"tests green and PR #196 merged" beats "the feature is done".
- Show, don't tell. A literal example beats a description of one.
- One artifact, one job. If the input bundles several asks, say so and offer to split.
- Never block. At most one disambiguation question (Step 0) or one round of refine questions
(Step 2). Otherwise make the best call and note it inline.
