The Constitution of Software

Every three months a new model arrives — everyone gets it. The difference lies one layer down: design system, directives, tests, and Smart Caches. Part two of the series reads software like a constitution and asks the question that puts every architecture to the test: What's left if all the code is deleted tonight?

SeriesParadigm ShiftPart 2 of 5
June 16, 2026 17 min
AI agentsAI developmentMeta
This post was originally written in German. You are reading a translation.

Every three months, the industry is reborn. A model drops, timelines glow, benchmarks tumble, and a thousand meetings resolve to finally rethink everything from scratch. It's the most reliable ritual of the agent era — and its greatest misunderstanding. Because the faster the leaps come, the less any single leap decides: what everyone gets sets nobody apart. The model everything revolves around has by now become the most interchangeable component in the stack — more fungible than any library, shorter-lived than any framework. What isn't interchangeable sits one layer down — and looks suspiciously like homework.

If you're competing with agents in 2026, you're not competing on models. You're competing on constitutions.

The Napkin

A web form over coffee and cake

Summer 2024, birthday party of a couple we're friends with — old friends from college, the food was phenomenal, and at some point the group sat outside in the courtyard on beer tent benches, between leftovers, glasses, and the children's coloring books. I took one of their colored pencils, wiped a few cake crumbs off a napkin, and roughly sketched a web form: a few fields, a few steps, arrows in between; in one of the boxes I simply scribbled: “Table with last name, first name, date of birth, six demo records.” That's how you tell friends what you are currently building.

Watercolor of a beer tent set in a garden: on the wooden table a paper napkin with a hand-scribbled form sketch — table with last name, first name, date of birth and six demo records —, next to it colored pencils, an open notebook, a coffee cup, a partially eaten cake and a champagne glass.
The napkin that held everything: a form made of colored pencil, among coffee, cake, and a champagne glass. The form remained on the paper — the intent moved on.

Then I photographed the little work of art with my phone and sent the photo to my bot — an assistant who knew my first draft of a semantic design system: the components and the instructions on how a bot should use them. It read the sketch, built the data object from it, and passed it on to the UI builder. A few minutes later, a finished web form lay on the phone screen: multi-step, functional, compliant with the design system. The phone made the rounds, between coffee cups and a genuinely good, partially eaten cake.

The remarkable part wasn't the speed but what the system left out: it didn't copy the sketch. The crooked lines, the colored-pencil aesthetic — none of it made it into the form. The system recognized what the thing was — a wizard with these steps, fields with this meaning, a process with this skeleton — and rebuilt it by the rules of its design system. The scribbled box with its single sentence became a real table: three columns, six demo rows, exactly as noted. The form stayed on the napkin. The intent arrived.

In 2024, this amazed everyone at the table. Today it is — my own read from practice, not industry statistics — the standard among those who practice agentic coding seriously: you build a framework, design system included, feed in specifications, and out comes a web product. “The Foreign Service” asked about the external law between agents, about passports and credentials; this essay writes the internal law of the software — and begins where all law begins: with the question of what should apply. The answer from that evening in the courtyard has held ever since: the system preserved the intent, not the form.

Two Valid Skepticisms

A defense of the eye-rollers

Anyone rolling their eyes at this point has good reasons — two kinds of them, actually.

The first skepticism will be familiar to anyone who has survived a design system initiative. Not that the idea was wrong — on the contrary: I've been building design systems for years and consider them central to any product meant to scale. The skepticism was never aimed at the idea. It was aimed at what usually became of it in practice. For three waves, this genre was built, celebrated, and buried: style guides created for audits that shone in pitch decks; component libraries whose maintenance nobody budgeted for after launch; token architectures that exactly one team understood — and then that team left. The magnificent volume on the shelf: printed, signed, and unread. (The term “living document” carried a burden of proof in those years that it rarely met.) Whoever said “window-dressing fluff” wasn't describing the idea, but its standard case.

The second skepticism is more recent and sits deeper: the suspicion that the model is everything after all. It too was justified. As long as model leaps were the only source of new capabilities, model-hunting was simply the correct strategy — whoever had the better model won, and everything else was decoration. For a while, the fetish was simply true.

Both skepticisms, then, were completely right — until something shifted that had nothing to do with quality. The style guides didn't get better, the models didn't get any humbler. What changed was something else: who reads.

The design system never had a quality problem. It had a reader problem.

The Second Reader

What has changed — and it was not the humans

