Pronounced TROH-ver-ee — a trovery is where troves are kept. Bakery, brewery, trovery.
Formerly Demigo. Renamed to Trovery in 2026 — the old name's most legible morpheme (demi-, "half") worked against a toolkit whose entire claim is completeness. Existing links and clone URLs still resolve.
An AI-assisted workflow that helps you make decisions — and documents them as you go.
Templates are a monologue. Trovery is a dialogue.
You and the model work together — you steer, the model interviews you, and every choice you make is captured as a durable decision record: the context you were in, the options you weighed, what you chose, and why. That record is the point. It's documentation both future-you and the AI can look back on — so nobody has to reconstruct the reasoning three weeks, or three sessions, later. A chat window forgets. Trovery writes it down.
The atomic unit isn't a document you maintain; it's a decision you record once. Everything else — PRDs, Roadmaps, SADs, Delivery Plans, study guides — is a generated view computed on demand from the current set of active decisions.
There are no approval gates. There are no status workflows. Conversation → confirm → commit → done. If a decision turns out wrong, you supersede it. If a phase turns out wrong, the retro routes you back to redo it. The framework trusts you to know when to revisit.
Trovery is the decide half of a pair. The build + govern half is trovery-tools — the Go platform: trove forge (build agents & MCP servers) and trove vigil (govern AI-assisted work).
Two commands stand on their own, outside the PRD/roadmap workflow:
/trove:skill-forge— a convergent interview pins one autonomous agent to six facets (trigger · task · tools · guardrails · fail-safe · output) and emits a self-contained, agent-invocableSKILL.md+ decision trail to hand off. Custom-agent authoring, not doc generation./trove:onboard— point it at an existing codebase; it reverse-engineers evidence-cited ADRs plus a contributor onboarding guide. Trovery's brownfield on-ramp.
The substance of the framework is the Markdown in
prompts/. The JS/CSS inrenderer/is just an optional HTML viewer — don't let GitHub's language bar mislead you.
- A supported AI coding harness — Claude Code, Gemini CLI, Cursor, Codex CLI, or GitHub Copilot. Trovery installs as slash commands in any of them; see Install (other tools).
git— to clone and to version your decision files.pandoc+node— optional, only for the HTML renderer (/trove:render). Everything else works in plain Markdown without them.brew install pandoc node # macOS; use your package manager elsewhere
git clone https://github.com/ceasarb/trovery.git ~/Developer/trovery
cd ~/Developer/trovery
./install.shSymlinks all Trovery prompts into ~/.claude/commands/trove/. Restart Claude Code; commands are live as /trove:<name> everywhere.
Options:
./install.sh --copy— copy files instead of symlinking./install.sh --uninstall— remove~/.claude/commands/trove/
Trovery is harness-agnostic. The prompts/ markdown is the single source of truth; one emitter carries it to every supported target.
node adapters/emit.mjs --list # show every target profile
node adapters/emit.mjs --target cursor # emit for one target
node adapters/emit.mjs --target gemini-cli --dry-run| Target | Installs to | Invoke as | Live edits? |
|---|---|---|---|
| Claude Code | ~/.claude/commands/trove/ |
/trove:brainstorm |
✅ symlinked |
| Gemini CLI | ~/.gemini/commands/trove/ |
/trove:brainstorm |
❌ re-run |
| Cursor | ~/.cursor/commands/ |
/trove-brainstorm |
❌ re-run |
| Codex CLI | ~/.codex/prompts/ |
/trove-brainstorm |
✅ symlinked |
| GitHub Copilot | .github/prompts/ |
/trove-brainstorm |
✅ symlinked |
Why some update live and some don't. Where a target reads Trovery's own format, the emitter symlinks — editing a prompt changes the command instantly. Where a target needs a different format (Gemini CLI stores prompts inside TOML; Cursor inlines the file without frontmatter), files are generated, so changes need another run.
Why two invocation styles. Claude Code and Gemini CLI namespace by directory, so commands land under trove:. Cursor, Codex and Copilot read one flat directory, so the namespace moves into the filename.
Adding a harness is a profile entry in adapters/emit.mjs, not a new directory. Contributions welcome.
Codex note: custom prompts still work but are deprecated upstream in favour of skills.
1. /trove:scaffold # once per project — creates .claude/docs/{decisions,views,retros,discovery,design-refs}/
2. /trove:brainstorm # have a conversation; the model drives Q&A; decisions commit as files
3. /trove:plan phase-1 # break the captured decisions into 5–25 min tasks
4. build the thing
5. /trove:maintain # comb the repo for drift; every proposed change cites its decision
6. /trove:retro # capture learnings, decide what's next
For client work with existing material: replace step 2 with /trove:discovery <notes-file>.
Step 5 needs /trove:maintain --init once, to establish the conventions it enforces — see Keep the repo consistent.
| Command | Purpose |
|---|---|
/trove:scaffold |
Create .claude/docs/{decisions,views,retros,discovery,design-refs}/ + project CLAUDE.md. Once per project. |
All top-of-funnel commands drive a conversation, draft PDRs/ADRs inline, and ask "commit? (y / edit / drop)". The interview script is what differs.
| Command | When to use |
|---|---|
/trove:brainstorm |
Self-directed work. You arrive with an idea. Model drives product Q&A then tech Q&A. |
/trove:discovery |
Client work. You arrive with material. Raw preserved verbatim; conflicts/ambiguities/unstated gaps surfaced. |
/trove:design |
Visual refinement phase. Reference-first interview (admired apps, anti-references), then structural design decisions. |
/trove:decide-product |
Focused PDR interview. Direct invocation or called inline. |
/trove:decide-tech |
Focused ADR interview. Direct invocation or called inline. |
/trove:refine <ID> |
Iterate on an existing decision. In-place if unshipped; supersede if shipped. |
/trove:onboard |
Existing codebase. Reverse-engineer it into evidence-cited ADRs + a contributor onboarding guide. Trovery's brownfield on-ramp. |
Views are always regenerated, never hand-edited.
| Command | Produces |
|---|---|
/trove:rollup prd <phase> |
PRD view from PDRs tagged with the phase |
/trove:rollup roadmap |
Roadmap view from sequencing PDRs + phase tags |
/trove:rollup sad |
Solution Architecture view from active ADRs |
/trove:rollup study-guide <topic> |
Aggregated HTML study guide from concepts (for exam prep) |
/trove:plan <phase> |
CRAWL/WALK/RUN delivery plan; 5–25 min tasks with energy tags; first WALK task is deploy |
| Command | Produces |
|---|---|
/trove:render |
A navigable static HTML site from a project's .claude/docs/ (decisions, generated views, onboarding guide). Local, static, read-only; Mermaid diagrams render offline. |
| Command | Produces |
|---|---|
/trove:skill-forge |
A bespoke, agent-invocable skill bundle. A convergent interview pins one autonomous agent to six facets (trigger · task · tools · guardrails · fail-safe · output) and emits a self-contained SKILL.md + decision trail to hand off. Trovery's engine aimed at authoring agents — not distributing Trovery itself. |
AI-assisted repos drift: each session makes locally reasonable structural choices, and nothing arbitrates between them. These commands make the arbiter explicit.
| Command | Purpose |
|---|---|
/trove:maintain --init |
Establish. Surveys the repo, makes you resolve competing layouts, and writes convention records — layout rules, naming patterns, and tool pins carrying a vendored docs snapshot. Run once. |
/trove:maintain |
Enforce. Combs the repo against those records and proposes a plan where every item cites the decision behind it. Applies nothing until you approve; never invents a convention it wasn't given. |
| Command | Purpose |
|---|---|
/trove:retro <phase> |
3-question retro. Proposes supersede/consolidate/deprecate actions on decisions. Names the next move. |
After /trove:scaffold in a project:
.claude/docs/
├── decisions/ # PDRs (product) and ADRs (technical). The source of truth.
├── views/ # Generated PRDs, Roadmaps, SADs, Delivery Plans. Do not edit.
├── retros/ # End-of-phase retros.
├── discovery/ # Raw client material (verbatim) + open-questions.md
├── design-refs/ # Visual references — admired apps, screenshots, notes
└── snapshots/ # Vendored docs snapshots backing /trove:maintain tool pins
snapshots/ appears only once /trove:maintain --init has captured a tool pin. Everything else is created by /trove:scaffold.
Decisions are atoms. Every meaningful piece of thinking is a decision — a choice between alternatives with consequences. PDRs and ADRs capture decisions. Same shape (Context → Options → Choice → Consequences); different interview scripts. That captured shape is the documentation — a durable record you and the AI read back to remember why a path was taken, long after the conversation has scrolled away.
Views are derived, never authored. PRDs, Roadmaps, SADs, and Delivery Plans are read-only outputs computed from the current state of active decisions. To change a view, change the decisions and re-run /trove:rollup or /trove:plan.
The lifecycle rule. Before code ships against a decision, in-place edit. After code ships, meaningful changes create a NEW decision that supersedes the old one. Old file stays in the repo as history.
Self-filter at draft time. Before drafting any decision, the model asks itself: "Is this a real decision, or a preference / fact / minor detail?" If there's no real alternative, no meaningful consequence, or it's reversible in under an hour — the model says so and suggests inlining as a code comment instead.
References ≠ decisions. discovery/ and design-refs/ hold raw material — client notes, admired apps, screenshots. These are working inputs, freely appendable and deletable. Decisions extracted from them cite the source file/quote in their Context section.
No gates, anywhere. No /approve, no /status, no /whats-stale. Every command is conversation → commit → done.
/trove:scaffold (once per project)
│
┌───────────────┼───────────────┐
▼ ▼ ▼
brainstorm discovery design ← top-of-funnel (pick one)
│ │ │
│ (handoff to decide-* inline as decisions surface)
▼ ▼ ▼
decide-product / decide-tech ← commit decisions
│
▼
refine (when you change your mind)
│
┌───────────────┼───────────────┐
▼ ▼
rollup (PRD/Roadmap/SAD) plan (CRAWL/WALK/RUN) ← derived views
│
▼
build the thing
│
▼
maintain ← comb for drift; every change cites its decision
│
▼
retro
│
decide what's next
/trove:maintain sits between building and the retro because that's when drift has accumulated and is still cheap to undo. It needs /trove:maintain --init once first — it enforces conventions you gave it and never invents its own.
Trovery evolved out of a 12-artifact gated framework where the gates themselves became the paralysis trap. Strip the gates, collapse the artifacts into atoms, let the conversation do the structuring work. Every design decision in Trovery falls out of that:
- Trust over gates — the model asks confirmation, not permission.
- Decide, then document — every choice is written down once as a record of the why, not just the what. The paperwork is a byproduct of thinking, not a separate chore.
- A shared memory for human and AI — the same decision records orient future-you and keep the model consistent across sessions. Nobody re-derives what was already settled, and nobody silently contradicts it.
- Conversation over templates — templates are passive; interviews are active.
- Derived over authored — views (PRDs, Roadmaps, plans) are regenerated from decisions, never hand-maintained.
- Reversibility scales the ceremony — cheap decisions get lightweight capture; expensive ones warrant a full record.
See docs/methodology.md for a longer treatment.
| Symptom | Fix |
|---|---|
/trove:* commands don't appear |
Restart Claude Code after ./install.sh — commands load at startup. Confirm the install with ls ~/.claude/commands/trove/. |
| Commands appear but the model doesn't "drive" | Invoke the command on its own line (e.g. type /trove:brainstorm and send) rather than embedding it in a longer message. |
/trove:render produces no HTML |
Install the renderer deps: brew install pandoc node. Everything else works without them. |
| Want it out of the way | ./install.sh --uninstall removes ~/.claude/commands/trove/. Your project .claude/docs/ decisions are untouched. |
trovery/
├── prompts/ # source-of-truth markdown (the actual framework)
├── adapters/
│ ├── emit.mjs # the emitter — one source, five target profiles
│ ├── emit.test.mjs # round-trip, escaping, and lint tests
│ ├── claude-code/ # bash installer (being replaced by the emitter)
│ └── skill/ # project a Trovery prompt into a Claude Code SKILL.md
├── renderer/ # MD→HTML renderer (needs pandoc + node)
│ ├── build-docs.mjs # project-docs builder (/trove:render)
│ ├── lib.mjs # shared rendering helpers
│ ├── template.html # page shell (sidebar nav + on-this-page TOC)
│ ├── style.css # stylesheet
│ └── mermaid.min.js # vendored client-side Mermaid (offline diagrams)
├── docs/
│ └── methodology.md # long-form on the philosophy
├── install.sh # convenience wrapper → adapters/claude-code/install.sh
├── LICENSE # MIT
└── README.md # you are here
The prompts/ directory is the framework. The adapters are distribution mechanisms — each translates the prompts into a form the target tool understands.
The prompts/ markdown is the framework. Improvements to the interview scripts, better self-filter heuristics, or new command types all belong there.
New harnesses are a profile entry in adapters/emit.mjs — output path, extension, field mapping, naming, emission class, escaping, and any reserved sequences. If a target needs changes to the emitter itself rather than a config entry, that is worth discussing first: the abstraction is meant to hold.
Open issues and PRs welcome.
MIT. See LICENSE.