Software is being democratized. The cost of building just collapsed in a way most people haven't fully processed yet. Anyone with an idea and access to an AI agent can ship a product. What used to take a team of twenty and six months now takes one person and a weekend. That's not hype. It's happening right now, everywhere, all at once.
But here's what nobody's talking about. The systems underneath all of this are buckling. And the people responsible for keeping them running are either overwhelmed, undervalued, or being replaced entirely. We're entering an era where everyone can build, and almost nobody understands what they've built.
That's not an AI problem. It's an identity crisis that's been growing inside software engineering for years. AI just ripped the cover off.
Software used to be something you could wrap your head around. You knew what server it ran on, what database it talked to, what data center it lived in. That era has been gone for a while now. We scaled, broke things into pieces, adopted every cloud service and managed platform we could find, and when the complexity got unbearable we started stacking layers on top. Infrastructure as code, GitOps, CI workflows. The pitch was always the same: encode the complexity, make it manageable, sleep at night. It happened so gradually that nobody noticed how deep they were until they were already underwater.
What came out the other side wasn't engineering. It was bureaucracy wearing an engineering costume. Configuration scattered across dozens of tools, each owned by a different vendor, each showing a narrow slice of reality. The daily work shifted from shaping systems to keeping machinery lined up. And we just accepted it, because the way we value work in this industry never caught up either. The teams keeping systems alive today are visible and rewarded. The teams doing the quiet work of making sure systems don't need saving tomorrow get ignored. Nobody promotes the team that prevented the outage. Leadership retells the 4 a.m. hero story. We say we value reliability but promote throughput. Prevention matters, right up until the budget conversation. Then we fund response.
None of this is new. The complexity, the configuration bloat, the broken incentives, all of it predates AI by years. What AI did was pour gasoline on it. Teams that shipped weekly now ship continuously. Architecture decisions that took weeks happen in minutes, all because the cost of writing code is collapsing overnight. But the cost of understanding that code, what it actually does to a running system, hasn't moved at all. If anything it's gotten dramatically worse, because now the author doesn't even know why they made their decisions. And while all of this is happening, the number of people responsible for keeping things working is shrinking, not growing. We've created a supply chain crisis where we're producing far more than we can actually handle.
Change is up 30x while understanding is dropping, and the gap is widening every quarter. It's the same mess we've always had. It's just moving fast enough now that all the little tricks we used to play on ourselves have stopped working.
Great engineering is not deployments. It's not monitoring, not dashboards. It's understanding. Knowing how the pieces connect, who owns what, how changes spread, and where risk has quietly been building for months until it suddenly matters.
What should make everyone very hopeful is the foundation of great engineering isn't missing. It's scattered across every tool your organization already pays for. What's missing is anyone putting it together. Engineers jump between dozens of tools and rebuild the picture in their heads every time something goes wrong. That picture decays the day they leave, breaks apart across teams, and is always slightly wrong in exactly the ways that surface under pressure.
And this is about to get so much worse. We're heading into a world where AI agents outnumber engineers 50 to 1, each one shipping code and deploying changes faster than any human can track. When one engineer could barely keep up with what ten humans were changing, what happens when that same engineer is responsible for understanding what fifty agents are doing to a live system at the same time? The old ways of keeping up don't just get harder. They become physically impossible. Monitoring can tell you something went wrong. It can't tell you why, or what changed, or who owns the thing that broke. Understanding isn't a nice-to-have in that world. It's the only thing standing between a running system and chaos.
... continue reading