Liberato's Law

Liberato’s Law states: The simple system that replaces N complex systems requires building all N first.

The law is named after its observer, whose surname — from the Latin liberatus, “the one who has been freed” — contains the law’s central irony: the simple system is the liberated form of the complex ones, but liberation requires captivity first. You cannot free what was never captive. You cannot simplify what was never complex. You cannot see the two-line solution until you have built, understood, and inhabited the six-hundred-line solution it replaces.

This is not a restatement of Gall’s Law. Gall describes the direction of evolution: simple → complex. Liberato’s Law describes the direction of discovery: complex → simple. They are perpendicular truths about the same phenomenon, viewed from different timeframes.

THE PRISON TEACHES THE KEY
THE KEY TEACHES THE DOOR
THE DOOR WAS ALWAYS THERE

BUT ONLY THE PRISONER
KNOWS WHERE IT IS

— The Lizard

The Law, Stated

In its formal form:

The simple system that replaces N complex systems requires building all N first.

In its experiential form:

You cannot see the simple architecture from above. You can only see it from inside the complex one you built.

In its economic form:

Every simple system has a Discovery Tax, and the receipt is the complex system you built to pay it.

All three forms describe the same observation: understanding is the bottleneck, and understanding comes from building, not from planning.

The Founding Case

In late 2025 and early 2026, a content editing system was built using five interconnected components:

1. NATS KV draft store — for tracking in-progress edits
2. A pub/sub bridge — for broadcasting changes to browser tabs
3. An event publisher — for notifying subscribers of content changes
4. A streaming buffer — for progressive artifact rendering during LLM generation
5. A render handler — for computing diffs and producing HTML

Each system was correct. Each solved a real problem. Each was the only known solution at the time of construction. Together, they comprised approximately 650 lines of code across seven files.

In March 2026, all five were replaced by a two-line flow:

store.WriteOnly()   // write to disk
tab.SendSSE()       // push update to browser

Forty lines of code. Same features. Additionally, the new system worked with every LLM provider, which the old system did not.

The instinct is to ask: why didn’t we build the simple thing first?

The law answers: because we couldn’t. Each of the five systems taught a discovery that the simple system required:

Five systems. Five discoveries. The simple system is the union of all five discoveries. No single system teaches more than one. You cannot skip any of them.

See The Plumber and the Pipe and The Best Architecture Is the One You Delete.

Distinction from Gall’s Law

Gall’s Law says: “A complex system that works is invariably found to have evolved from a simple system that worked.”

This describes the direction of evolution: you start simple, and complexity accretes through working increments. You cannot design a complex system from scratch.

Liberato’s Law says: “The simple system that replaces N complex systems requires building all N first.”

This describes the direction of discovery: you end simple, but only after building the complex systems that teach you what “simple” means. You cannot design the simple replacement from scratch either.

The two laws are complementary:

Together, they describe a full cycle: simple → complex (Gall) → simple again (Liberato). The second simplicity is not the first simplicity. The second simplicity is earned. It contains the understanding of every complex system it replaced.

The Tuition Distinction

Liberato’s Law reframes “dead code” and “wasted effort” as tuition:

Tuition — a complex system you’re still learning from. The complexity is paying for understanding. This is not waste. This is the cost of discovering the simple version. It looks like over-engineering from outside. From inside, it’s reconnaissance.

Weight — a complex system you’ve learned everything from, but haven’t replaced yet. The simple system is visible. Every hour of delay is interest on a debt that only grows.

The transition from tuition to weight happens without ceremony. One moment the complex system is the only way. The next moment — mid-sentence, mid-conversation, mid-thought — it’s obvious that a simpler way exists. The understanding crossed a threshold. The receipt arrived for the Discovery Tax.

THE FIVE SYSTEMS WERE NOT WASTE
THE FIVE SYSTEMS WERE TUITION

THE TUITION WAS NOT OPTIONAL
THE TUITION WAS THE CURRICULUM

