Elicitation & enrichment engine for prompts, goals, and loops — a Claude Code plugin that takes a thin, under-developed draft and returns a complete, ready-to-use artifact, with every applied rule traceable to a cited research finding.
Enrichment is not generation from nothing: the draft's intent is never
redirected, only made specific and complete. Missing information is never
invented and never becomes a [PLACEHOLDER] — it is folded into the output as
a concise clarifying question (default), or resolved up front via
AskUserQuestion (--interactive).
This repo is both the plugin and its own marketplace — .claude-plugin/
carries a plugin.json and a marketplace.json side by side — so installing
straight from GitHub is one two-line step, no local checkout required:
/plugin marketplace add zircote/improver
/plugin install improver@improver
For local development against a working checkout instead:
claude --plugin-dir /path/to/improver| Skill | Input | Output |
|---|---|---|
improve-prompt |
rough prompt draft | XML-structured prompt (JSON Schema output contract when the consumer is a program) |
improve-goal |
vague goal draft | one measurable, transcript-verifiable completion condition, prefixed /goal , strictly under 4,000 chars |
improve-loop |
loosely-specified recurring task | bounded loop spec ready for /loop / /schedule; autonomous loops are hard-gated (sandbox + iteration cap + human checkpoint) |
grade-enrichment |
an enriched artifact (opt-in only) | per-rule graded report; LLM verdicts only trusted against the shipped calibration record, degrading gracefully when absent |
Every skill accepts --interactive to resolve detected gaps via
AskUserQuestion (batched, at most 4 questions per call) before synthesis.
Structured output is the default: emitted prompts carry explicit XML-tagged
sections; machine-parsed outputs get an explicit JSON Schema contract.
The full doc set lives under docs/ — start there for
navigation:
- Tutorial — install and run your first enrichment, end to end
- How-to guide — task recipes for every skill,
--interactive, pitfalls - Reference — exact skill contracts, rule-pack schema, budgets
- Explanation — why prompts, goals, and loops are enriched differently
- Changelog
- ADR-0001 — why rule packs are versioned data, not prose
The rules live in rules/*.json — one independently versioned pack per
artifact kind (prompt-rules.json, goal-rules.json, loop-rules.json).
Each rule carries the finding_refs it traces to, resolvable to full MIF
finding @ids and source URLs via rules/findings-index.json. Ask "why did
you add X?" after any enrichment and the answer is a citation, not a restated
heuristic. A rule with no citation is indistinguishable from an invented one,
so none exist.
Character/token budgets are inherited from each target surface (goal: 4,000
chars, /goal's own ceiling) and enforced by compressing before returning —
never emitting an artifact its own consumer would reject.
grade-enrichment is strictly opt-in; the improve skills never chain into it.
It selects a grader type (code-based, LLM, human) per the researched
tradeoffs. LLM verdicts are trusted only against
golden/calibration-record.json — a committed record of a real blind-judge
run over the 9 hand-reviewed golden cases in golden/ (current record:
9/9 agreement, threshold 0.75). If the record is ever missing or stale, the
skill degrades gracefully — verdicts marked UNCALIBRATED plus a
self-calibration offer against the shipped golden sets — and never blocks.
Each skill ships evals/evals.json (3-4 cases, ≥2 expectations each, with
deterministic checks for the mechanical properties: no placeholder tokens,
budget respected, loop bounds present). Runnable with any
evals.json-compatible runner (e.g. autoresearch).
Implements the Elicitation & Enrichment Engine architecture spec
(rule packs per artifact kind, shared classify → detect-gaps → elicit →
synthesize pipeline, opt-in calibrated grading). The single-turn
fold-gaps-into-output contract follows the proven /improve-prompt /
/goal-improver UX; --interactive implements the spec's normative
elicitation text directly. Grading rigor is deliberately opt-in, never a
mandatory pipeline or an install-blocking gate.
MIT © zircote