Specs are the source code. Code is a build artifact.

Why closing the cycle with reverse discovery doesn't add a command — it inverts what the asset of a software system is.

01 · Before — the code is the truth

This is how almost every project works today: the asset is the code. The spec — if it exists — is documentation: written once, rotting in silence, because nothing forces it to move when the code moves. Six months in, nobody believes it, and rightly so. When the document and the code disagree, the code wins. Always.

Note the economic consequence: everything the organization knows about the system lives in an artifact that can only be read by executing it. When the one person who understands it retires, the knowledge retires too.

02 · The analogy — nobody edits the binary

Think of C. Nobody hand-patches the compiled binary — it would be madness: you edit the .c and recompile. The binary is disposable, regenerable; the .c is the asset. The thesis says: with good enough LLMs, source code moves into the binary's seat. You edit the spec and "recompile": the LLM generates the code.

A compiler alone, however, goes in one direction. While the methodology was forward-only (intent → spec → code), the spec was one more input — not the canonical representation — because the world is full of systems where only the code exists. The return trip was missing.

03 · After — the closed cycle inverts the asset

Reverse discovery adds the inverse direction: code → spec. It is the decompiler. And with both directions, any system — even the legacy with not a single document — can enter the canonical format. With one condition that does all the work: legacy code mixes intent with accident. Bugs customers already depend on, timeouts nobody decided. A naive decompiler photocopies the bugs as features. That is why the one step no automatic tool can perform is a human gate: the machine extracts evidenced candidates, and only a person rules on what was intent (preserve), what was a bug (fix), and what nobody ever decided (undefined).

04 · Corollaries — what follows on its own

The asset appreciates; the code depreciates. If the code is regenerable, every model improvement upgrades the "build" for free: the same spec package, recompiled with the 2027 LLM, produces better code. Specs are the only investment that doesn't age — and that is the commercial argument: you don't sell the rewrite, you sell the asset that also survives the next rewrite.

Fidelity becomes measurable. If you decompile what you compiled and the result matches what you had, the methodology is lossless — and that is a number, like the bootstrap test of a compiler that compiles itself:

Drift and migration are the same problem. A spec three weeks behind its code is 5% drift; a legacy with no document at all is 100% drift. The same question at different scales — with the honesty that today they are different instruments, not a shared engine.

05 · Truth-pass — what is real today, what is still vision

The pitch is beautiful, and precisely for that reason it deserves distrust. The house rule: under-claim, then wire, then re-claim. State as of today (kit 1.65.0):

And note the elegant part: the piece of the diamond that is already real — the formal, traceable, blocking human-judgment layer — is exactly the one no tool in the space has. The part that remains vision is the one anyone could promise. The hard part is built and the glamorous part is missing: the right order.

06 · Why "diamond"

Because it isn't the feature. Reverse discovery — the command — is only the first materialization. What the closed cycle changes is the category of the whole project: from development methodology to canonical representation format for systems. Code comes and goes; the decisions — evidenced, judged, recorded — are the only thing worth migrating.

State verified against kit 1.65.0 · sources: ADR-009, ADR-010, ADR-011, CHANGELOG-1.64.0, CHANGELOG-1.65.0 · the REAL/VISION labels follow the repo's INV-TRUTH-01 rule.