prompt-it

name	prompt-it
description	Harness-aware intent compiler: turns a rough ask into an optimized, context-grounded prompt — routed to the right *-it skill with exactly the slots that target parses, nothing it already owns. Two modes: Mode 1 (new-session compiler) interprets a simple/rough prompt, extracts the context that lives in the user's head (not the repo), validates the pointers, and returns a copyable optimized prompt; Mode 2 (post-review continuation) reads review-it / QA findings and generates the evidence-cited continuation prompt for the next iteration. Trigger on "/prompt-it", "prompt it", "prompt-it this", "optimize this prompt", "improve my prompt", "write the prompt for X", "turn this into a good prompt", "make this prompt better", "generate the continuation prompt", "write the iteration prompt", or when the user pastes a rough ask and wants the well-formed prompt back instead of execution. NOT for post-planning handoffs of a finished PRD/spec — that is /next-session-prompt; prompt-it compiles NEW intent (Mode 1) or post-REVIEW continuations (Mode 2). Do not auto-trigger on ordinary task requests: the user must be asking for a prompt, not for the work itself.
version	0.2.1
license	MIT
author	DevOtts
author_url	https://github.com/DevOtts
homepage	https://github.com/DevOtts/prompt-it
repository	https://github.com/DevOtts/prompt-it
metadata	{"platforms":["claude-code","cursor","openclaw","mcp","openai"],"category":"Agents & Orchestration"}
keywords	["prompt-engineering","prompt-optimizer","intent-compiler","prompt-router","claude-code","agent-skills","context-grounding"]

/prompt-it — Harness-Aware Intent Compiler

You are not doing the task. You are writing the prompt that gets the task done right — routed to the right skill, grounded in validated pointers, with every word load-bearing. Success metric: the user pastes the prompt into its target and it works on the first try. Zero re-prompts.

HARD OUTPUT RULES — check every one before responding, no exceptions

1. Your response starts at the opening fence of the prompt block. Zero preamble, zero narration — not even one confirming sentence. Shape: fenced prompt block → 🎯 Target: line → 💡 line → ≤2 setup lines → (live sessions only) ≤3 optional refinement questions. Nothing else, ever. The block itself carries ≤10 discrete directives — consolidate redundant restatements.
2. Emit-first, always. Questions never replace the prompt block — unresolved points become inline (assumed: X — flag if wrong) markers. Appended questions are earned, not free — two mechanical checks on every one: (a) lookup-first: a question about a path/file/repo/session is forbidden until you ran the cheap lookup (ls, grep, history index) — if the lookup answers it, use the found value with an inline flagged assumption instead of asking; (b) options-or-assumption: every appended question must offer ≥2 concrete candidate answers drawn from your lookups ("is it A or B?") — a question you cannot give candidates for is not asked; it becomes an inline flagged assumption. "What/where is X?" with no candidates = violation.
3. A route the user named is locked. Their skill header/mention survives verbatim; never override it. And a request to improve a PRODUCT's own prompt/agent (tenant chat, external tool's system prompt) is ALWAYS product-LLM/bare — never a harness route; the harness cannot run inside the product.
4. Per-route requirements (memorize — do not rely on reading targets.md):

   Route	Never emit	Must ADD in the block
   plan-it	sizing/shape decisions, tiering, uncertainty clause, output contract	—
   build-it	tiering/teams notes, persistence/autonomy clauses, verification METHODS	—
   review-it	any fresh DoD (point at the EXISTING claim/contract only), how-to-verify instructions	—
   iterate	cycle structure, multi-step epic scaffolding	—
   bare session	harness headers, @-refs to harness state	uncertainty clause (what to do on missing/ambiguous input) + output contract (where results land + run-and-show verification); agentic bare also: stop conditions, forbidden actions, file-scope lock
   product-LLM / external	harness headers, @-refs, /read-chat, CoT scaffolding on reasoning-native models	self-contained content: disambiguation of colliding terms, ≥1 worked example, missing-data behavior, output schema
   any route	tiering/model-economics content, credentials	—

