A software engineering framework for the agentic era
Software that breathes.
INSPIRE is a way to build software with AI agents. When generating code is cheap, the scarce act is knowing what to build, and telling whether it's right.
The shift
AI changed software development. Our frameworks haven't.
For decades, software development was a coordination problem: getting teams of humans aligned around implementation. Agile was built for that world.
Now the unit of work is changing. A single individual can orchestrate a swarm of AI agents, shifting the bottleneck from coordination to judgment.
The agile era
SCRUM
Built for teams of humans coordinating over weeks. Work is split into time-boxed Sprints, with roles, estimation and daily stand-ups — because the bottleneck was collaboration between people.
The agentic era
INSPIRE
Built for one person orchestrating a swarm of AI agents in a single session — a Breath. Guardrails, skills, QA and version control replace the ceremonies; the bottleneck is judgment, not coordination.
What INSPIRE is
One name. Three things that work together.
INSPIRE is a way of thinking about software, the agent skills that put that thinking to work, and a factory that turns the result into production code. You can adopt them one at a time, but each one is built to feed the next.
01
The methodology
Development built on a knowledge graph
The specification is not a document. It is a connected graph of decisions, use cases, contracts and screens that humans and agents both read and write. Code is its current expression. Work moves in Breaths rather than sprints, and every turn of the spiral brings the product closer to release.
Read the methodology02
The skills
Agent skills for every stage of the work
Fifteen /inspire-* skills for Claude Code cover the whole lifecycle: specifying the product (ADRs, modules, features, domain contracts, screens, prototypes), codifying it, and keeping the workspace in order. They interview you wherever a decision is needed and carry each change through every layer it affects.
03
The software factory
From specification to production code
Given a specification, the factory produces production code with no human turns in between. It builds in dependency waves, assigns separate agents to contract, test, implement and oversee each unit, and promotes nothing until deterministic guardrails pass. The agents propose; the checks decide.
Inside the factoryThe methodology says what must be known. The skills capture it. The factory builds from it.
FAQ
Questions people ask first.
Is INSPIRE a methodology or a tool?
Both. The methodology is a set of principles that stands on its own. The skills and the factory are the tooling that puts it into practice. The methodology works without the tooling, but the tooling is where it pays off.
Why a knowledge graph instead of a spec document?
A document gets read once and then drifts. A graph of small, linked plain-text files can be traversed: an agent working on one endpoint can follow the links to the use case, schema, screen and decision behind it, and pick up only the context that applies. That traceability is what allows code to be regenerated without losing the reasons it was written.
Where does the knowledge live?
In your own repository, as Markdown under inspire_kb/, versioned with git next to the code. There is no external service or database. You can edit it by hand or through a skill, and both are first-class.
Do I need Claude Code?
The skills and the factory ship as a Claude Code plugin, so you need it for those. The knowledge base is plain text, and the validators are plain Bash with yq and jq, so neither depends on any particular agent.
What does “deterministic guardrails” mean?
The checks that decide whether a change can land are ordinary programs, not language models. Validators enforce the structural rules of the knowledge graph, git hooks refuse commits and PRs while hard errors remain, and the factory promotes a unit only once the tests citing its acceptance criteria are green. Agents generate the code; deterministic checks rule on it. The same input always gets the same verdict.
Does the factory replace engineers?
No. It moves the engineer to where judgment counts: deciding what should exist and whether the result is right. The factory takes care of the exhale, turning a specification that is already understood into code. The inhale, understanding the problem, stays with a person.
Can I adopt it on an existing codebase?
Yes. /inspire-extract runs four parallel scanners over an existing codebase (stack and infrastructure, UI screens, logic/API/DB, and styles), consolidates their findings into cross-linked knowledge-base candidates, and hands them to the authoring skills. It never writes to your source.
Which stacks does it support?
It is stack-agnostic by design. Optional stack profiles add a framework's conventions on top of the generic checks. The template ships react, angular, nestjs, ios and android profiles plus a typescript language profile, and a fork can add its own.
How is this different from Scrum?
Scrum addresses coordination between people over weeks. INSPIRE addresses one person directing many agents within a single session. The unit of work is a Breath, sized by context and impact rather than by time, and skills, guardrails and QA take the place of ceremonies.
How do I start?
Install the plugin, run /inspire:init in your repository, and invoke your first skill. The how-to page covers each step.