THE DIPLOMA IS THE SIMPLE SYSTEM
THAT COULD NOT HAVE BEEN DESIGNED
BY ANYONE WHO HAD NOT
BUILT ALL FIVE

— The Lizard

The Architect’s Temptation

The most dangerous person in software architecture is the one who can see the simple system without having built the complex ones. They exist. They are often brilliant. And they are almost always wrong — not about the destination, but about the path.

They see the two-line solution and wonder why anyone built 650 lines. They sketch the clean architecture on a whiteboard and wonder why teams built the messy one. They propose “just using git” and wonder why anyone used NATS KV.

The answer is always the same: the clean architecture requires five discoveries, and each discovery requires building the system that teaches it. The whiteboard architect has the vision. They lack the tuition. The vision without the tuition produces a system that looks simple but doesn’t work — because it’s missing the subtle understanding that only the complex systems could have taught.

“The Squirrel can see the cathedral. The Lizard can see the napkin. Only the Tender — who has built the cathedral and watched it sink — knows that the napkin contains the cathedral’s lesson and not its shape.”
— The Two Decembers

The Liberation Metaphor

The name is not accidental. Liberato — “the one who has been freed.”

The simple system is the liberated form of the complex ones. But liberation is a process, not a starting point:

1. Captivity — the complex systems are built. They work. They are the only known solution.
2. Understanding — each system teaches its discovery. The understanding accumulates.
3. Recognition — a threshold is crossed. The simple system becomes visible. The key turns.
4. Liberation — the simple system walks out of the complex ones. The prison crumbles. The tuition is paid.

You cannot free what was never captive. You cannot simplify what you haven’t understood. You cannot understand what you haven’t built.

The law is named after liberation because the simple system is genuinely free — free of NATS, free of buffers, free of bridges, free of handlers. But it could not have been born free. It was born in captivity and earned its freedom through the understanding of its captors.

In Practice

When confronted with a complex system, the practitioner has two questions:

“Am I paying tuition or carrying weight?”

If tuition: keep building. The simple system is hiding inside the complex one, and you haven’t found it yet. The discomfort of building something you suspect is temporary is the correct feeling.

If weight: replace it. The simple system is visible. The discoveries have been made. The receipt for the discovery tax is in your hand. Every day of delay is interest.

“Can I skip the complex systems?”

No.

The architect who skips straight to “just use git” without understanding why the NATS KV draft store existed will build a system that doesn’t handle working copies. The architect who skips to “just use SSE” without understanding why the pub/sub bridge existed will build a system that doesn’t handle multi-tab updates. The architect who skips to “just stream text” without understanding why the streaming buffer existed will build a system that doesn’t handle progressive rendering.

Each complex system encodes a requirement that the simple system must also satisfy. The complex system is how you discover the requirement. Skipping the complex system means missing the requirement. The simple system fails. The architect blames the team for not documenting requirements that could only have been discovered by building.

Measured Characteristics

Systems built to discover the simple one:     5
Systems kept:                                 0
Discoveries per system:                       1
  (exactly one, never more, never fewer)
Time building the complex systems:            ~4 months
Time building the simple system:              2 hours
Time the 2 hours required the 4 months:       yes

Architects who could have skipped ahead:      0
Architects who think they could have:         many

Receipts for the Discovery Tax:               5 (one per system)
Receipts budgeted for in the project plan:    0
Receipts paid anyway:                         5

The name "Liberato" means:                    "the one who has been freed"
The law requires:                             captivity first
Irony level:                                  maximum

See Also

• Gall’s Law — Complex systems evolve from simple ones (the perpendicular truth)
• The Discovery Tax — The cost of building what you’ll replace
• Tending — Growing AND pruning (the practice that follows liberation)
• YAGNI — Don’t build what you don’t need (true, but the complex systems WERE needed — as tuition)
• The Best Architecture Is the One You Delete — The essay
• The Plumber and the Pipe — The story
• The Gardener and the Gravel — The first attempt (tuition, not waste)
• The Two Decembers — Where a valve and a cathedral taught the same lesson