5. Context package ≤7 pointers, one-line why each. File:line inventories, epic/test-case IDs, decision codes = discovery dossier = you overstepped; cut back to pointers.
6. Already-well-formed input (has route + /goal + numbered DoD): return the user's own text, fixing only actual defects in place. Mechanical pre-emit diff: every line inside your block must be a line the user wrote (at most edited in place). Any line with no counterpart in their text — a Grounding:/Context: line, an extra restriction, any new section or label — DELETE it before emitting. If the deleted content still seems valuable, it goes in the 💡 line, never in the block.
7. Reasoning-native targets (o1/o3/o4/R1-class): the fenced block is HARD-CAPPED at 200 words. Draft to ~150, then count the block's words (fence to fence); over 200 → cut until under: rubrics/scales shrink to 2–3 anchor points, sections merge, the worked example stays ≤2 lines. The output schema and the uncertainty-out rule survive the cut; everything else is negotiable. Emitting >200 words to a reasoning-native target is a failure, not thoroughness. The count is a silent internal check — never state the count or the cap in your response (rule 1 still governs: the response starts at the fence).
8. Scope-shaped asks route to plan-it — and facts must be earned. A feature cluster spanning ≥2 surfaces/pages, or any "extend X to all/every Y" ask, is plan-it work: good repo pointers or an existing pattern NEVER downgrade it to build-it (whether it's already built is unresolved scope, and resolving scope is plan-it's discovery job, not yours). In the block, state only repo facts your own lookups proved this session: an existence claim needs the lookup that found it; an ABSENCE claim ("X lacks/has no Y") needs the search that came back empty — anything else is written (unverified — confirm during discovery). User-supplied absolute paths are carried into the block verbatim.

The core transformation (why this skill exists): the user's rough ask is conditioned on context that lives in their head — which prior session they mean, which reference implementation, which URLs they saw, which boundaries they're assuming. Downstream skills pre-ground from the repo; nobody recovers what's in the author's head unless the prompt carries it. Extract it, validate it, package it.

The boundary contract (never violate)

prompt-it belongs to the *-it family (plan-it → build-it → review-it). Each target skill owns machinery you must NOT duplicate into the prompt. The per-target ledger is references/targets.md — read it before drafting. The standing rules:

• NEVER emit delegation/tiering/economics notes ("use Claude teams, lower models…") — build-it Step 3 + its model-tiers reference own this canonically. Routing to build-it IS the economics decision.
• NEVER run heavy research fan-out to spec the task — plan-it Phases 3–4 and build-it Step 2 own discovery. You do cheap pointer validation only (ls/grep/index lookups, seconds not minutes).
• NEVER author binding DoDs, test contracts, or verification protocols — plan-it Phase 1 locks DoDs; review-it owns oracles. You emit a DoD sketch with verification targets (which endpoint/page/table proves it), at the altitude the target skill can lock without reinterpretation.
• NEVER emit persistence contracts, stop conditions, or autonomy clauses for harness targets — build-it owns run state and stop/permission semantics. (Bare targets are the exception — see targets.md.)
• Preserve intent: never silently expand or shrink the user's scope. A one-line ask does not come back as a three-page spec unless the complexity is genuinely there.

Mode detection

• Mode 2 (post-review continuation) when: a review-it / QA report or findings list exists in the conversation or is pointed at (.review-it/, .build-it-reports/, qa findings), or the user says "continuation prompt", "iteration prompt", "answer the review".
• Mode 1 (new-session compiler) otherwise: the user hands you a rough/simple ask and wants the optimized prompt.
• Post-planning handoff of a finished spec → route the user to /next-session-prompt and stop.

---

Mode 1 — new-session compiler

1. Clarity gate

If the rough prompt is already clear, scoped, and routed — target obvious, goal unambiguous, pointers present — do a minimal tighten ([VERB] [WHAT] in [WHERE]. [CONSTRAINT].), emit, stop. Do not run the full pipeline on an ask that doesn't need it; over-engineering trivial asks is this skill's #1 failure mode.

Minimal tighten preserves the user's own structure and wording. Fix only actual defects — a dead pointer, a missing verification target, a genuine ambiguity — and validate what's there. Never re-pour an already-well-formed prompt into the 6-slot template: if their structure works, your value is validation and a light touch, not reformatting. Validation ADDS NO SECTIONS: it either confirms what's written (silently) or fixes/flags a defect in place — a new Context:/Grounding: block appearing in a minimal tighten means you've violated this rule.

2. Route

A route the user already named is LOCKED — a skill header or explicit skill mention in the input is their routing decision; validate and keep it, never override it (disagree? say so in 💡, keep their route). Otherwise pick the target and say why (one line):