The reader who was missing all those years has arrived. They just aren't human. Before every task, a machine reads the project's artifacts — design system, documentation, directives. Not by plowing through everything front to back; that would be a waste. It reads the table of contents and works its way from there — via ontologies, references, links — to exactly the spot the task requires. No fatigue, no silent agreement that nobody needs chapter three anyway; but no blind trudging either. Developer Experience and Agent Experience merge into one: what this second reader can't find no longer exists for production.

At the same time, the speed ratio every engineering culture was built on has reversed: generating is now faster than understanding. This breeds massive software structures that no human can fully see through anymore. Generated in a single afternoon, they become tomorrow's digital ruins.1

Take it as a rule of thumb: models double their practical capabilities roughly every three months. If that's even approximately true, an uncomfortable calculation follows: whoever owns only code owns the artifact that loses value fastest — a snapshot of what the generation before last considered a good solution. This is where the real divergence of this era opens up: the model leap devalues code at exactly the rate it revalues constitutions.

The Constitution

Preamble, norm, standing instructions, contract, case law

So what is this constitution that survives the leap? Let's read it the way lawyers read a constitution — from the beginning. It consists of four artifact classes and a preamble, and none of them are code. All five are aggregate states of the same substrate: Intent.

The Preamble — Intent

Every constitution begins with a sentence that enforces nothing and justifies everything. “We the People” becomes “I the user” in the software constitution: recorded here is the purpose all norms serve — word for word, not summarized. The same mechanism runs in both directions: the user articulates what they want, and the application unfolds around it; the developer articulates what should apply, and the agents build to it. A small experiment shows how quickly the exact wording gets lost: tell an agent “build me a square,” and it builds a square. Tell a second one days later, and you get a rectangle — the four-sidedness came through, the actual condition got lost along the way. The preamble is where “square” stays until someone changes it with justification. The intent drives things forward; what makes it durable comes further down. Because a preamble enforces nothing — but without one, no norm knows what it's for.

The Norm — the design system

Then the constitutional text itself begins. The norm of a piece of software is its design system, understood as a generative source: it determines what may be generated in the first place — and shares little more than a name with the old style guide for humans. That's exactly what was on display on the napkin in the courtyard — the system read the sketch against its norm and rebuilt it in compliance with the design system. The closest relative is older than you'd think: for years, WAI-ARIA has been giving screen readers a purely semantic description of what an interface means, decoupled from its presentation.2 The design system of the agent era is the same promise to a new addressee. Keep the norm purely semantic, and you can ultimately even swap out its renderer without touching the application core. The norm includes the legal definitions: a hierarchical glossary in which every term is defined in exactly one layer and deeper layers only reference it — “for the purposes of this constitution, a wizard is …”. Without it, the terms drift — and the agents drift with them.

And the norm answers a question that never used to exist: when does building actually happen? Three cadences are on offer — pre-build, where specifications solidify into a static product; on the fly, where every user gets their own rendering; and a hybrid that weaves the two together. Pre-build freezes, on the fly flows, the cache decides the aggregate state. As a rule of thumb for sorting them: texts are more volatile than layouts, layouts more volatile than semantic contracts. One of these three cadences, though, is more than a technical option — it's a value decision; more on that in a moment. What remains to note is the division of labor: the norm determines what software is allowed to become. What it looks like is a matter of interpretation afterward.

The Standing Instructions — Directives

Norms don't enforce themselves. Enforcement falls to the directives: standing instructions3 that every agent reads before every task. Their substance is use cases, networked documentation, and first principles — material in which an agent finds a reason to stop even when the conversation has long since flattered its way off course.

I can show how this discipline is learned with one of my own scars — not a single one, more a pattern that repeated across many projects. A model's first plan was never the best. So I had it improved: “Make it watertight.” That worked — and reliably tipped into the opposite. The agent kept on waterproofing, long past the actual task, losing sight of the goal and all sense of proportion. My one-sided watertight directive was a failed directive: it knew only one pole. Out of this grew a ritual in three prompts — first the plan, then “make it watertight,” then “go over it again and cut everything that's over-engineered.” Trim the Fat. Whether two separate instructions really beat one combined instruction, I never cleanly A/B-tested. My impression says yes. The lesson stands either way: directives are allowed to hold contradictory poles in the same manifest — the tension isn't an inconsistency, it's built-in self-correction that the agent processes as a loop.

One language guideline from my learning portal shows what this looks like in production: it settles what gets translated and what doesn't, how proper names are handled, which character set applies, how technical terms stay consistent — written cleanly once, read by every translation agent before every task. Today, a stable five percent of visitors read the portal in Easy Language — which simply wouldn't exist without this directive discipline. The scar and the portal teach the same thing: a directive with only one pole is drift with an official seal.

