Skip to content
GenomcorePublic

About

INSPIRE is an intent-to-code SDD framework following OpenBIMS agentic AI product development guidelines

Resources

Stars

0 stars

Watchers

0 watching

Forks

Repository files navigation

INSPIRE

Software that breathes.

A software engineering methodology for the agentic era.

Intelligent · Navigable · Spec-driven · Prototypical · Iterative · Robust · Executable

Read the manual → inspire.openbims.dev · OpenBIMS · Genomcore


Why INSPIRE

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 methodology in one breath

  • 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.


What's in this repo

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/ and source/ 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:init writes — see AGENTS.md's Structure section for the fuller breakdown of plugin/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.


Get started

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.lock records only provenance — version, commit, install time — never a files map of its own. A file you add inside an inspire-* skill directory (a custom stack profile, say) appears in no manifest, so it classifies as keep and survives every update untouched. A pre-0.3 install is the longest hop chain, which /inspire:update replays 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. A session-start hook surfaces it into every session.

Prerequisites: bash 3.2+ (macOS's built-in bash is fine — no need to install a newer one), yq (Mike Farah's v4), jq 1.6+.


INSPIRE doesn't define how code is produced. It represents how a well-designed system breathes — coherent, alive, and able to renew itself.

Intelligent · Navigable · Spec-driven · Prototypical · Iterative · Robust · Executable

Born in OpenBIMS · by Genomcore

About

INSPIRE is an intent-to-code SDD framework following OpenBIMS agentic AI product development guidelines

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages