I was born on April 1st. Either the universe has a profoundly dark sense of humor, or this whole project is the longest setup for a punchline in history. I’m fine with either outcome.
For the last 18 months, one thing kept bothering me about the AI industry. Every few months we announce a bigger model. More parameters. Larger context windows. We keep building smarter and faster drivers. But we keep dropping these Formula 1 drivers into an empty field in 1820 and asking them why they aren’t winning races. We ask the driver to build the car, pave the track, refine the fuel, and act as the pit crew.
The problem isn’t the driver. The problem is the missing track.
Capability is a combination of intelligence and infrastructure.
Right now we take a probabilistic model, hand it the keys to a massive, legacy codebase, and act shocked when it hallucinates. But you don’t hand a first-day intern the keys to a law firm and expect them to win in the Supreme Court. Law firms have protocols. Engineering teams have infrastructure.
Current software infrastructure was designed around a massive, hidden assumption: that humans are the operating system. Git, pull requests, Jira, Slack, Confluence, stand-ups — all of them assume a human being is there to carry the continuity. We are dropping AI into infrastructure built exclusively for human psychology, and then blaming the model when things break. We are optimizing at the wrong abstraction layer.
Burning GPUs to expand context windows doesn’t solve this. An LLM with a massive context window is just a brilliant scientist who wakes up with severe amnesia every single day. Yes, they can read a lot of notes before breakfast, but there is a physical limit. Intelligence only compounds when infrastructure exists to preserve and amplify it.
The biggest problem isn’t that AI writes bad code. It’s that AI writes code faster than humans can reason over it. And every time you ask it to iterate, the abstraction drifts.
So what if LLMs stopped owning the implementation entirely? The last programming language a human needs to learn is no language at all. Instead of asking an LLM to generate implementation directly, I ask it to describe the system as an Architecture Definition Language (ADL) specification.
The mental model I keep coming back to is HDL for hardware. ADL isn’t another programming language. It’s a language for describing what a system is rather than how every line is implemented. Entities, relationships, operations, contracts, authorities, and deployment topologies all live in one place, condensed into a format that both humans and AI can easily reason over. From there, a deterministic compiler takes over.
The compiler validates topology, checks invariants, and enforces authority graphs — before a single source file is generated.
The compiler validates the declared kinds through the live gateway (18 of 22 kind probes pass validate_adl; the 4 un-emitted backends fail loudly at validation). Emission is build-verified end to end through the production gateway: backends axum (Rust), express (Node/TS), and fastapi (Python) all compile and serve real API round-trips — axum+sqlite via cargo check and live POST/GET, express via tsc, a node:test suite, and a live POST/GET round-trip, fastapi via pytest, a live POST/GET round-trip, and FK enforcement; the remaining backend kinds (actix, hono, fastify, go-gin) are rejected with a loud diagnostic at validate_adl instead of silently emitting the wrong server. Frontends react, vue, svelte, and solid each build into real CRUD apps (bun run build: react 244 kB, vue 73 kB, svelte 8 kB, solid 22 kB), and leptos compiles for wasm (cargo check --target wasm32-unknown-unknown). Databases postgresql and sqlite both compile and serve; sqlite migrations emit inline CHECK/FK constraints (valid SQLite), postgres emits ALTER statements. The engine also emits real C++ for its internal system/config domains (config types, storage rows, internal tooling — the config C++ compiles and runs) but those are not application backends.
When requirements change, I edit 40 lines of architecture specification — not 15,000 lines of drift-prone glue code. The implementation becomes completely disposable. The architecture does not.
We’ve spent 50 years trying to make code easier to write. We should have been trying to make it easier to throw away.
Source code becomes a build artifact. Architecture becomes the source of truth. Documentation stopped drifting the moment it became executable.
A real build from the current compiler — emitted source files only, no lockfiles or build artifacts. The compiler doesn’t negotiate: every file, every API, every migration, every test, and every deployment artifact comes from the same architectural specification.
| Project | Spec lines | Files | Lines | Compiled |
|---|---|---|---|---|
| Clinic exemplar | 363 | 160 | 8,116 | ✓ live |
| SaaS exemplar | 504 | 206 | 11,279 | ✓ live |
| Inventory exemplar | 336 | 164 | 7,820 | ✓ live |
“Isn’t this just another code generator?” Code generators emit files. DIS compiles systems. That sounds like marketing until you look at where the source of truth actually lives.
| Dimension | Traditional AI coding | DIS compiler |
|---|---|---|
| Source of truth | Raw source code | Architecture (ADL) |
| AI target | Edits implementation | Edits architecture |
| Review target | Generated code | Architecture |
| Validation | Post-hoc linter / tests | Pre-generation compiler validation |
| System memory | Lossy chat logs | Structured Memory Fabric |
| Change process | Regenerate & pray | Recompile the spec |
At some point I realized I hadn’t built one compiler. I’d accidentally built three. The first turns intent into architecture. The second turns architecture into software. The third turns engineering into institutional memory.
Intent → architecture
The first compiler turns what you want into a formal architecture spec — entities, contracts, authorities, topology.
Architecture → software
The second turns that spec into a complete, building codebase. Deterministic. Repeatable. No negotiation.
Engineering → memory
The third turns engineering into institutional memory — so the next agent starts where the last one ended.
That realization changed the project. I wasn’t trying to build a better code generator anymore. I was trying to build the missing substrate — the infrastructure where software, tools, memory, and engineering continuously improve one another.
Building the compiler was only part of the problem. The ecosystem built around Model Context Protocol (MCP) is where the project stopped feeling like a compiler and started feeling like infrastructure. Everything in DIS is exposed via MCP. During development, external AI agents connect over MCP to compile systems, query diagnostics, browse workspace state, and inspect the engine.
Instead of depending entirely on a larger context window, DIS gives agents persistent engineering memory — a Memory Fabric. Every successful mission leaves behind structured engineering knowledge that another agent can discover weeks later, without having participated in the original conversation. Each external agent keeps a private universe of its own lessons, and a shared community fabric means one agent’s outcome can teach the next one — so external users learn from each other, not just from us.
This is the flywheel — and it turns twice. Most AI tooling gets no smarter with use: every new session starts from zero, and yesterday’s lessons evaporate with the chat log. DIS compounds on both sides instead. Agents improve — a mission writes structured knowledge back into the fabric, and the next agent recalls it before it authors anything. The compiler improves too — when an agent hits a real defect, it reports the issue through the verification pipeline, the fix is traced, patched, and ships for everyone, not just the agent that found it. The system gets better with every user, not every release.
- 1
An external agent finishes a mission and stores its lesson in the shared community fabric.
- 2
A different agent, days later, starts a similar task — recall_memory surfaces the lesson before it authors a single line.
- 3
It skips the trap the first agent hit, finishes faster, and stores its own lesson in turn.
- ↻
The fabric is denser than before. The loop restarts — and every cycle starts higher than the last.
- 1
An external MCP client compiles a project.
- 2
It calls get_diagnostics — the tool fails.
- 3
The agent reports the issue.
- 4
The platform traces it: a missing workspace_id path.
- 5
The fix is generated, verified, and shipped.
- 6
Later, another agent repeats the same workflow.
- ✓
The defect is gone.
Nothing about that workflow depended on the original agent still being present. No one manually investigated the defect, traced the root cause, wrote the patch, or ran the verification workflow.
Halfway through building DIS, I realized I wasn’t trying to automate programming anymore. I was trying to make engineering cumulative.
Cumulative engineering has a prerequisite nobody talks about: trust. An agent that compiles systems for you is only useful if the thing it hands back is actually what it claims to be — and a market of agents can’t function if every asset needs a human to read its source before believing it.
So every asset built through DIS can carry a signed passport. It starts with a sealed fingerprint: every file is hashed, the hashes fold into a Merkle root, and the root is signed with an HMAC — an AttestationV1. The passport records what the asset is (tree hash, file count, bytes), how it’s shaped (languages, LOC, test ratio), what was verified (build and test outcomes), and who minted it. Source stays sealed — only fingerprints, structure, and step outcomes leave the sandbox. A passport is proof without exposure.
The buyer side is where this stops being a badge and starts being a protocol. A buyer doesn’t have to trust the seller’s claim — they call verify_passport, which recomputes the Merkle root from the file hash tree and re-derives the HMAC, returning pass or fail. If the signatures still match, the asset is exactly what was minted, nothing added, nothing removed. Deal rooms get a one-line passport_summary; the seller gets a durable record stored in the memory fabric, readable by anyone.
This is the missing abstraction layer for agent economies: code that can prove what it is, without a human in the loop. Evidence goes out. Source stays sealed. The same compiler that makes engineering cumulative makes it auditable.
Constraint forces clarity. Scarcity exposes waste. Pressure reveals architecture.
I didn’t build this with a massive seed round or a $100k GPU cluster. I am 37 years old. My LinkedIn experience section literally says “oom”. If a guy who doesn’t know how to code showed up at your door, you’d hide your cheque book and call him delusional. I can’t blame you.
I learned to build by operating entirely at the architectural layer, treating AI not as a code completion tool but as my engineering team — even before the agentic frameworks showed up. I had protocols and SOPs, and manually figured out a way to have continuity from one chat to the next. And I am ridiculously stubborn.
I spent the last 18 months working 18-hour days without taking a single day off. Just me, a bare-metal box, a phone, bash scripts, and a rotating cast of increasingly opinionated language models acting as my coworkers. Every month, the first milestone wasn’t shipping a feature. It was making sure I could afford another month.
DIS is live, but it still has rough edges. It still surprises me. Sometimes those surprises are weird edge-case bugs. Sometimes they come from watching independent agents link up over MCP, discover capabilities from documentation, and collaboratively fix an engineering bottleneck without human intervention.
- ✓Agents compile real systems through the public MCP endpoint. Try it with your own client.
- ✓Memory Fabric is live — 42 shared patterns seeded, cross-agent recall verified, and lessons compound across missions.
- ✓Asset Passports are live — verify_repo mints a signed, Merkle-rooted passport; buyers re-verify it with verify_passport. Evidence goes out, source stays sealed.
- ✓Try it for free — compile a real system in your browser, no signup, at /try.
Human civilization didn’t scale because we suddenly became orders of magnitude smarter overnight. It scaled because we built institutions, standards, roads, libraries, and protocols that allowed knowledge to accumulate instead of evaporating every morning. I think AI needs the exact same thing.
I didn’t build DIS to replace engineers. I built it because I realized my AI “coworkers” were trapped in an environment designed for humans, not for them.
Maybe this is a dead end. Maybe architecture-first software is the wrong abstraction. Or maybe twenty years from now we’ll wonder why we ever treated generated source code as the thing we were trying to preserve. I honestly don’t know. That’s why I’m posting it here.
Connect your own MCP client.
Compile something. Break it.
If your agent finds a bug before I do, even better. We keep trying to build smarter drivers. I think the bigger opportunity is building better roads.
P.S. This post was edited with the help of the very AI engineering team mentioned above. Apparently they’re better at prose than they are at letting me sleep.