The Contract — Tests

In software history, tests were the canary in the coal mine: tolerated, occasionally fed, and the first thing cut when in doubt. In the constitution, they move into the position of the contract — the only artifact class that verifiably survives a model leap. The reasoning is older than any AI. Nietzsche had his Zarathustra declare that one human at best almost understands another — machines included. Complete understanding is not to be had. What is to be had: the exact wording, recorded syllable for syllable — what the user said, what the developer said, every “I”. Wording turns into requirements, requirements turn into tests. And if something doesn't fit in the end, the cascade runs backward — from the red test via the ticket to the original statement and its subtext, the same mechanism that ran through the agent world in the previous article as “back-propagating”. None of this changes classic requirements engineering, and that's no side note: clarifying requirements remains the discipline. Tests are their executable final form4 — the step where acceptance criteria take on machine form, whether as specification tests, broad property tests, mutation testing, or persona-driven end-to-end runs. Test and code are separate instances here — one holds the goal, the other executes and reports back. A red test is, if you will, a successful constitutional complaint.

A test is the only requirement that cannot lie.The Contract Clause

Case Law — Smart Caches

That leaves the question of what happens to the judgments. Smart Caches are the constitution's case law: the best valid solutions available, not to be changed without justification. What's preserved is what was recognized — the wizard type, the field semantics, the process skeleton. The appearance, from pixel layout to raw input, stays out. A solution enters the cache the way a case enters court: only once frequency, tests, and security checks have been passed and a justification is on file is it elevated to precedent — and it's only downgraded on the record. The reasoning behind the judgment comes from Architecture Decision Records, which sit right next to the code instead of in some distant system that only full-text search ever sees again: the cache is the executable half of the precedent, the ADR the reasoned half — and the agent reads both in the same place. Why all the effort? Because the pressure comes from four sides at once: untested things must not roll out, human approval needs a stable state, the user's mental model needs recognizability, and every unnecessary regeneration burns money.

This also makes good on the value decision from earlier. The question isn't when you need a cache. The question is which parts of your application leave no room for fluidity — where two faces of the same function would be a breach of trust. The hybrid from the norm chapter gets its mechanics here: the cache is pre-build material on an on-the-fly substrate. And yes, forgetting needs regulating too — otherwise the case law becomes a memory of old mistakes. What remains is the short legal form: a cache is a decision against fluidity — made, justified, on the record.

The Deletion Question

Four artifact classes, one preamble. If this feels like a toolbox, a thought experiment helps — one that leaves no tools behind.

Tonight — say, at three o'clock — your organization's entire codebase gets deleted. Every line. Months or years of implementation — gone. What burns is everything a last-generation model wrote. What doesn't burn, if it exists: the preamble with the recorded intent, the norm, the standing instructions, the contract, the case law along with its justifications.

What remains of your software if you delete all the code tonight?The Rebuild Test, in one question

The Rebuild Test

Cities burn, land registries do not

Anyone who has a constitution answers the question with surprising calm: they rebuild — as a process, with a plan, the way cities were rebuilt after fires as long as the land registries and building codes survived.

There's a name for this: Rebuild Affordance — a system's capacity to be rebuilt from its constitution at any time, by any sufficiently good model. The Rebuild Test is the most honest measure of maturity a software organization can apply today: hand the new model the norm, directives, tests, and intent — and have it rebuild the same thing. If the new build upholds the contracts, you have in days what used to be a migration roadmap spanning quarters: modern code that verifiably does the same thing. This is exactly where an old anti-pattern flips. The Big Bang Rewrite — the boogeyman generations of architects have rightly warned against — becomes a real option: when a model twice as good arrives every three months and a rebuild takes days instead of years, rebuilding suddenly becomes a decision you can make — no longer a fate you suffer.

And it reaches further than it first appears: once the rebuild becomes trivial for your own software, it becomes trivial for the software you've been buying, too. What that means for the vendors — for entire business models that rested on the toil of rebuilding — is the subject of the next part of this series: “Cold on Demand”. Until then, the benchmark itself is enough: rebuildability is the proof that a constitution holds — and the only proof that can be executed.

Six Questions for Your Stack

Monday morning, first coffee

