FBL — reverse-compiling a real microservice into a spec, then regenerating it byte-identical

Most code-generation demos show you the output and ask you to trust it. This one closes the loop: real code in, a spec out, code back out, and a byte-for-byte check that nothing drifted.

What it was

FBL — Function Block Language — is a spec format for describing a feature slice: its data model, its API surface, its UI. The test, run on 25 April 2026 and nicknamed "Dogfood," was deliberately hard: take a real, live feature slice — SQL migrations, an API, a UI, auth, CRUD, pagination — reverse-compile it INTO an FBL spec, then regenerate the whole slice FROM that spec, and check whether what came out matched what went in.

What we built

🔬Research

A 1,348-line compiler and reverse-compiler, backed by 46 tests, capable of reading a real codebase and producing an FBL spec, then reading that spec back out into working code. The Dogfood run wrote the spec, generated a baseline, applied fixes, ran post-fix tests, and proved a byte-identical round-trip across nine different web framework targets — 14,405 files including generated output, 172MB. That's not a toy repository; it's a real slice, tested at real scale.

Another primitives model — this time for wiring, not meaning

The name is not decorative. "Function block" is borrowed from electrical and control-systems engineering — IEC 61131-3's function block diagrams describe a system as a small set of primitive blocks with typed inputs and outputs, wired together, rather than as free-form code. FBL does the same move for a software feature slice: instead of treating "an app" as one undifferentiated pile of code, it decomposes it into a small, fixed set of primitive block types — data model, API surface, UI, auth, CRUD, pagination — each with typed edges to the others, and a compiler that can generate or reverse-generate the wiring between them.

That makes FBL the same shape of bet the lab keeps making elsewhere, aimed at a different target: the wave-native architecture treats a wave equation as the primitive a whole sequence model is built from; the Calculated Mind treats a semantic primitive as the unit meaning is computed over, not sampled from; NovaTerra Genesis maps all of software onto six primitives; GLYPH and BrainLang both compress language to an atomic primitive set. FBL is the version of that thesis for a running system's wiring: a minimal, composable primitive set (block types + typed connections) from which a real feature slice can be generated and proven, byte-for-byte, rather than merely described. The round-trip proof is what makes it a real test of the thesis rather than a diagram: if the primitive set were missing something the real slice needed, the regenerated code would not match.

What we learned — including the honest negative

The codegen story here stopped being a demo and became a measurement: byte-identical, not "looks right," across nine independent framework targets. That's a materially harder bar than most code-generation claims clear, because there's nowhere to hide drift.

The honest limit sits right next to the win: this is proven on one real feature slice, not validated as a general-purpose tool for arbitrary codebases. The round-trip discipline — spec to code to spec, checked byte-for-byte — is the genuinely hard-won part; broad applicability across arbitrary code is a separate, still-open claim this result does not make.

Where it went / status

Kept public deliberately. FBL is a wiring-contract spec format — there's no core model or platform IP riding on the format itself, so there's no reason to protect it, and real reasons (trust, adoption, feedback) to publish it openly. The proof stands as recorded: one real slice, nine frameworks, byte-identical, dated 25 April 2026.