ADL vs UML

TL;DR: UML is the cautionary tale that motivates ADL, so this is the article where the series’ thesis lives or dies. Model-Driven Architecture (the 2000s dream of generating systems from UML models) failed, comprehensively, and the industry drew the wrong lesson from the wreckage. The lesson people took was “modeling doesn’t work; just write code.” The actual lesson, visible in the mechanics of the failure, was narrower and more useful: generation doesn’t work. The moment generated code exists, it gets edited; the moment it’s edited, regeneration is destructive; from then on the model and the code diverge and the code wins, because the code is what’s in production. ADL inverts the failed step. It doesn’t generate the application from the model — it interprets the model as the application, so there is no second artifact to win. This lesson matters more in 2026 than it did in 2006, because AI agents have industrialized exactly the thing MDA died of.

---

What UML got right

Start with the credit, because the standard sneering at UML skips over how much of it was correct.

UML’s diagnosis was sound: software’s essential complexity lives in its structure and behavior, not its syntax, and that essence deserves a representation above the code. Class diagrams captured real things: entities, relationships, multiplicities, the shape of a domain. State machine diagrams captured real things too. The UML statechart formalism is genuinely rigorous, and any ADL state machine would be recognizable to anyone who drew one in 2004. Even the unloved OCL (the Object Constraint Language bolted on for invariants) was reaching for something real: constraints as declarations on the model rather than assertions buried in code.

Read that list again: entities, relationships, state machines, declared constraints. It’s an ADL feature list, sketched twenty years early. The modeling instinct was right. What failed was everything downstream of the model.

The mechanics of the MDA failure

Model-Driven Architecture was OMG’s program to make the models matter: platform-independent models, transformed into platform-specific models, transformed into code. CASE tools had sold the same dream in the late eighties; MDA was the standards-grade second attempt. Both died the same death, and the autopsy is precise.

The round-trip problem. Generation covers the structural skeleton: classes, fields, method stubs. The behavior, the actual application, gets written by hand inside the generated artifact. Now regeneration threatens hand-written work, so tools invented protected regions, merge strategies, “round-trip engineering”: an entire genre of tooling whose existence proves the architecture was fighting itself. Every team eventually faced the same choice: stop editing the code (impossible: the code is where the missing 80% goes) or stop regenerating (which everyone did). The model froze at the moment of its last generation and became documentation. Stale documentation. A lie with diagrams.

The abstraction gap. UML could express structure richly and behavior only ceremonially. There was no serious way to declare “owners may edit their own drafts; editors may edit anything,” or “this transition requires a resolution note and stamps the closing timestamp,” or “total commitments may not exceed 100%.” The semantics that make an application an application had no home in the model. So they went into the code, which guaranteed the code contained things the model didn’t, which guaranteed divergence even before the round-trip problem finished the job.

The audience inversion. Because models drove nothing at runtime, keeping them current was unpaid work with no forcing function, and unpaid work without a forcing function does not get done. Developers, correctly, prioritized the artifact that shipped.

Note what’s absent from this autopsy: any evidence that modeling was the mistake. Every failure mechanism is downstream of one decision: that the model would be realized by generating a second artifact and letting humans finish it.

Inverting the failed step

ADL keeps UML’s diagnosis and reverses its prescription. The model isn’t transformed into an application. The model is interpreted as the application, by a runtime, on every request.

Each MDA failure mechanism, revisited under interpretation:

The round-trip problem doesn’t exist, because there is no generated artifact to edit. Change the model, resubmit it, and the runtime diffs it against the previous model and migrates (schema and behavior) atomically. There is no protected region because there is no region.

The abstraction gap is answered by making the language carry what UML couldn’t: permissions down to field level, guarded state transitions with required fields and side effects, cross-field validation, cross-record policy, computed fields, workflows, history. This is where the “forty chapters of semantics” earns its keep. An interpreted model is only as good as what the language can say, and the language has to say everything the runtime enforces, because nothing else does.

The audience inversion reverses itself: the model is current because the model is what’s running. Reviewing the model is reviewing the system. The forcing function that UML never had is the runtime itself.

And where the model genuinely can’t express something, ADL does what UML’s action semantics never credibly did: it draws an explicit boundary and provides sandboxed hooks (Lua) inside the pipeline — before-write logic that can compute or abort, subject to the same transactional discipline — rather than pretending the model is total or surrendering the remainder to an ungoverned codebase next door.

One boundary worth drawing honestly: there does exist a code generator in this ecosystem (ADLGen: the same YAML can emit a conventional FastAPI/SQLAlchemy codebase). Isn’t that MDA again? As an operating mode, it would be. You’d inherit the round-trip problem within a week. Its role is the opposite: an exit. If you ever leave the runtime, you leave with a conventional codebase generated from your spec, and from that moment the code is the system and the spec is retired. Generation as a one-way door out is honest; generation as a development loop is the thing that killed MDA.

Why this lesson matters more now

MDA generated code from models at human speed, and the two-artifact divergence took months to rot a project. In 2026, AI coding agents generate plausible code from prompts at industrial speed, and a prompt is a model too, just an unversioned, unreviewable, semantically undefined one. The cost of producing code has collapsed; the cost of owning it (reviewing, securing, migrating, understanding it in three years) has not moved. Agent-era code generation is MDA’s failure mode with the throughput turned up: more artifacts, produced faster, from specifications nobody can point to afterward.

The alternative isn’t to slow the agents down. It’s to give them a target worth generating: a specification with defined semantics, small enough for a human to review, precise enough for a runtime to enforce. An agent that emits fifty thousand lines of Python has produced a liability someone must now own. An agent that emits four hundred lines of ADL has produced a reviewable claim about the system, and the runtime, not the agent’s confidence, decides what it means.

Where UML is simply better

One concession, and it’s genuine: UML remains a fine communication medium. A whiteboard class diagram or a sequence sketch is often the fastest way for humans to align on a design, and nothing about ADL replaces the whiteboard. The failure of UML-as-source-of-truth says nothing against UML-as-conversation. Sketch in boxes and arrows; specify in something that runs.

The one-line version

UML modeled the right things and realized them the wrong way. ADL keeps the model and deletes the generation step — the model doesn’t describe the system or produce the system; it is the system.

Next in the series: ADL vs EXPRESS/STEP, the thirty-year-old language that proved rich declarative modeling works, and shipped everything except a server.