I have spent years inside software projects. Not demoing them. Not writing about them. Not just selling them. Inside them, cleaning data, untangling legacy systems, watching what happens after the keynote ends, and the vendor leaves.
What I have seen does not match what gets written about technology.
Different Softwares, Similar Ending
Three kinds of software keep showing up in my work.
The first is the ambitious one. Someone had a real vision. Early builds were promising. The founder believed in it, the first vendor believed in it, and for a while, there was genuine momentum. Then the runway shortened. Patience ran out, the founder’s, the vendor’s, or both at once.
The product never reached production. Not because the idea was wrong. Because the gap between a working pilot and a working product is where dreams go to get quietly archived. The code still exists somewhere. The Jira board is still open.
The second is the industry workhorse from the 1990s. Built for a specific problem, it solved that problem completely. For decades, without complaint, generating revenue with no serious competition. They held the system. Defended it. Retained and retrained people on it rather than adapting. They skipped the web. They skipped mobile. They skipped modern UI and UX. Each time, the system was good enough, the migration was too expensive, and the urgency was not quite there.
Then AI arrived in 2024, and every skipped wave became a debt due simultaneously. Decades of confidence became panic. Not rebuilding. Rushing. Every new feature is now archaeology.
The third is the legacy system that simply works. Unit economics are fine. It does what it does. But the company grew. New leadership arrived with a fresh budget and a mandate to modernize. New positions formed around new initiatives.
The easiest way to show results is to build something visible on top of what exists. Do not fix what exists. An API here. A middleware wrapper there. A modern dashboard pulling from data that the underlying system was never designed to expose cleanly. The system collects the sediment of every leadership cycle that passes over it without replacing it.
The path is always different. The result is the same. Somewhere along the way, the foundation got discredited.
The Wave Is Real. The Pilot Is Rushed.
None of these waves was wrong. Cloud migration was necessary. On-premise infrastructure had real limits. Microservices were necessary. Monoliths had real scaling problems. Mobile was not a hype. It was a genuine shift in how humans interact with information. Every wave arrived as a solution to a real problem.
The hype began the moment the wave stopped being a technical solution and started being a corporate mandate. That is when systemic incentives took over. Vendors needed to hit quotas, consultants needed billable hours, and the actual problem got lost in the noise. Demand was manufactured. Not invented from nothing, but inflated far beyond the actual problem it was solving.
Organizations under pressure not to be left behind funded pilots for problems they had not fully diagnosed. Clean scope, demo date, narrative. It worked because pilots run on clean data and the best people on the team. The demo went well.
Then someone asked what the migration costs were. Not the pilot. The actual migration. Data sanitization. Decoupling systems that were built tightly coupled because that was faster at the time. That number has no demo. It cannot be explained in a slide. So it went to the next budget cycle. And the next. Eventually, a new wave arrived, and the migration became less urgent. Surely the new wave would make it unnecessary.
The pilot joined the graveyard. The foundation absorbed another layer and kept running.
PHP was supposed to die when Ruby on Rails arrived. Then again, when Node.js arrived. Then periodically for fifteen years after that. It is still running a significant percentage of the internet. COBOL was declared dead in the 1990s. Banks are paying hundreds of dollars an hour for COBOL developers today because nobody trained replacements during the decades it was supposed to be dying.
This is not a failure of technology. It is what happens when supply creates demand instead of following it. The real work never gets funded because manufactured urgency always arrives first.
AI Is Not Different. It Just Won’t Admit It.
AI feels different. That feeling is precisely the problem.
Every wave felt different from inside it. Engineers who migrated to the cloud in 2010 genuinely believed they were participating in something categorically new. The blockchain teams of 2017 were not cynics performing hype. They believed. Feeling different is not evidence of being different. It is evidence of good marketing meeting a real incremental improvement.
These waves were incremental improvements that the industry packaged as a new era. There was only digitization, moving into new domains, solving new problems, wearing new names.
The 1990s ERP digitized the paper ledger. The mobile app digitized the physical storefront. The recommendation engine digitized the instinct of a good salesperson. The AI agent is digitizing rote cognitive labor: pattern recognition, repetitive decision-making, and first-draft production. We are always encoding something human into something that runs without a human present.
AI won’t admit this because it doesn’t feel like it. You are not clicking a button. You are having a conversation. It feels like intelligence, not automation. The denial runs deeper here than in any previous wave, and the resistance to calling it digitization is stronger for it.
Remove the feeling, and the same dynamic appears: supply has outgrown diagnosed demand. Organizations rush pilots. Foundations get ignored.
ChatGPT integrations became the wrong architecture within eighteen months. RAG pipelines became obsolete before most organizations finished building them. Agentic workflows are already being called naive by the people who were selling them a year ago.
Every wave now arrives before the previous wave’s invoice has been paid.
The Sediment Is the Architecture Now
If your organization has run three transformation initiatives in five years and the same system is still running underneath all of them, you are not behind on transformation. You are ahead on sediment.
The next wave will not fix this. It will add another layer. At some point, the weight of unlaunched pilots and half-finished migrations becomes the actual architecture. Nobody planned for that.
That admission is the beginning of fixing something.
Stop funding the pilot. Fund the foundation. Use the tools you have for the work that matters. The data that was never cleaned. The systems that were never documented. The dependencies nobody mapped because the wave always made it feel unnecessary.
There are tools capable of doing that work at speed now. AI, applied to the foundation rather than the demo, maps legacy dependencies, surfaces undocumented logic, and cleans data at a scale that was previously unaffordable. The most overhyped technology in a generation turns out to be most useful precisely where it is least being applied.
The vibe always changes. The foundation is always what it was. Fix it now, while you have the means. Or keep explaining to the next wave why the demo worked, and the migration didn’t.
