03 · The software factory
Specification in. Production code out.
The INSPIRE factory turns the knowledge graph into production code under source/, unattended from start to report. Agents write the code. Deterministic guardrails decide what lands: validators, hooks and tests that give the same verdict every time they run.
The input
The factory builds from knowledge, not from prompts.
Nobody writes a prompt describing the feature. The factory reads the parts of the knowledge graph that specify a unit and keeps returning to them while it works.
Architecture decisions
The ADRs that constrain the unit: layering, cross-module rules, system-wide choices.
Domain contracts
Action descriptors and entity documents from 04_domain: what each operation takes, returns, requires and guarantees.
Acceptance criteria
The use cases in 03_features, already through the quality gate. Every test the factory writes cites one of these claims.
Screens and stack
Pattern-driven screen specs from 05_screens, and the stack declared in 00_bootstrap.
A gap in the spec is never patched in code. When the factory or /inspire-code debug finds that the specification is missing something, the issue goes back to /inspire-feature or /inspire-domain. The graph stays the source of truth.
The line
One goal. Dependency waves. No human turns.
/inspire-emanate takes one goal and walks the knowledge base in dependency order: whatever nothing else depends on gets built first, then whatever depends only on that, and so on outward.
Plan
emanate plan is read-only. It lists the waves it would build and what blocks each one, and it refuses up front when a run provably cannot reach its goal.
Build each wave
emanate run works through the waves without supervision. Each unit is handled by its own crew, and each persona runs in its own git worktree.
Verify
Two overseers review the unit independently, and the tests that cite its acceptance criteria have to pass. Both conditions are required.
Promote
Promotion is a git merge that records the verdict. The factory never writes to the knowledge base, so the specification it builds from stays untouched.
The crew
No agent grades its own work.
Every unit gets five personas with separate jobs. Whoever writes the tests did not write the code, and the agents who approve the result wrote neither.
01
Contracter
Pins down the unit's interfaces from the domain contracts before any implementation exists.
02
Tester
Writes the tests from the acceptance criteria, each one citing the claim it verifies.
03
Implementer
Writes the code that satisfies the contract and turns the tests green.
04 · 05
Two overseers
Review the result independently against the specification. The unit is promoted only if both approve.
Deterministic guardrails
The agents propose. The checks decide.
A language model can be persuaded. A validator cannot. The gates every change has to pass are ordinary programs: given the same input they return the same verdict, and no agent can argue its way past them.
Validators
Bash, yq and jq checks in .inspire/bin/, with no Node toolchain. They enforce the structural rules of the graph: acyclic dependencies, stable-blocker invariants, entity lifecycle and cross-field coherence.
Git hooks
pre-commit reports findings in the modules you staged. pre-pr re-runs the review over the whole tree as a second line of defence. Both refuse while hard errors remain, and --no-verify is not an option.
Tests that cite the spec
A unit counts as done when the tests tied to its acceptance criteria pass, not when an agent says it is finished. Every claim in the specification has a test that checks it.
Provenance
Tooling, never the skill itself, stamps each artifact with the skill that wrote it, the exact deployed bytes it ran against and the runtime version. When the machinery drifts, the drift is visible.
Two modes
Attended when you want to steer. Unattended when the spec is ready.
Attended · one feature
/inspire-code
You stay in the session. tdd implements a single feature test-first against its acceptance criteria. review, debug, fix-build and fix-vulns cover the rest of the coding stage, and each one re-anchors to the ADRs and descriptors behind the code.
Unattended · a whole scope
/inspire-emanate
You give it one goal and read the report at the end. It plans the waves, builds every unit with its own crew, and promotes only what passes the guardrails. Nobody intervenes between the start and the report.
Skill referenceStacks & foundations
Stack-agnostic, built on solid ground.
Stack profiles
Your framework's conventions
Optional profiles, resolved on demand from 00_bootstrap/stack.md, layer a framework's specifics on top of the generic checks: layering, test conventions, review focus and build commands. The template ships react, angular, nestjs, ios and android profiles plus a typescript language profile.
Trusted foundations
Proven primitives
The factory builds on proven primitives such as OpenBIMS and on explicit contracts, so agents compose existing pieces instead of reinventing critical components or introducing needless variation.
Get OpenBIMSThe factory is only as good as the knowledge it reads.
That is why INSPIRE puts the human effort into the methodology and the skills, and leaves the rest of the work to the line.