A software engineering methodology for the agentic era.
Intelligent · Navigable · Spec-driven · Prototypical · Iterative · Robust · Executable
Read the manual → inspire.openbims.dev · OpenBIMS · Genomcore
For decades, building software was a coordination problem — getting teams of humans aligned around implementation. Agile was built for that world.
That world is ending. When generating code is cheap, the scarce work is no longer writing it — it's knowing what to build, and telling whether it's right. A single person can now orchestrate a swarm of AI agents, and the bottleneck moves from coordination to judgment.
INSPIRE is a way to build software around that shift:
- Intent lives in a navigable knowledge graph — plain-text artifacts that stay durable each time the code is emanated afresh.
- Prototypes create clarity — a wide, shallow horizontal prototype and narrow, deep vertical spikes reduce uncertainty before you commit.
- Coherence is enforced mechanically — guardrails, skills and automated checks catch drift by design, not by human discipline.
It was born inside OpenBIMS, an open-source healthcare-AI platform by Genomcore. This repository is both its home — where the methodology is documented and evolved — and a ready-to-use template for bootstrapping your own specification-driven projects.
📖 The full story lives in the manual: inspire.openbims.dev (source in its own repo, Genomcore/inspire-docs).
- The unit of work is a Breath, not a sprint. One intent, one context — inhale (internalize the problem) → exhale (materialize it as a pull request). Its size is set by context and impact, not by a clock.
- Every Breath turns the spiral of convergence — Discover → Specify → Generate → Verify — each loop reducing uncertainty and moving the product closer to release.
- Prototypes are instruments for learning, not early products. One horizontal prototype (wide, shallow, mocked) asks "is this the right thing?"; many vertical spikes (narrow, deep, functional) ask "can we build it as we think?".
- The specification is the DNA of the system. Code is its current expression; when it drifts, agents emanate it afresh from the spec instead of patching it.
Stop sprinting. Start breathing.
The convention: dotfolders are INSPIRE scaffolding; non-dot dirs are the product you build on top.
| Path | What it is |
|---|---|
plugin/ |
The distributable Claude Code plugin. .claude-plugin/plugin.json carries the release identity (version + released); skills/{init,update,migrate,visor}/ are the only live skills — /inspire:init, /inspire:update, /inspire:migrate and /inspire:visor; base/ is the inert payload, materialized into a governed project by init: base/skills/ → .claude/skills/inspire-*, base/agents/ → .claude/agents/, base/bin/ → .inspire/bin/ (validators — base/bin/test/ never materializes), base/hooks/ → .claude/inspire/hooks/, base/visor/ → .inspire/visor/ (the visor's configuration), base/kb/ → inspire_kb/, base/templates/ → a provisional root CLAUDE.md, a .gitignore block, and the source/ + prototype/ README stubs. |
.claude-plugin/marketplace.json |
Makes this repo its own plugin marketplace, so /plugin marketplace add Genomcore/inspire resolves. |
docs/adr/ |
Hand-authored, core-level ADRs about INSPIRE itself — not materialized; a governed project's own decisions live in its inspire_kb/01_spec/ (*.adr.md). |
inspire_kb/,prototype/andsource/don't exist in this template repo — they're materialized into a governed project by/inspire:init(the KB skeleton and the product roots, respectively), not shipped here. This list covers the repo's top level, not every file/inspire:initwrites — seeAGENTS.md's Structure section for the fuller breakdown ofplugin/base/.
The skills + validators + hooks under plugin/base/ are the guardrail layer:
the concrete embodiment of INSPIRE's Robust principle — skills carry the
judgment, hooks + validators catch drift mechanically. inspire_kb/ is the graph
they operate on.
A new specification-driven project adopts INSPIRE's guardrail layer wholesale by installing the plugin and materializing it into a repo. The skills, hooks and validators speak a generic, stack-agnostic model — features, specs, screens, prototypes — so they fit any stack.
1. Install the plugin (once per machine).
/plugin marketplace add Genomcore/inspire
/plugin install inspire@inspire
/reload-plugins
The plugin is installed per user. A materialized project runs its skills, validators
and hooks without it, so CI needs nothing; whoever runs an init, an update, a migration
or /inspire:visor needs it installed.
2. In the repo you want to govern, initialize.
/inspire:init
It asks two questions (product roots; whether to declare the marketplace for
teammates), then materializes the skills, validators, hooks and KB skeleton,
marker-merges the session-start + dispatch hooks into .claude/settings.json,
seeds the design system and its token file from your bootstrap theme, seeds a provisional root
CLAUDE.md and a .gitignore block (both left untouched if already present), and
writes .inspire.lock recording which release was materialized. It never touches your git
history and never clobbers existing content.
3. Reload, then bootstrap.
/reload-skills
/inspire-bootstrap init
/reload-skills picks up the newly materialized inspire-* skills — no restart
needed. /inspire-bootstrap init then sets the project's output language,
configures the stack + theme and its shape (frontend / backend / monorepo · one
face or several · web / mobile · database), refines the seeded CLAUDE.md and creates your project's own
README.md, and optionally wires your git remote. Then start filling in
inspire_kb/ — your modules, features, screens and specs. The foundation
(00_bootstrap) and starter screen patterns ship with sensible defaults; the
inspire-* skills guide the rest.
4. Commit the result. From here the runtime lives in git like any other
project file — pulling a template update means running /plugin update inspire
then /inspire:update (which reports drift on the runtime — skills, validators,
hooks — and never overwrites a file INSPIRE shipped without your say-so), not
re-forking. inspire_kb/ is out of scope for update entirely: it is seeded once
at init and is yours from then on. A project whose KB predates INSPIRE 0.15.0 is on
the layered layout (01_adr … 05_screens), and one whose KB predates 0.17.0 links
with [[wikilinks]]; after updating, run /inspire:migrate once to move it to
inspire_kb/01_spec/ and convert its links to relative Markdown links. It rebuilds
nothing already built.
5. Configure the factory.
/inspire-config init
INSPIRE specifies; INSPIRE Factory writes
the code. /inspire-config init writes .inspire/emanate.yml, the factory's only
configuration, from your stack, and validates it with the factory's own reader. The
factory then builds every accepted unit and opens one pull request.
QARA is an optional layer on top, for
the assurance of quality, security, personal data and responsible AI use.
Drift tracking covers the files INSPIRE shipped: each release's manifest holds their hashes, and
.inspire.lockrecords only provenance — version, commit, install time — never a files map of its own. A file you add inside aninspire-*skill directory (a custom stack profile, say) appears in no manifest, so it classifies askeepand survives every update untouched. A pre-0.3 install is the longest hop chain, which/inspire:updatereplays like any other.
Faces and bundles. The specification in
inspire_kb/01_spec/is organised by concept: modules (the domain, one slice at a time), bundles (which actions a package exposes), faces (what a person uses: screens, shell, package, tokens) and processes (work that runs on a trigger). Every file carries a typed extension (.feature.md,.entity.md,.action.md,.screen.md,.bundle.md,.face.md…) and is found by it, so the directories are for people. Declare faces and bundles with/inspire-face add; each one's file says which package the coding stage emanates it into.
Output language. Every skill authors its artifacts in the project's declared language (
inspire_kb/00_bootstrap/project.md, default English) — independent of the language you converse in and of the product's own UI i18n. Asession-starthook surfaces it into every session.
Prerequisites:
bash3.2+ (macOS's built-in bash is fine — no need to install a newer one),yq(Mike Farah's v4),jq1.6+.