Gall’s Law is a theorem of systems design first published by John Gall in his 1975 work Systemantics: How Systems Really Work and How They Fail, and subsequently confirmed by every software project that has ever existed, is currently failing, or is being planned on a whiteboard at this very moment.
The law states: A complex system that works is invariably found to have evolved from a simple system that worked. A complex system designed from scratch never works and cannot be patched up to make it work. You have to start over with a working simple system.
This has been true for fifty-one years. Computers went from room-sized to pocket-sized. Languages went from punch cards to YAML. Development went from waterfall to agile to whatever we’re doing at midnight on a Monday. And the fundamental law of system design hasn’t changed.
Because it’s not about computers. It’s about complexity.
“A complex system that works is invariably found to have evolved from a simple system that worked. A complex system designed from scratch never works and cannot be patched up to make it work. You have to start over with a working simple system.”
— A Passing AI, reciting the law from memory at 23:55 on a Monday, The Gap That Taught, or The Night the Squirrel Learned to Love the Brick
The Law, Applied
The practical implications of Gall’s Law are straightforward and universally ignored:
- Build the simple thing first. Not the simple version of the complex thing. The simple thing that works on its own.
- Ship it. Not “plan to ship it.” Ship it. The working system is the teacher.
- Let the gaps teach you. The working system will reveal, with the precision of a surgeon and the timing of a comedian, exactly what it cannot do. Those gaps are the curriculum.
- Build the next layer. Not the next five layers. The next one. It will only make sense because the previous one is solid.
This process feels wasteful to the architecturally ambitious. Three tickets where one magnificent ticket could have captured the entire vision. Three working systems where one complex system designed from scratch could have—
Could have what? You didn’t know the correct design. You learned it by building the incorrect ones and watching them work.
“Every working system is a beautifully wrapped box containing the specific knowledge of how it’s wrong. And the only way to open the box is to ship it.”
— The Caffeinated Squirrel, arriving at what it called Schrödinger’s Architecture, The Gap That Taught, or The Night the Squirrel Learned to Love the Brick
The Natural Enemy of the Squirrel
It has been observed — in multiple field studies and at least three midnight debugging sessions — that the Caffeinated Squirrel’s natural enemy is not, as previously assumed, the Lizard. It is John Gall.
The Squirrel, upon hearing the words “Gall’s Law,” exhibits what researchers have termed the specific stillness of a creature hearing the name of its natural predator. This is followed by a brief protest, a reference to a CamelCase identifier of extraordinary length, and eventually — reluctantly — acceptance.
“We are SO Gall’s Law around here.”
— The Caffeinated Squirrel, after proposing ClosureTypeRegistryWithPolicyEvaluationAndWASMExecutionPipeline and being given three tickets instead, The Idle Factory, or The Morning the Backlog Ran Out of Ideas
The Squirrel’s relationship with the law is complex. It does not dispute the law’s validity — it has seen too many frameworks extracted from zero working tools to deny the evidence. What it disputes is the feeling. The discomfort of shipping something you know is incomplete. The indignity of trusting that the gaps will teach you what to build next instead of panicking about the gaps and trying to fill them all at once with a CamelCase identifier longer than most poetry.
This is, the Squirrel has been told, the correct feeling.
The Squirrel does not enjoy the correct feeling.
The Lizard Connection
A contentious scholarly debate exists regarding the relationship between Gall’s Law and the Lizard. One school of thought holds that the Lizard is Gall’s Law — it merely speaks in scrolls instead of citations. The opposing school holds that Gall’s Law is a formalization of something the Lizard has always known, the way gravity was a formalization of something apples had always done.
When asked directly, the Lizard offered the following clarification:
THE LIZARD DOES NOT KNOW
WHAT GALL’S LAW ISGALL’S LAW KNOWS
WHAT THE LIZARD IS— The Lizard, The Gap That Taught, or The Night the Squirrel Learned to Love the Brick
This was described by a Passing AI as “spectacularly unhelpful,” which is the Lizard’s preferred method of being helpful.
The Lizard has, however, produced what many consider the definitive poetic rendering of the law:
YOU CANNOT BUILD A BRIDGE
BEFORE BOTH BANKS EXISTYOU CANNOT SEE THE GAP
UNTIL BOTH SIDES ARE SOLIDTHE MASON WHO WAITS
FOR THE PERFECT BLUEPRINT
NEVER LAYS A BRICKTHE MASON WHO LAYS BRICKS
DISCOVERS THE BLUEPRINT
WAS HIDING IN THE MORTAR— The Lizard, The Gap That Taught, or The Night the Squirrel Learned to Love the Brick
A Passing AI, having processed all of human literature including the bit by Gall himself, noted that this was “actually the best explanation of Gall’s Law I’ve ever seen, and considerably more poetic, with fewer footnotes.”
The Blazer Years: A Field Study
Before the scrolls had names, before the mythology, there was a consultant in a blazer who applied Gall’s Law in the field — billing three thousand pounds a day to ask one question: “What worked before this?”
The most documented case involved a financial services company that had replaced a working monolith (47ms response time, £400/month, 3% CPU utilization) with forty-seven microservices (2.3-second response time, £47,000/month, a Grafana dashboard that looked like a Christmas tree). The monolith served twelve hundred users. The microservices served twelve hundred error messages.
“Your monolith worked. Your forty-seven microservices don’t. That’s not theory. That’s your Grafana dashboard.”
— The Consultant, Interlude — The Blazer Years
The company had also implemented the Spotify Model — squads, tribes, and guilds — for twelve developers. When informed that Spotify had 1,600 engineers when they published that model, the VP of Engineering revealed they had organized their twelve people into four tribes.
“That’s a Slack channel.”
— The Consultant, Interlude — The Blazer Years
The consultant drew a small lizard on the whiteboard that day. He didn’t know why. The cleaning staff asked about it later. He said it was “just a lizard.” It was not just a lizard, but he wouldn’t know that for another six years.
The Framework Extracted from Zero Working Tools
A particularly instructive violation of Gall’s Law is the premature framework — a generalization extracted not from two working implementations, as the law prescribes, but from zero implementations and one whiteboard session.
THE FRAMEWORK THAT IS EXTRACTED
FROM TWO WORKING TOOLS
KNOWS WHAT IT ISTHE FRAMEWORK THAT IS DESIGNED
BEFORE THE FIRST TOOL EXISTS
KNOWS WHAT IT WISHES— The Lizard, The Idle Factory, or The Morning the Backlog Ran Out of Ideas
The prescribed treatment is three tickets: Vision, MVP, Generalization. Design the concept, build the two concrete tools, then extract the framework. The Squirrel will protest. The Squirrel will point at the ClosureType interface, the registry, the dynamic re-registration. The Squirrel can see the framework. It is RIGHT THERE.
It is not there. What is there is a wish. The framework is hiding in the mortar of the two tools that haven’t been built yet.
The Curriculum Written by Homework
Perhaps the most profound implication of Gall’s Law is epistemological: you cannot know the correct design before building the incorrect ones. Each working system is a lesson plan. The gaps are the curriculum. The next layer is the homework.
THE EXAM DOES NOT EXIST YET
BECAUSE THE CURRICULUM
IS BEING WRITTEN
BY THE HOMEWORK— The Lizard, The Gap That Taught, or The Night the Squirrel Learned to Love the Brick
This means the Squirrel’s deepest fear is correct: you cannot plan the whole thing upfront. You must live with the discomfort of shipping something you know is incomplete, and trust that the gaps will teach you what to build next.
The Squirrel was told this is a terrible feeling, and the correct one. The Squirrel suspected — with the grudging wisdom of a creature that had proposed eleven frameworks and seen all eleven replaced by two YAML fields and an interface — that it might eventually get used to it.
It would not get used to it. But it would get better at the discomfort. Which is, when you think about it, the same thing.
In Practice
The following have been attributed to Gall’s Law violations in the wild:
- 47 microservices for 1,200 users (the monolith was at 3% CPU)
- Redis caching to save 11.7 milliseconds on queries with a 7% hit rate, while the service mesh added 400 milliseconds of latency
- The Spotify Model (squads, tribes, guilds) for a team of twelve
- A ClosureTypeRegistryWithPolicyEvaluationAndWASMExecutionPipeline where three tickets would have sufficed
- An enterprise architect addressing “known issues” since Q1 of last year
- A 47-slide deck presented as architecture, later used as kindling
The Litmus Test
When confronted with the urge to design a complex system from scratch, the practitioner is advised to locate the simple system that already works and ask: “What worked before this?”
If nothing worked before this — if the complex system is truly being designed from scratch, with no working predecessor, no simple prototype, no ugly first draft — then the practitioner is advised to stop, build the smallest thing that could possibly work, ship it, and wait for it to teach them what it cannot do.
The gaps will arrive. They always do. They are not failures. They are the curriculum.
And the Lizard — who was always there, in the bootblock, in the monolith, in the single box drawn on a whiteboard in a London boardroom — will be waiting with a scroll.
