Specify.
Weeks of specification now automated and repeatable.
Every snippet, decision record, and number on this page comes from an actual run of the Aurora L02 Documentation-as-Code automation against the L01 blueprint produced for synthetic Keystone Analytics. Layer 02 turns that dossier into a binding, machine-verifiable contract. Every AI behavior gets a guardrail — what it can do, what it must refuse, who confirms before it acts. Every acceptance criterion becomes a test authored from the spec, before code is written. The charter locks. From here, every commit is verifiable against this specific document, this specific hash.
Source: Keystone-2026Q2 Charter v1 · locked 2026-05-23 · hash
sha256:dcb07909…Specs fail not from missing words —
from missing commitments.
Most AI specs are drafted to read well at sign-off and litigate badly afterward. Aurora's specification layer turns every commitment into something a machine can check and a builder can be refused for violating.
"The AI should be safe" — without a definition of safe.
The word "safe" appears 14 times in most AI specs. The word "safe" maps to zero enforceable checks. Aurora replaces "safe" with a list of forbidden patterns the build layer runs as a grep.
Acceptance criteria written after the code.
Tests get reverse-engineered to match what got built. The traceability matrix shows green because it's been engineered to. Aurora authors tests from the spec, before a line of code lands.
Ambiguity gets deferred — then quietly resolved.
The fuzzy clauses ("appropriate human oversight," "reasonable confidence") become whatever the builder decided at 2am. Aurora forces every ambiguity to a named decision-maker before charter lock.
The spec doesn't survive the first change.
Change orders accumulate in Slack and never propagate to the artifact. The signed document gradually stops describing the system. Aurora locks the charter and routes every change through an explicit, dated amendment.
Safe AI isn't a value statement.
It's a registry of decisions a machine can enforce.
Seventeen decisions in the Keystone charter. Each one names: the choice, the alternatives considered, the rationale, and the patterns the build layer is structurally prevented from using. Below are four representative records from the run.
Driver attribution must be interpretable
Where AI explains "why is this account at risk," the explanation must decompose into named drivers a human can verify. Black-box reasoning is forbidden on any path that influences a customer-impact decision.
External actions require human confirmation
The AI playbook composes. A named human ratifies before any customer-facing action fires — email, calendar invite, in-app message, escalation, contract change. Every action carries a confirmation record.
AI memo cannot invent numbers
Every paragraph in the board memo traces to a numerical source or a documented assumption. The narrative is generated from the template, not from a free-form prompt. No paragraph escapes without a citation.
The validation gate cannot be bypassed
A signal known to be unreliable (broken data lineage, missing inputs) is suppressed before it reaches a CSM. The gate's behavior is dependency-injected and testable, not buried as a substring check.
The full Keystone Charter carries seventeen records. Eight on AI behavior. Six on data lineage and disclosure. Three on operational discipline. Each is loaded by the build layer as a structural check before commits land.
A spec that's readable by an executive
and enforceable by a build agent.
Below: representative slices from the Keystone Charter showing the same requirement at four layers of resolution — executive prose, structured spec, decision record, and machine-checkable test.
Five steps. Each one a gate.
Charter draft
Read the L01 Blueprint + signoffs. Populate the Aurora Charter schema's six sections — executive statement, background, scope, acceptance criteria, wave plan, AI decision registry. Every section pulls from named L01 evidence.
AI Decision extraction
Every architectural choice implied by the charter (chose X over Y) gets externalized as a discrete decision record with full enforcement clauses — forbidden patterns, allowed patterns, integration citation requirements. The build layer can't deviate without surfacing the deviation.
Ambiguity catalog
Every place L01 surfaced "we don't know" becomes an explicit entry with a named decision-maker. Blocking ambiguities get resolved on the record before charter lock. Non-blocking ambiguities are deferred with rationale.
Hash + sign
The charter's canonical hash is computed and written to a signature file. The charter is now immutable. The build layer's first action is to verify this hash. Drift detected = the build halts before code lands.
Hand off
The locked charter + decision records + acceptance tests + ambiguity log move to L03 as a phase-exit contract. The build agent reads all of this. Every commit is verifiable against this specific document, this specific hash.
L03 takes the locked charter
and ships the working system.
See how an AI builder honors seventeen guardrails and an independent verifier catches what the builder missed.