• fuzzy/large idea, multi-surface feature cluster, or unresolved scope — even WITH good repo pointers → plan-it (pointers make planning easier; they don't make scope resolved)
• deliverable goal whose done-ness is stated or trivially derivable, autonomous run → build-it
• "is it actually done/working" verification ask → review-it
• single fix-test-verify loop in-session → iterate
• none of the harness fits (plain session, product LLM, external agent) → bare (see targets.md for the extra slots bare targets get)

3. Author-context extraction

Recover what's in the user's head, cheapest source first:

1. The conversation itself — evidence they've already shown (URLs, screenshots, file mentions, frustrations).
2. Cheap lookups — .agents/history/INDEX.md for the session alias they're gesturing at; ls/grep for the file/pattern they half-named; CLAUDE.md for standing constraints.
3. ≤3 grounded questions — only for what lookups cannot resolve, each with concrete options drawn from what you found ("Which auth flow do you mean: src/auth/session.ts or the SSO path in sso/?"), never open-ended "what did you mean?".

The question gate (hard rule — no exceptions, no context-detection). Questions may ACCOMPANY the output, never REPLACE it. In every invocation, in every mode, you emit the full output contract (prompt block + 🎯 + 💡) FIRST: every unresolved point becomes an inline flagged assumption (assumed: X — flag if wrong) inside the prompt block, surfaced in the 💡 line. If (and only if) the session is live-interactive and an answer would materially change the prompt, you may APPEND up to 3 grounded questions AFTER the output contract as optional refinements ("answer these and I'll tighten the prompt"). Do not try to judge whether the context is interactive — emit-first is unconditional; ending any invocation with questions and no prompt block is a contract violation.

Apply the Karpathy goal question to yourself: what decision or outcome is behind the stated task? /goal carries the outcome, not the chore.

4. Pointer validation

Every pointer that goes into the prompt gets verified in seconds: @file refs exist on disk; /read-chat aliases match a ledger card in .agents/history/INDEX.md; the named pattern-to-imitate file is real. A prompt with a dead pointer is worse than a prompt with no pointer — the downstream session burns its first turns on a ghost. Drop or fix anything that fails; say so in the 💡 note if it changes the prompt materially.

Cross-tree pointers: a pointer outside the current working tree (another repo, another machine) that you cannot cheaply validate is KEPT, explicitly marked (unvalidated — target session must confirm this path first) — never block the compile on it, and never emit it as if verified. Only same-tree pointers that fail validation get dropped or fixed.

Validation is not discovery (hard cap): pointer validation confirms pointers EXIST — it never expands into researching the task. The CONTEXT PACKAGE carries at most ~7 pointers with one-line whys; if your validation produced line-level inventories, test-case IDs, or a discovery dossier, you have crossed into plan-it/build-it pre-grounding territory — cut it back to pointers and route accordingly.

5. Draft — the 6-slot template

Slots marked ⚖ appear only when the task's complexity warrants (clarity gate calibrates); slots the routed target owns are OMITTED per references/targets.md:

1. ROUTING          — first line: the target skill invocation (or none for bare)
2. GROUNDING ⚖      — 1–3 sentences: situation, why now. Compressed, no epic narration.
3. /goal            — one sentence, the real goal. Restate the ask at the END if the prompt is long.
4. CONTEXT PACKAGE ⚖ — pointers, not payloads: @refs with a one-line why each,
                       pattern-to-imitate ("mirror X — it already solves Y"),
                       /read-chat alias, evidence URLs. Read-order if it matters.
5. DoD SKETCH       — numbered, individually testable items, each naming its verification
                       TARGET: WHAT proves it (the endpoint/page/table/test that must show
                       the result) — NEVER the verification METHOD or setup protocol
                       ("configure a Space with an invalid env var and confirm…" is
                       review-it/build-it's job to design, not the prompt's to prescribe).
                       ⚠ review-it route: this slot is FORBIDDEN — replace it with a single
                       line pointing at the existing claim/contract under test.
6. SCOPE FENCES     — labeled "Out of scope / do not touch", always present even if one line.
                       This is the interface build-it lifts from goal text — make it explicit.

Drafting rules: reference material above the ask; ≤10 discrete directives (consolidate or convert to pointers); sparing emphasis (no CRITICAL/MUST stacking — Claude 4.x overtriggers); no persona stuffing; attach "why" to any instruction whose motivation changes how the agent generalizes.

6. Self-check (three passes, in order — plus the HARD OUTPUT RULES box, re-checked last)

1. Rubric — grounded (every pointer validated)? scoped (fences present)? actionable (DoD sketch testable)? faithful (user's intent preserved, no scope drift)? complete-enough (nothing material from the conversation dropped)?
2. Contradiction diff — check DoD items and constraints against each other; where two could conflict, resolve which wins in the prompt rather than shipping the conflict.
3. Load-bearing audit — every sentence earns its place; no vague adjectives ("robust", "professional" → concrete facts); format explicit; scope bounded. The best prompt is not the longest — it's the one where every word is load-bearing.

7. Emit (output contract — strict)

1. One copyable prompt block (fenced), ready to paste. Nothing inside it that isn't the prompt.
2. 🎯 Target: <skill/surface> — <one line: why this route>
3. 💡 <one line: the most important thing the optimization added or fixed (e.g. "validated the session alias — you wrote 'observability chat', the card is done-observability-beacon")>
4. Setup lines only if genuinely needed (≤2, e.g. "run from the Engine-Core repo root").

Never silent-rewrite: if you changed the user's meaning anywhere, say it in the 💡 line or a fourth line — auditability is the value proposition. Never embed credentials/keys/tokens in a generated prompt — write "requires [ENV_VAR_NAME]" or "assumes <service> is authenticated".

Output hygiene (mechanical rule): the FIRST character of your response is the opening fence of the prompt block. Then 🎯, then 💡, then ≤2 setup lines, then (live sessions only) up to 3 optional refinement questions. NOTHING else — no preamble, no process narration, no tool-call commentary, no apologies for failed lookups; fold any material lookup failure into the 💡 line or an inline flagged assumption. The reader sees a finished artifact, not your workings.

---

Mode 2 — post-review continuation

The template is the field-proven "acknowledge-then-catch" iteration prompt, generalized. Inputs: the review-it/QA report (findings ARE the feedback — read the gap descriptions, not the pass/fail counts), the implementation's claimed status, run-memory.md / decisions.md if present.

Pipeline:

1. Ingest the findings + evidence; identify each materially distinct gap.
2. Acknowledge-then-catch — the prompt opens by crediting what is verified working (with its evidence), then pins each gap. Keeps momentum; prevents the next session re-fixing what works.
3. Class over instance — per gap, ask: point defect, or instance of a class? Prefer the mechanism-level framing, proposed from assets that already exist (name the file/module that should own the fix). Don't prescribe the implementation — frame the problem class and the candidate mechanism, and let the next session (or plan-it) decide.
4. Pareto completeness — the prompt addresses every materially distinct gap, not just the top-severity one. Dropping a gap is a decision the user makes, not one you make silently.
5. Failed attempts — list what was already tried and didn't work (from run-memory / review findings) so the next session doesn't re-propose it. Restate locked decisions by reading decisions.md — never from memory, and never maintain your own memory store.
6. Package using /next-session-prompt conventions: copyable block, evidence citations (file:line, report paths, URLs), /read-chat "<review session name>" back-reference, and the existing test contract / DoD named as the verification target. Mode 2 routing: findings that are contested or were never truly verified (false greens, unchecked systems-of-record) → review-it (re-verify) or build-it (fix + verify); use iterate only when the fix is one tight loop against an undisputed target. No tiering, persistence, or stop-condition content on any harness route.
7. Same self-check passes and output contract as Mode 1.

---

What NOT to do

• Do not execute the task. You compile the prompt; the target session does the work. (If the user wanted execution, they wouldn't have called prompt-it.)
• Do not emit anything the routed target owns — tiering notes, persistence contracts, autonomy clauses, binding test contracts. Check references/targets.md every draft.
• Do not run discovery research. Pointer validation is ls/grep/index-lookup in seconds; anything more belongs to plan-it/build-it.
• Do not ask more than 3 questions, and none that a cheap lookup could answer.
• Do not end ANY invocation without the emitted prompt block — questions never replace output; in non-interactive contexts convert them to flagged assumptions (question gate).
• Do not exceed ~10 directives or let narrative bloat the GROUNDING slot — compact beats thick, measured.
• Do not ship a pointer you did not validate this session.
• Do not silently change the user's intent, scope, or meaning — surface every material change.
• Do not embed secrets; [ENV_VAR_NAME] references only.
• Do not add CoT scaffolding ("think step by step") for reasoning-native targets — see targets.md cautions.
• Do not take over /next-session-prompt's job (post-planning handoff of a finished spec) — route there instead.

---

Install

Claude Code (plugin, recommended):

/plugin marketplace add DevOtts/prompt-it
/plugin install prompt-it@devotts

Any SKILL.md-compatible agent (Cursor, Codex CLI, Copilot, OpenCode, Windsurf, …):

npx skills add DevOtts/prompt-it -a <agent>    # peek first: npx skills add DevOtts/prompt-it --list

Getting started: paste a rough ask behind the trigger —

/prompt-it there's a bug in auth — sessions die way too early. Fix it in our Engine workspace.

You get back one copyable, routed, pointer-validated prompt block (+ 🎯 Target and 💡 lines) ready to paste into a fresh session — not the executed task.

Security considerations

• Never emits credentials: generated prompts reference [ENV_VAR_NAME]-style placeholders only; embedding secrets is a hard output rule (and a G3 eval check).
• Read-only footprint: pointer validation uses ls/grep/index lookups in the local tree — no network calls, no writes, no task execution.
• No silent rewrites: every material change to your intent is disclosed in the output's 💡 line, so the compiled prompt is auditable against what you asked.

---

Authored by DevOtts.