The methodology

Knowledge first. Code follows.

INSPIRE is a way of developing software in which the product's durable truth — its intent, decisions, contracts and screens — lives in a navigable knowledge graph. Code is the current expression of that graph: humans shape the knowledge, agents emanate the code from it.

The seven principles behind it — Intelligent, Navigable, Spec-driven, Prototypical, Iterative, Robust, Executable — are in the manifesto.

The knowledge base

Knowledge lives in a navigable graph.

The specification is not a document. It is a connected knowledge graph.

Every durable decision, specification and piece of knowledge is a plain-text artifact connected into one navigable graph. It becomes the product's memory — a source of truth that humans and agents can read, write and reason over, long after any implementation has been emanated anew.

ArchitectureUse casesEndpointsSchemasUI Spec

The graph is the shared context between humans and agents.

The unit of work

Not sprints. Breaths.

In the agentic era, the unit of work is context rather than time. INSPIRE works in Breaths: one intent, one context, taken exactly as deep as it needs.

SPECIFICATION → PRODUCT INHALE UPSTREAM EXHALE DOWNSTREAM ISSUE PULL REQUEST

Inhale — the upstream operator

Functional judgment and specification

Understands the use case and decides what the product should do, and why. Brings the domain firsthand or by working with the stakeholders who hold it. This is where scarce judgment enters the loop.

Lands as: specifications in the knowledge graph that guide INSPIRE.

Exhale — the downstream operator

Technical judgment and correction

Knows the product's full-stack code and its technical decisions. Reviews what the factory generated and refines the output with technical requirements for robustness and maintainability.

Lands as: a reviewed pull request — and findings fed back into the specification.

A Breath has no fixed size — defined by context and impact, sometimes a sweeping change, sometimes a single line of code.

The spiral

The spiral of convergence.

The phases of development aren't stages you pass once, nor a flat loop you repeat. Every Breath reduces uncertainty, increases value and moves the product closer to release.

Discover Specify Generate Verify RELEASE

Discover · Intent, Architecture, Design

Take in intent and shape the form. A wide, shallow prototype answers: is this the right thing?

Specify · Contracts, Schemas, Interfaces

Turn intent into concrete contracts. A narrow, deep spike answers: can we build it as we think?

Generate · Implementation

Agents produce the software from the specification, with a bounded margin. The product becomes real.

Verify · Tests, QA, Reality

Tests derived from the spec catch drift; human testing validates what the spec cannot express.

A Breath is not a cycle. It is another turn of the spiral.

Two speeds

The system breathes differently as it matures.

The system breathes at the pace of its responsibilities.

YOUNG SHAPING FAST MATURE EVOLVING WISELY

Young System — Growing through intent

Accelerated breathing

The system breathes with force and intent. It can change direction quickly because its history is still light.

Mature System — Evolving through memory

Conscious breathing

The system breathes with depth and experience. It evolves through the memory it has accumulated, preserving what gives it identity.

The boundary is the moment the system acquires history.

Prototyping

Prototypes create clarity.

No prototype is the product. Its purpose is to reduce uncertainty and refine the persistent knowledge layer. Different prototypes answer different questions before that knowledge shapes the evolution of the product.

One horizontal prototype

wide · shallow · not functional

A rough but navigable representation of the whole product, every face of it — mocked but real. Cheap enough that showing the intended form beats drawing a mockup of it.

Is this the right thing?

Many vertical prototypes

narrow · deep · fully functional

One focused spike per module, section or component — each running end-to-end in its own isolated sandbox, exercising real behaviour proving that the specification can become reality.

Can we build it as we think?

Robust

Coherence is protected by design.

When agents move this fast, coherence can't rely on human discipline or implicit memory. INSPIRE makes it structural — through enforcement and trusted foundations.

Driving the Process

The guardrails

Skills, hooks, validators and QA turn the specification's rules into automated checks. Each skill checks the files it writes, every commit gets a review of the knowledge files it touched, and the pre-PR gate blocks what is still incoherent. Drift is caught by these checks, so nobody has to remember it. Every session also starts with the project's live decisions loaded.

See them in the factory

Deploying the system

Trusted foundations

The system is built on proven primitives such as Vitacora and clear contracts. Agents compose on solid ground instead of reinventing critical components or introducing unnecessary variation.

Get Vitacora

Executable

An executable specification: code emanates from it the way a senior engineer would write it.

A specification that only describes the product leaves the agent to guess. In INSPIRE, the knowledge graph says enough for code to emanate from it, and the agents work from it the way a senior engineer works from a well-written brief.

Respects the architecture

Every change re-anchors to the ADRs that constrain it: layering, cross-module rules, system-wide choices.

Implements the contracts

Action descriptors and entity documents say what each operation takes, returns, requires and guarantees. The code implements them instead of improvising.

Tests first

Tests come from the acceptance criteria before the implementation, and each one cites the claim it verifies.

Follows the house style

Stack skills bring each framework's conventions: layering, test conventions, forbidden patterns, review focus, build commands.

Gets reviewed

Deterministic checks verify every claim's citation, and an independent reviewer judges the change against the project's conventions before it merges.

Inside the factory

Updates & Lessons

Teach it once. It remembers across every release.

The runtime evolves, and your customizations shouldn’t have to be fought for again on every upgrade. INSPIRE records how you taught a skill as lessons, and an update reconciles only what it owns.

Lessons

One line that changes how a skill behaves

A lesson is a single imperative, such as “When generating a NestJS controller, keep DTOs in a separate file.” It is written once, version-stamped and never edited; to revise it you write a new one that supersedes it. You capture it because it matters in this project. Whether it generalizes is decided upstream, from the pattern many teams’ lessons form.

/inspire-lesson

Updates

Upgrade from any version, keep your edits

/inspire:update upgrades a project from any released version to the installed one. It compares three hashes per file: what INSPIRE shipped at your version, what is on disk, and what is about to be installed. Stale files update silently, your edits are kept, and only a file both sides changed asks you anything. It touches only the paths INSPIRE owns, and a read-only plan mode shows everything first. It ends by reviewing .inspire/emanate.yml and, when the review warns, offers to re-derive it through a shown diff. It never moves your knowledge base or rewrites its links: when a release changes either, /inspire:migrate does that once, on purpose.

Install & update

Status. The lessons catalog and /inspire:update ship today. On the roadmap for v1 is the semantic half: writing each lesson into the skill it teaches, and re-deriving your lessons onto every new release as absorbed, kept, partially kept or contradicted. When the call is uncertain, your lesson is kept.

INSPIRE doesn't define how code is produced.

It represents how a well-designed system breathes — coherent, alive, and able to renew itself.

Stop sprinting.
Start breathing.