Imagine you have a very large estate.
It’s old, but it has been well lived in.
Over the years, people have made adjustments to it. Not because they were following some grand architectural vision, but because they lived there. They adapted it to reality.
Maybe they added closets where they realized storage was always lacking. Maybe the kitchen was expanded at some point because the original layout stopped making sense for the family using it. Maybe there’s a little bridge over a ditch because people got tired of tracking mud through the house every time it flooded.
There are conveniences everywhere.
Paths people naturally walk. Rooms people instinctively know how to navigate. Bathrooms exactly where people expect them to be. Tiny adjustments accumulated over decades because somebody discovered friction and removed it.
Now imagine that someday a new technology appears.
Some kind of nanotech construction system that makes building a new estate incredibly fast and incredibly cheap.
Not free. But cheap enough that rebuilding the entire estate suddenly becomes a serious option.
So somebody says:
“Well, the kitchen is outdated anyway. Let’s just rebuild the entire thing from scratch next door.”
And because this new technology is so powerful, they can do it astonishingly fast.
They carefully catalog everything:
- five bedrooms
- three bathrooms
- guesthouse
- large kitchen
- pantry
- office
- storage rooms
Every specification is accounted for.
Then they build the new estate.
And everybody moves in.
At first, everything seems fine. Maybe even impressive.
But then reality starts showing up.
People keep opening the wrong doors because the bathrooms aren’t where their instincts expect them to be anymore.
The pantry technically exists, but it’s in a less convenient location relative to the kitchen workflow people had unconsciously developed over years.
Somebody realizes there isn’t nearly as much usable storage space as they thought there would be, even though the square footage is almost identical.
The ditch between buildings still exists, but nobody rebuilt the little bridge because nobody thought about it during planning. It wasn’t part of the official estate specifications. It was just something people discovered they needed after years of living there.
So now they build the bridge again.
And then another path… another convenience, and then another.
Because the old estate did not merely contain architecture, it also contained adaptation.
Construction is not adaptation
This is what I think about when people talk about rebuilding entire platforms in the age of AI. AI changes the economics of construction. It may soon become possible to rebuild enormous systems in days or weeks that once would have taken years.
But construction is not the same thing as adaptation.
A mature software platform contains thousands of tiny adjustments made in response to reality:
- operational knowledge
- user habits
- debugging workflows
- accessibility improvements
- navigation expectations
- support procedures
- edge-case handling
- performance trade-offs
- institutional memory
Some of these things are documented, but many are not.
Some only exist because a team lived with the system long enough to discover where the friction actually was.
This is also where I think we have to be careful about the difference between complicated and complex.
Some systems are complicated because the domain itself is complicated. A tax engine, a permissions model, a reporting system, a deployment pipeline, a compiler. These things may have a lot of moving parts because the underlying problem has a lot of moving parts.
Rebuilding them does not necessarily eliminate that difficulty. It may only recreate it in a new shape.
But mature platforms also accumulate something different: adaptive complexity.
That is not just the difficulty of the original problem.
It is the complexity that emerges from real use.
It comes from the path people actually take, the workaround that became a workflow, the support process that grew around an edge case, the accessibility fix that made the system usable for someone who otherwise would have been blocked, the debugging ritual that exists because a team knows where the dragons live.
And that matters because AI may make it much easier to generate complicated structures.
But adaptive complexity still has to be discovered through contact with reality.
A well-maintained mature platform is not necessarily “legacy” in the pejorative sense people often use today.
Sometimes it is simply a city that people successfully learned how to live in.
And yes, there are absolutely cases where a full rebuild makes sense. Some systems truly are no longer maintainable. Some architectures become so resistant to change that replacement becomes cheaper than continued adaptation.
But I increasingly worry that the falling cost of software generation is going to make organizations underestimate the value of accumulated adaptation.
Because once rebuilding becomes easy, people start treating mature systems as though they are merely piles of features.
They are not… they are lived-in spaces.
I believe the better long-term strategy is not “tear down the estate.”
It may be:
“How do we make it easier to replace the kitchen next time?”
How do we create cleaner boundaries?
How do we isolate the parts that need to change?
How do we modernize pieces without forcing everyone to relearn the entire house?
How do we preserve the accumulated adaptation while still making progress?