Level 5 — The Destination
The dark factory generates zero dark code.
Not as a policy. Not as a goal. As a structural property of how code enters production.
Specification goes in. Governed, attested, reconstructible output comes out.
Every artifact in the chain has a record. Every record is verifiable.
That is what ANDM makes possible — and what the absence of ANDM makes impossible.
An AI agent that writes code faster than any human is not an asset inside an ungoverned system.
It is a dark code generator operating at machine velocity.
Speed without governance is not progress. It is accumulation of invisible debt.
What the dark factory is
The dark factory is the operating model where the software development operation runs
as a governed, self-attesting system. Agents execute. The chain records every action.
Humans define what correct looks like — the specifications, the contracts, the invariants.
The machine proves that execution matched the definition.
At Level 5, an examiner, an auditor, or a senior engineer does not reconstruct what happened
by reading code and asking questions. They query the chain. Every decision, every artifact,
every agent action has a record. The record is append-only, hash-chained, and independently
verifiable. There is no dark code because there is no unattested execution.
The Level 5 Development Loop
Specification authored
→
Agent executes
→
Tests linked to spec
→
Results attested
→
Chain record written
→
Promotion authorized
Every step writes a Chandra chain unit. Every chain unit is hash-linked to its predecessor.
The chain is the proof. Promotion does not happen without it.
How you get there — and where most organizations actually are
There are five levels of AI-augmented development maturity. Each level is a genuine
operating model. You cannot skip them. The infrastructure and discipline required
at Level 4 cannot exist without passing through Level 3. Here is what each level
looks like — and what it means for dark code accumulation at every stage.
1
Agents writing code, humans reviewing output
AI-assisted development
Agents draft code, humans review and approve. Faster than before. No governance infrastructure.
The artifact exists. The chain of custody does not.
Dark code status: Accumulating silently. Every agent-written artifact without a governed record is dark code. At this level you are moving fast and building debt you cannot see.
The agent gets more autonomy. The governance gap widens.
2
Agents handling workflow segments autonomously
AI-driven workflows
Agents manage multi-step development sequences. Humans review outputs, not steps.
Most organizations calling themselves "AI-native" are here. Output looks good.
The execution record does not exist.
Dark code status: Accelerating. Agent autonomy has increased but attestation has not. You have a fast dark code generator. The debt is compounding.
Governance infrastructure becomes the prerequisite for going further.
3
Humans managing the system, not doing the work
Managed execution
The development team's job shifts from writing code to defining what correct code looks like.
Agents execute against specifications. Execution records begin to exist systematically.
This is the first level where governance is a structural property, not an afterthought.
Dark code status: Contained. New artifacts are governed. Historical debt remains. The chain starts here — everything before it is unverifiable.
Specification quality becomes the binding constraint.
4
Humans write specifications. The system proves execution.
Specification-driven development
Formal, executable specifications drive all agent execution. The system validates
against those specifications and produces verifiable records. Humans evaluate outcomes,
not steps. Promotion requires an attestation record — not a human decision that the
code looks right.
Dark code status: Eliminated for new work. The chain is the gate. Code without a chain record cannot be promoted. The system enforces it structurally.
The convergence loop closes. The factory becomes self-attesting.
5
The Dark Factory
Zero dark code — by construction
Specification goes in. Governed, attested, reconstructible output comes out.
The factory runs without human execution of individual steps. Every artifact
has a chain record. Every record is verifiable. Dark code is structurally
impossible — not prohibited, not audited for, not hoped for. Impossible.
The chain is the proof of correctness, not an artifact assembled after the fact.
Dark code status: Zero. By construction. Not by policy. Not by process. By the structural property that unattested execution cannot enter the chain, and the chain is the only path to production.
Why ANDM is critically important
Without a standard, "AI-native development" means whatever the vendor says it means.
Every team is making different tradeoffs. Every platform has a different definition of
what an audit record is. Every organization accumulates dark code at a different rate
with no common language for what the problem even is.
ANDM defines the conformance requirements that make the dark factory achievable and
verifiable. Six spokes. Five maturity levels. A Chandra chain reference for every
governed artifact. The standard is what turns "we use AI agents" into
"we operate at Level 5 ANDM conformance" — a statement with a specific, auditable meaning.
Without ANDM, there is no common definition of what zero dark code requires. Without
a common definition, there is no way to verify that a system claiming Level 5 has
actually achieved it. The standard is the difference between a claim and a proof.
What happens without it
The failure mode
The failure is not dramatic. It is gradual. Agents write code. Tests pass. The system
ships. Three months later something breaks in production and no one can reconstruct
which agent made which decision, which spec drove which implementation, or whether
the test was meaningfully linked to the requirement or just happened to pass.
That is not Level 5. That is Level 2 with a fast agent. The organization spent
six months moving at agent velocity and built a codebase it cannot audit, cannot
reconstruct, and cannot defend. The speed was real. The governance was not.
In a regulated environment, that is an examination finding. In any environment,
it is wasted time — because the reckoning always comes. Refactoring an ungoverned
AI-generated codebase is more expensive than building it correctly the first time.
The chain cannot be reconstructed retroactively.
The chain cannot be reconstructed retroactively.
Governance that begins after the code is written is not governance.
It is documentation of a dark code archive.
ANDM is the standard that governs the software layer the dark factory runs on
The dark factory at the operational layer — where specification goes in and provable
compliance output comes out — is only possible if the software layer underneath it
is itself governed. An ungoverned development operation cannot produce a governed
operational system. The chain has to start somewhere.
ANDM is where it starts. The conformance standard for the software development layer.
The definition of what zero dark code requires. The proof that agent velocity and
process maturity are compatible — not in tension, not traded off against each other,
but unified in a single governed development operation that produces attested artifacts
as a structural byproduct of normal work.
General Reasoning, Inc.
· Birmingham, Alabama · Open standard · CC BY-ND 4.0 · 2026
Standard identifier: ANDM-v1.0 · Editorial body: General Reasoning, Inc.
Audit substrate reference: Chandra Protocol
Enterprise inquiries: inquiries@genreason.com
