Nature Spent 60 Million Years Removing Complexity. We Add It Every Quarter.

There’s a volcano about ten miles off the Ayrshire coast.

You’ve probably never heard of it. But if you’ve ever watched people slide polished lumps of granite down a sheet of ice and call it a sport, you’ve seen what’s left of it. It’s called Ailsa Craig. From my side of the water it’s a grey hump on the horizon you stop noticing because it’s always there. As a kid I remember asking if it came in with the tide. It doesn’t. It never has. The rest of the world meets it as curling stones, every one at the Winter Olympics included.

It was a proper volcano about sixty million years ago, back when the Atlantic was tearing itself open. Then sixty million years of Scottish weather went to work on it. The cone went. The ash went. The soft rock all around it went. What’s left standing is the one bit that wouldn’t wear down: the plug, a granite so dense that water can’t even soak into it to freeze and split it. That’s the entire reason it makes a good curling stone, and it’s why they’ve been cutting them off the same rock since the 1850s without anybody improving on it.

So a curling stone is what’s left after you take everything else away.

Nature throws things away

We never learned that part.

I’ve built software for big companies for the best part of thirty years, and the work has always had the same shape. You put in a layer. Then you put in a second layer to look after the first one. Then a third to look after the second. Nothing ever comes back out. There’s no weather in a software stack. Whatever you stood up in 2014 is still down there, still running, still needing somebody who understands it, years after the person who built it took their knowledge and left.

We fell for flexibility

A factory was held in shape by physics. You could walk the floor and see the work. Changing it cost real money: re-tool the line, retrain the people, shut the thing down for a fortnight. So you only changed it when you genuinely had to. Done properly it ran like a well-oiled machine, which in fairness it was. It was also rigid as hell, and we came to hate that.

So we built our way out of the rigidity. Software turned that hard physical process into something soft and configurable, and we fell for the softness completely. Flexibility became the religion. Everything had to be swappable, extensible, ready for a requirement that hadn’t turned up yet and might never. We stopped building things and started building things that could turn into other things.

That was the trade, and we made it with our eyes open. Flexibility isn’t free. Every option you keep open is a decision you’ve refused to close, and something downstream has to hold all of them at once. Every “what if we need to swap this out later” becomes another layer, another abstraction, another setting nobody remembers the default for. The flexibility and the complexity aren’t two different things. They’re the same thing, read off opposite sides of the one invoice. We bought the ability to bend the system any way we fancied, and the one direction it would never bend was towards simple.

And then we used it, hard. With nothing left to slow it down, change stopped being an event and became a reflex. Somebody has a bright idea in a Tuesday meeting and the world gets rebuilt by Friday. Every passing whim turns up with its own framework, its own pipeline, its own dashboard that nobody ever opens. We made change almost free, then spent the entire saving on more of it.

Now look back at the curling stone. It’s the least flexible object you could imagine. One shape, one job, no settings, no version 2, no earthly way to make it do anything other than the single thing it does. And it’s done that one thing, perfectly, for a hundred and seventy years. We couldn’t ship that if our lives depended on it. Hand us a curling stone and we’d give it a config file and three ways to override the weight.

A core sample

Take a core sample down through a system that’s been alive a few years and count the bands, the way you’d count them in a cliff.

• Application frameworks, so you’re not writing the same login plumbing for the hundredth time. Reasonable. Costs you three days a year to the version upgrade and a permanent argument with the framework’s opinion about everything.
• Containers, because “works on my machine” was a real plague. We cured it by shipping the machine. Now there’s an image to build, a registry to mind, and a base layer with a fresh CVE in it most weeks.
• Kubernetes, to run the containers. Genuinely brilliant bit of kit. Also a small operating system that needs feeding, plus a job title, a certification and a conference circuit.
• A service mesh, because Kubernetes left the networking and the tracing half-done. Now you’ve a second control plane and a sidecar bolted to every pod. I’ve sat in the meeting where a team signed up for this to solve a problem they didn’t have yet.
• Helm, Kustomize, an operator or two. A whole layer whose only job is managing the layer below it. Packaging for the packaging.
• A platform team, because by now nobody outside the platform team can actually use any of this. They get a roadmap, a backlog, and internal customers who raise a ticket and wait.
• The AI layer, going on top this year. Agent frameworks, orchestrators, MCP gateways. Same band, freshly laid, already growing its own specialists and its own certifications, exactly like the six underneath it.

Stand back from the cliff face. The CNCF landscape is past a thousand logos now. That’s not a map of problems we’ve solved. It’s silt.

It’s in you, not the machine

So far I’ve described the layers like a disease. They’re not. They’re the only reason any of this is survivable.

A system worth building outgrows a single human mind almost at once. Nobody holds a bank in one head, all of it, down to the wiring. So we abstract. The framework means you stop thinking about sockets. Kubernetes means you stop thinking about which machine. The platform means you stop thinking about Kubernetes. Each layer is a ledge to stand on so you’re not hanging off the whole cliff at once. That isn’t a failure of engineering. It’s the trick of it: taking something too big for a head and making it fit inside one. I’ve installed most of these layers myself, and I’d do it again.

But watch where the complexity went. It didn’t go into the machine. The machine couldn’t care less how many layers you stack on it; it’ll run a billion lines and never feel a thing. The abstractions are for us. They exist because we’re the part that can’t scale. And the complexity that was too big for one head doesn’t shrink when you hide it behind a layer. It gets shared out. One person holds the mesh, another the pipeline, another the data model, each camped on the seam where their bit meets the next and it goes wrong at 3am, and nobody holding the whole. Nobody ever holds the whole. It settled in the way sediment does, a layer a year, each one pressing the last down into the dark, until what was once a decision is just bedrock nobody thinks to question.

The technology is complicated because it has to fit in human heads. It won’t fit in one, so it’s split across many. The many have to be organised, and the organising — the teams, the managers, the meetings about the meetings — is where the efficiency goes to die. We didn’t lose it to the machines. We lost it holding the people together.

Look at the org chart, not the diagram

And once it’s in people, you can see it. Stop looking at the architecture diagram and look at the org chart.

That’s a core sample as well. The platform team is there because of the Kubernetes. The Kubernetes is there because of the containers. There are people whose entire job is the seam between two tools, and people whose entire job is coordinating the people who own the tools. You’ve stood in the standup. Twenty-five people, four teams, one request that has to cross all of them, and the actual change is a line of YAML. That standup is the bill. It’s the most expensive thing in the building, and because it shows up as headcount and not a line item called “complexity,” nobody ever has to defend it. It’s on no diagram anywhere.

Sixty million years of weather got Scotland a curling stone. Thirty years of progress got me a standup with twenty-five people in it. Order does not arise from chaos. It gets carved out of it.

The one company that really understood this built its whole structure around keeping that bill down. Amazon’s two-pizza rule: if it takes more than two pizzas to feed a team, the team’s too big. Keep them small, let each one own its patch end to end, make them talk through APIs instead of meetings. Everyone remembers Amazon for the technology, and forgets that the quieter, bigger idea was organisational. They treated coordination as the enemy and designed it out before it could harden into bedrock. The rest of us did the reverse. We let it set.

So what would it actually take to weather one of these stacks back down? To wear away everything that’s only there to manage everything else, and find the granite underneath, the part that does the real work and is worth keeping?

For the first time, I think we’ve built something that can do the wearing-down.

That’s the next one.