2026.05.04
A company I worked at became flush, and as a celebration decided the next logical move was rewriting most of the customer-facing platform. Not because it was failing, but because it was outdated, and the people now in charge of it didn't fully understand it. Rewriting it was the version of "getting their arms around it" that came with the budget of the buyout. They spent over two years on rewriting it until leadership finally pulled the trigger on deploying it, just to stop burning time and effort maintaining two systems. The next six months were spent rediscovering edge cases the old system had quietly handled. The refactor had come up short and the cost was customer trust.
I've watched the smaller version play out a dozen times since. Someone inherits a service they didn't write, too expensive to keep on, hard to model, difficult to grok in general, and instead of doing the slow work of breaking it apart in their mind and understanding it, they swap it for one that aligns with how they think it should behave. Eight months later they rediscover the five edge cases the old one quietly handled. This happens a lot with intake systems, where there's a dozen rules on how to correlate, look up, match, and ingest data. The move underneath all of these is the same. We talk about it as reducing complexity on the problem, but it's reducing cognitive load on the people. The old system is the expanded form of years of production reality. A mental model of how it ought to work is the compressed form. Replacing the expanded form with the compressed form is information loss, with a clean repo as the receipt.
It's hard to push back on because comprehensibility feels like correctness. Code you understand reads as code that's right. "Aligns with our mental model" lands as a virtue rather than a tell. Capital makes it worse. A flush org has a hard time pitching maintenance from confidence; stewardship reads small, rewrite reads as ambition. (Joel Spolsky has been yelling about this since 2000.) What it costs isn't just the capital and the year(s) spent climbing back to par. It's the institutional memory the old system was holding for you, and the instinct it teaches everyone watching: that not understanding something is a license to replace it rather than an obligation to learn it.
The pattern shows up outside code too. The loss of words over time, because the meaning gets compressed into the most efficient, singularly inclusive term; using the modern single love where the Greeks had multiple words for nuanced interpretations (agape, philia, storge). How we used to chop pieces out of people's bodies because we didn't think they were necessary (tonsils, appendix, gallbladder). Though I think my favorite instance of this is ecosystems: a term still wholly in use, completely overloaded by the reduction of all the similar words around it. We used to walk into a forest and think that if we put in X wolves and Y deer and Z plants, it would all become self-sustaining. We've since learned the nuance of nature is past our grasp. The way I hate this the most is how we now think a child sitting in a chair wondering about the world is unhealthy, and that they need structured fun, because we believe we understand the output of structured fun.
It strikes me that with LLMs we're constantly trying to pack every token of context we can into the window. Why don't we approach the rest of our lives like that?
