I have read Denis Stetskov’s "The Great Software Quality Collapse: How We Normalized Catastrophe", which made me think.
He points out how we’ve slowly come to accept things that would have been unthinkable twenty years ago:
🤡 a calculator app leaking dozens of gigabytes of memory,
🤡 everyday tools using tens of gigabytes of RAM,
🤡 updates that break essential functions,
🤡 and AI systems producing code riddled with vulnerabilities.
The point isn’t about a single bug - it’s the culture. It looks like we built layer upon layer of abstraction, optimized for development velocity, and normalized inefficiency along the way.
I think (and hope) we could be seeing the start of a counter-movement in response.
A few examples hint in that direction:
🌟 Casey Muratori has been writing and speaking about the performance cost of abstraction and the limits of "clean code" when it turns into slow code.
🌟 David Heinemeier Hansson (DHH) and 37signals decided to leave the cloud entirely, owning their hardware again and reportedly cutting costs significantly.
🌟 A few smaller engineering teams are experimenting with leaner stacks and fewer frameworks, less container orchestration, and more direct code-to-hardware paths.
I like these small experiments towards simplicity and efficiency.
Here’s how a counter-movement might look like:
💡 Fewer layers of abstraction (fewer frameworks, fewer containers, fewer micro-services) in favor of more direct, efficient code.
💡 More emphasis on resource usage (RAM, CPU, I/O) as key engineering metrics instead of just features shipped.
💡 More demand for low-level programming skills: memory management, concurrency, algorithmic efficiency, etc, instead of just "AI generation" of code.
💡 Quality and maintainability regaining priority over raw development velocity and shipping slower but better.
💡 Organizations recognizing the risk that relying entirely on AI tools and high-level layers may leave them brittle when the overhead or failure surface grows.
💡 "Green software" is mostly a regulatory and reputation-driven effort but with the expected increase in energy use from data centers (specially from AI) and grid expansions taking years, we could see a shift from "sustainability as a moral/regulatory goal" to an actual operational bottleneck. That could be another push for leaner, closer-to-the-metal code.
It would be nice to shift the culture a bit and value craft over complexity, efficiency over abstraction, and understanding over automation. Part of it is nostalgia for the old "unbureaucratic" days but also a practical way to build that doesn’t collapse under many layers.
Any others seeing (or hoping for) this too?