Code that AI agents actually understand.

Architecture

One neutral core, projected per language

The language-independent core ships the manifesto, the pattern-card format, the nine-class catalog of executable scaffolds, the operating playbooks, and the neutral engines: conformance, traceability, the inert tag macro. Each language stack projects that core through its own fact extractor and four gate binaries, adds a generation-time type oracle, the language guide, the nine cards in language shape, and two agent skills. Your project keeps the policy — which cells are gated, which are exempt and why. The packages ship engines, never policy.

Each stack also ships as an MCP server (*-ai-native-mcp) — the same command surface plus the type oracle for any MCP-capable agent; the Rust server alone exposes eighteen tools. Distribution is vibe: one aggregator package per language pins stack, server, and core to one resolved version set.

The dividing line

What your toolchain proves — and what the gate adds

The discipline deletes nothing. Each language’s floor runs your existing tools first, in a fixed order, then appends three gates of its own: conform for structure, specmap for traceability, test-gate for the baseline. One command, one exit code.

Mechanisms

Five things you can hold in your hands

1. Traceability that survives refactors

   Code carries inert tags — at most three edges per item, typed implements | verifies | documents | deviates | informs. The specmap engine compiles them into a committed, deterministic index: spec units on one side, code items on the other. Invalidation is asymmetric by design: bump a spec unit’s revision and its edges turn suspect; edit the code and the edges hold. An item that loses its anchor is an orphan the ratchet refuses to accept. That is the difference between architecture you re-derive and architecture you query.

   #[derive(Debug, Error)]
   pub enum Error {
       #[error("invalid package reference `{input}`")]
       InvalidRef { input: String },
   }

   #[derive(Debug, Error)]
   #[spec(implements = "spec://…#package-identity")]
   pub enum Error {
       #[error(
           "invalid package reference `{input}`: \
            {reason} \
            (violates spec://…#pkgref; \
             fix: `[kind:][group/]name[@version]`)"
       )]
       InvalidRef { input: String, reason: String },
   }

   Abridged from the pilot’s own vibe-core. The failure now names the contract it broke and the fix surface — for the reviewer and for the next agent alike; the error-enum-cites-req gate keeps it that way.

   The same edge, in each language:

   #[spec(implements = "spec://…#anchor")]

   /** @implements spec://…#anchor */

   //spec:implements spec://…#anchor r=1

2. The floor: one command, one exit code

   rust-ai-native floor, typescript-ai-native floor, go-ai-native floor. Formatters, compilers, linters, and tests run first; the discipline’s gates run after, in the same panel. Every policy line prints its origin, and a Defaulted policy announces itself — never trust a green you didn’t configure. Conformance is deterministic: same inputs, byte-identical SARIF, no model anywhere in the checking path.

3. The ratchet, or how a real repo adopts this

   init writes the pre-adoption posture: every crate or cell exempt, each with a recorded reason; the only hard precondition is that the workspace compiles. From there the direction is one-way — drain a unit to zero findings, flip it into the gated list, and a flip must never widen the baseline. Pre-existing findings freeze in conform-baseline.json; new ones fail the gate; the baseline only shrinks. The test gate is xfail-strict: it fails on a new failure and on an unexpected pass nobody promoted, so the baseline shrinks truthfully.

   {
     "findings": [],
     "schema": 1
   }

4. Bans carry escape hatches

   Forbidden-by-default constructs stay legal with machinery and a recorded reason. A matching deviation downgrades the finding to deviation-acknowledged — visible, counted, reviewable — instead of silencing it. The discipline states its own symmetry: a ban with no escape hatch is a bug in the discipline; a deviation with no reason is a bug in the code.

   #[spec(deviates, reason = "platform ctor runs single-threaded, pre-main")]

5. A type oracle at generation time

   Before writing a nontrivial edit, an agent can validate the hypothetical file content — unsaved, over in-memory overlays — against the language’s own analyzer: rust-analyzer, your project’s typescript, gopls. The oracle merges the gate’s conform rules into its answers (validate / scope / complete / type), so a discipline violation surfaces before the diff exists. The honesty is in the brief: an analyzer is not the compiler; a clean validate shortens the distance to green — the floor stays the truth.

   vibe bin exec rust-ai-native-tcg -- validate src/cells/edit.rs --content-from -

The family

Three projections, one bar

Parity is a law of the discipline, not a hope: no language projection may enforce the discipline more weakly than another without a recorded reason. Where a language genuinely lacks an idiom’s analogue, the gap is recorded — with the reason as the escape hatch, never in silence.

Beyond these three: C++ and Python exist in the engine spec as rows explicitly marked «specified, not built». They become stacks when a product decision says so — not silently.

Dogfood

Piloted on the code that ships it

The discipline is a product in its own right, and VibeVM is its first pilot — not its scope boundary. The vibe CLI, a Rust workspace of a few dozen crates, runs the gates on itself: most crates gated, the rest exempt with recorded reasons, and the ratchet baseline is empty today. Its committed traceability index carries thousands of spec units and edges. In the same family, Zap’s Rust engine and its TypeScript client run the same gates — the client alone gates dozens of cells across a six-figure line count. The lock file pins the exact discipline version the pilot runs, and the adoption campaign’s paper trail — baseline, log, report — is in the tree.

• The sweep idioms in the Rust guide — tests-out splits, restructure-beats-testify, flip-only-after-drain — are distilled from the pilot’s own campaigns, each with its gotchas recorded.
• The spec corpus audits itself: claims that outran the code are annotated «specified, not built» in place, down to file and line. The traceability machinery is what makes that check possible at all.
• What we do not claim: no performance numbers, no adoption statistics, no measured productivity delta. The discipline’s evidence base is cited and tagged in the manifesto; its own pilot metrics are still ahead.

Status, plainly

A research beta that names its failure modes

The invitation is to try the discipline, read its manifesto, and argue with it — not to believe a stability promise.

Start

Adopt it the way the protocol says: gradually

1. $vibe install org.vibevm.ai-native/rust-ai-native

   One aggregator per language — typescript-ai-native and go-ai-native are its siblings — pins the stack, its MCP server, and the neutral core to one resolved version set. Need vibe first? Install VibeVM →

2. $rust-ai-native init

   Writes the pre-adoption posture into your repo: conform.toml with every crate exempt-with-a-reason, specmap.toml with external spec resolution, the debt and intent registries. Nothing gates yet — and every tool is already useful at 0% adoption.

3. $rust-ai-native floor

   Your existing tools first, the discipline’s gates after, one exit code. Green means: no regression against the inventory — the honest definition for a repository that is mid-flight.

4. Drain one cell, flip it

   Pick one crate or cell, drain its findings to zero, flip it into the gated list — the baseline only shrinks. The terraform and sweep skills carry the procedures as your agents’ slash commands.