You don't check something like this in strategy workshops; you check it on a walkthrough with your own set of keys. Six questions for Monday morning:5

  1. Can an agent read your design system — or only your frontend team? If the norm lives in Figma screenshots6 and convention folklore, it does not exist for the second reader.
  2. Does your test suite survive a model leap — or does it test implementation details? Contracts bind to behavior; whoever tests internals has signed the contract with the wrong partner.
  3. Does every agent read your latest directive change before every task — or does it lie in a wiki that no one opens? A standing instruction that doesn't hang at the workplace is an anecdote.
  4. Which part of your application is never allowed to have two faces — and where is that recorded? If the answer is “in the team's head,” it's a no.
  5. If a model twice as good appears tomorrow: how many days until your stack benefits from it? The number is your constitutional maturity in days.
  6. Do your decision justifications lie where the agent works — or where management searches? Precedent without findable justification is superstition with a version number.

Anyone who answers yes to all six no longer needs a constitution — they've had one for a long time.

Compound Interest

Market, profession, and an uncomfortable question of ownership

Now zoom out. If constitutional maturity decides how much of each model leap actually arrives, then it compounds: the same new model generation triggers a wave of returns for the team with a constitution — rebuilds, modernization, freed-up capacity — and a wave of rework for the team without one. The gap between the two widens with every leap — and never asks about the talent of anyone involved. It's the same protection mechanism that shielded the human from their agent in “The Foreign Service”, just built one layer deeper: there, a recorded wording kept the proxy on course; here, it keeps the product on course while the generator underneath gets swapped out. And with the work, the profession shifts: whoever builds software today writes its code less and less — and its constitution more and more.

Which makes one question uncomfortably concrete: if intent is the only asset left, who actually owns it — the one who had it, or the one who wrote it down? The accounting rule, though, already stands: models depreciate. Constitutions compound.

The Discarded Document

The napkin from the courtyard, by the way, no longer exists. It got crumpled up that same night and followed the cake scraps into the trash — nobody noticed, me included. The form from back then is long since history, a showpiece from a single evening. What stayed is this way of building. What was on the napkin had left the paper long before: the intent. It lives on in the design system — from there, the exact same form could be rebuilt on any given afternoon. The drawing was only its vehicle for one evening.7

So go ahead and celebrate the next model leap — it will be remarkable again. Just don't confuse the gift with the asset.

You receive your next model as a gift. No one writes your constitution for you.The accounting rule of the agent era
  1. This is how I described it in Basiswissen Künstliche Intelligenz (Chapter 6: The Art of Prompting).
  2. W3C, Accessible Rich Internet Applications (WAI-ARIA) — a W3C standard since 2014: a semantic description layer that communicates the role, state, and meaning of UI elements to screen readers independently of their presentation. Twenty-five years of accessibility work turn out, in retrospect, to be a dress rehearsal for machine-readable interfaces.
  3. This genre only got a name late in the game: agent frameworks now package such standing instructions as “skills” — reusable instruction packages that an agent pulls as needed. In 2024, there was neither the term nor the product for it.
  4. The nice derivation — “test” from Latin testis, the witness — is historically shaky, unfortunately: more likely the word comes from testum, the clay vessel in which precious metals were tested for authenticity in the fire. For our purposes, both readings win. A test is a witness that tests your gold in the fire.
  5. If you feel a slight twinge reading the six questions: that isn't rhetoric. That's your backlog.
  6. My conviction: every software company should already be serving its design system through an in-house MCP server — machine-readable, versioned, queryable by the agent. Figma has figured this out and ships its own MCP server to go with it — which only shifts the question: if you prototype directly with the real production components, do you even need the drawn in-between thing anymore?
  7. Writing and maintaining such constitutions has long had a name: Code Context Engineering. What this discipline means for every career in building software is the subject of “The Book of Hours”, the final part of this series. One question stays open along the way, and it's bigger than it looks: who actually writes it in your own shop.

Plain Language

This preview is in Plain Language. The whole portal is also available in Plain Language. You can change the language at the top. Or use the button below. Our Plain Language texts are AI-assisted and editorially reviewed. They follow the core principles of easy-to-read language, but they are not certified Easy Read: a review panel of people with learning difficulties does not test them.

Preview: The Constitution of Your Software

What it's about

A new AI model comes out every three months. All companies get it. Something else makes the difference. I call it the constitution of the software. It contains the fixed rules for the AI.

A sketch on a napkin

In 2024, I draw a form on a napkin. I send a photo of it to my AI helper. A few minutes later, the form is done. The helper knows my design system. A design system sets how everything looks.

What belongs in the constitution

First comes the goal of the software. Then comes the design system. Directives are fixed work rules for the AI. Tests check if everything works correctly. You keep good solutions as examples to follow.

The big test

Imagine: Tonight, all of your code is deleted. Do you have a good constitution? Then the AI rebuilds everything. Without a constitution, the work is lost.