How to
Install once. Invoke. Review before you merge.
The knowledge base is plain-text Markdown. Edit it by hand or drive it with a skill — both are first-class. Whatever you touch, the same gate runs before every merge.
Get started
From an empty repo to a governed project.
INSPIRE is harness- and model-agnostic by design. Today the runtime ships as a Claude Code plugin: install it once per machine, then materialize it into each project.
# 1 · once per machine
/plugin marketplace add Genomcore/inspire
/plugin install inspire@inspire
/reload-plugins
# 2 · in the repo you want to govern
/inspire:init
# 3 · pick up the skills, set up the foundation
/reload-skills
/inspire-bootstrap init
/inspire:init writes into your repo
.claude/skills/inspire-*the twenty-one skills.inspire/bin/the validators.claude/inspire/hooks/session and git hooksinspire_kb/the knowledge base skeleton.inspire/visor/the visor's settings.inspire.lockwhich release you installed
It never rewrites your git history or overwrites existing content. Commit the result: from then on the runtime lives in git, and teammates and CI need nothing installed. /inspire:update upgrades to a newer release, keeps your edits and offers to bring .inspire/emanate.yml up to date. When a release changes the knowledge base's layout or how its files link, /inspire:migrate converts it once, when you choose to. /inspire:visor serves inspire_kb/ as a local site, with search, backlinks and a graph coloured by unit kind, and writes nothing in it.
How it works
Shape the knowledge base by hand or with a skill.
Everything a skill produces is plain-text Markdown under inspire_kb/. Both paths end in the same files and pass the same review.
By hand
Edit the files directly
Open any file in inspire_kb/ and write. The layout is designed for people: follow the conventions in each folder's README and your change passes review. A small edit never needs an agent.
With an agent
Drive it with a skill
Invoke an /inspire-* skill. It interviews you, writes the artifact in the right place, checks each file it writes, and carries the change to everything that depends on it: features, screens, domain, processes, prototype and decisions.
Reviews are read-only. A skill's review reports findings and recommends the next command. It never applies changes: landing the fix is always the author's call.
Or simply
Just chat.
After /inspire:init, the project's CLAUDE.md or AGENTS.md is loaded into every session, and the agent invokes the relevant skills on its own. You don't need to remember a single command: say what you want, and the agent picks the skill, asks what it needs to know and writes the artifacts in the right place.
Appointments need a cancellation reason.
/inspire-feature updateUpdating the use case Cancel an appointment. Should the reason be required, or optional?
Required, from a fixed list.
/inspire-domain updateAdding reason to the cancel action, then the screen…
Let the agent manage the concepts
- Ask for what you want. The agent works out which concepts the request touches (feature, domain, screens, decisions) and fills the gaps in each.
- What it can't close now becomes a ticket. Pending work lands in
99_tracker, linked to what it belongs to, instead of being forgotten. - Now and then, ask it to review what's pending. It closes the mechanical tickets and the ones that have gone stale, and tells you what still needs your judgment.
No external task manager needed: the backlog lives next to the specification, in git.
Keep sessions short and focused. Every turn adds to the agent's context, and a saturated context makes worse decisions. One session should deliver one change you can chew: small enough to evaluate, review and merge. A session that burns millions of tokens without opening a pull request has lost the thread — close it, and start the next one from the knowledge graph, where nothing was lost.
The loop
Specify, review, build. Repeat.
Installing happens once. After that, every change goes around the same three moves. The review is the gate before any pull request that touches inspire_kb/, and the factory builds only what that review let through.
Install
Plugin, /inspire:init, bootstrap, /inspire-config.
Specify
Invoke a skill; it asks wherever judgment is needed.
/inspire-feature create billing/INV-01
Review
One module, or the whole workspace for cross-cutting work.
/inspire-workspace review
Build
The factory builds what is accepted. You review one pull request.
run-sandbox.sh <project>
next change
Robust
Coherence is checked at git-time.
The skills are the judgment half. The mechanical half runs in git hooks, so drift is caught even when no one remembers to look.
Your change
by hand or by a skill
pre-commit
checks the modules you staged
Commit
post-commit reviews the knowledge files it contains
pre-pr
re-runs the review over the whole tree
Pull request
only with no hard errors
Validators
Bash, yq and jq checks in .inspire/bin/, no Node toolchain. They enforce unique ids, acyclic dependencies, stable-blocker invariants, entity lifecycle, cross-field coherence, what each face may call, the shape of every process and that every link points to a file that exists.
Provenance, not a gate
trust.sh lives beside them. It stamps which skill wrote each artifact and reports it, but never blocks a review.
--no-verify
If a hook fails, find the root cause. Bypassing the gate is never the answer.
How prose is written
A knowledge base is read twice.
Once by a person deciding what to build, once by an agent deciding what to generate. The writing contract keeps the prose regular enough that both reach the same conclusion from the same sentence.
Active voice
In a spec, the hidden actor is usually the thing being specified.
The appointment is cancelled.
The receptionist cancels the appointment.
One sentence, one claim
Two claims in one sentence cannot be half-accepted.
The system checks the date and sends a reminder.
The system checks the date. It sends a reminder.
No noun clusters
A preposition costs a word and removes the ambiguity.
patient appointment reminder template
the template for an appointment reminder
One concept, one word
The approved term lives in 00_bootstrap/glossary.md.
client · customer · patient
patient, everywhere
One paragraph, one idea
Past that, the second idea is the one nobody remembers.
Booking rules that drift into billing.
Booking here. Billing in its own paragraph.
State what is
Not what it was or will be. A present-tense rule stays.
The list used to load everything.
The list loads 50 records per page.
Name the thing
No metaphor, no intensifiers. A script returns and refuses; nothing knows or wants.
The validator really knows the schema.
The validator refuses unknown fields.
Say it once
No paragraph restating the table above it.
A table, then a summary of the table.
The table.
The skills apply it
Every skill that writes a KB artifact applies the contract while writing, in the project's language. session-start injects the same rules into every session, so replies follow them too.
prose-style.sh checks the rest
Sentence and paragraph length, passive voice, noun clusters, glossary synonyms, historical language and intensifiers. In another language it runs every check that does not depend on English grammar, using the words style-tokens.md declares.
Style never blocks a commit
Every style check is a warning, with one exception: a synonym the glossary rejects becomes an error once the artifact is accepted.
Where to start
Pick what you want to do.
Edit directly for small changes, reach for a skill for new artifacts or cross-cutting work, and always review before you merge.
Bring an existing codebase in
/inspire-extract scan <path>
Four scanners run in parallel — stack, screens, logic·API·DB, styles — and consolidate what they find into cross-linked candidate features, screens and domain objects. It is read-only: nothing enters the knowledge base without your review.
Next: hand the candidates to the authoring skills.
Add a feature to a module
/inspire-feature create <module>/<feature-id>
The skill interviews you for the use case and checks the acceptance criteria before it writes anything.
Next: its screens, its domain contract, or the prototype.
Propose an architectural change
/inspire-adr create <prefix-slug>
Records the decision at maturity design, with its context, the options considered and its consequences in a rationale file beside it. Placement sets its scope: the whole product, one module or one face.
Next: /inspire-adr promote <id> <maturity> as it moves design → prototyped → implemented.
Design or check a screen
/inspire-screens create <face>.<screen>
Authors a screen in a face: its bindings, its parameters, its layout and the shared components it uses.
To check an existing one for drift: /inspire-screens validate <face>.<screen>.
Specify a behaviour contract
/inspire-domain define <module::entity[::action]>
A socratic interview, not a form to fill in. Nothing is written until you approve the shape.
Next: promote it to accepted when it is ready to build.
Build the code
/inspire-config init
Writes .inspire/emanate.yml from your stack: the image every unit runs in, its services and the checks that decide what merges. Then the factory builds every accepted unit, each one cited by its tests, and opens one pull request.
Your stack's conventions come from the inspire-code-<stack> skills, which you can edit or add to.
See the whole product early
/inspire-prototype
Builds the horizontal prototype — wide, shallow, with mock data — from the specification. What it teaches goes straight back into features, screens and ADRs.
Next: steer the specification with what people saw.
Add an app or an API
/inspire-face add face
Declares a new face, such as a second app, an admin console, an API or an SDK, from scratch or split out of an existing one. /inspire-face add bundle declares which actions it may call.
Next: its screens, with /inspire-screens create.
Run something on a schedule
/inspire-process create <scope>/<process>
Specifies work that nobody asks for: a scheduled job, a reaction to an event, or a first population of the database. It names its trigger and the actions it runs.
Check it with /inspire-process review <id>.
Work without an agent
edit inspire_kb/ by hand
Follow each folder's conventions and its typed file names, and link one file to another with a relative Markdown link. The git hooks still run the validators on every commit.
When an agent is back: /inspire-workspace review catches what the templates don't enforce.
Every command, with what it reads and writes, is in the skills reference.
Skills don't write your product.
They keep it coherent while the agents do.