01 · 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 regenerate the implementation.
The principles
Seven letters. Seven breaths.
INSPIRE is not an acronym stretched over a process. It is seven properties that allow a software product and its underlying knowledge to emerge, evolve and remain coherent in the agentic era.
Individual
The human becomes the orchestrator.
A single contributor, amplified by AI agents, directs complex systems through intent, context and judgment.
Navigable
Context remains discoverable.
A navigable system connects intent, specifications, decisions, implementation and verification into a coherent knowledge graph. Humans and agents can discover context, trace decisions and evolve the system without losing understanding.
Spec-driven
Intent becomes the source of truth.
The specification captures what the system should be, while code becomes an expression of that intent. Implementation can change, but the knowledge behind it remains durable, explicit and verifiable.
Prototypical
Explore before committing.
Prototypes are not early versions of the product; they are disposable instruments for learning. They make uncertainty visible, allowing ideas to evolve before becoming part of the persistent knowledge layer.
Iterative
Progress comes from refinement.
The first version is not expected to be right — it is expected to reveal what is missing. Each iteration reduces uncertainty, revisits previous decisions and moves the system closer to what it should become.
Regenerative
Intent survives implementation.
The specification is the DNA of the system; code is its current expression. When implementation drifts or becomes constrained, agents can regenerate, refactor and reshape it while preserving the original intent.
Enforceable
Coherence is protected by design.
Intent alone is not enough. Guardrails, skills and automated checks turn principles into constraints that guide agents and keep every change aligned with the system's standards.
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 regenerated.
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.
Inhale — internalize
Take the context and go deep. The human builds the understanding needed to decide what should exist — the one place where scarce judgment enters the loop.
Exhale — externalize
Materialize that understanding into durable artifacts — an architectural decision, a specification, an implementation change. The breath lands as a pull request.
A Breath has no fixed size. It is defined by context and impact — sometimes a sweeping change, sometimes a single line of code.
Two speeds
The system breathes differently as it matures.
The system breathes at the pace of its responsibilities.
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.
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 · 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.
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 surface — 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?
Enforceable
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, linters and QA turn the specification's rules into automated checks. Every change is validated against standards before it lands — drift is caught mechanically, not remembered.
See them in the factoryDeploying the system
Trusted foundations
The system is built on proven primitives such as OpenBIMS and clear contracts. Agents compose on solid ground instead of reinventing critical components or introducing unnecessary variation.
Get OpenBIMSINSPIRE 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.