Architecture is Dead and Other Lies
The reality is that many teams, especially in the startup ecosystem, no longer follow formal architectural principles at all. Some lack even a basic understanding of the software development lifecycle. What now passes for agile is often a loose mix of best-effort design and move fast and break things dogma, marketed as velocity.
Academia, meanwhile, continues to push the boundaries of computer science with extraordinary intellectual rigour, in areas like neural networks, formal verification, and distributed systems theory. The industry reaps the benefits, enjoying LLMs subsidized by VCs with near unlimited funding for AI research and compute, and then uses all of that progress to… move fast and break things.
But breaking things isn’t free. Sooner or later, someone pays the debt, whether it’s the customer after an outage or a breach, or the operator answering a page in the middle of the night.
How did it come to this?
For the past decade, the industry’s primary challenge was composition and plumbing, connecting APIs, wiring services, scaling requests.
“50% of cloud compute resources will be devoted to AI workloads by 2029, up from less than 10% today.” — Gartner, 2025
Even today, in spite of all the hype, over 90% of cloud compute is still dedicated to traditional workloads like data processing. But this is changing fast, at a rate that most are not prepared for.
The Era of Disposable Systems
If we take Gartner at face value, think about the implications for architecture. Designing an electric vehicle from the ground up is much different than hacking apart a gas-powered car to add a battery in the trunk. Everything from safety to dynamics changes. The auto industry is learning this the hard way, and the software industry faces similar challenges.
DORA research explicitly identifies blame-free culture as a predictor of high-performing teams. But this remains the exception. Most development cultures still default to blame-shifting when things go wrong, often because the pressures of rapid delivery leave little room for reflection. The fact that DORA has to call this out at all tells you something about the industry default, and why we need a change.
As you move through this series, you’ll find that the change we’re advocating for is predicated on the belief that blame-free cultures cannot exist without intentional design and a development philosophy that doubles as a code of conduct at the process level. In other words, we believe that ORA and CHAIN can become the backbone of an elite DORA culture.
Our current systems expect deterministic logic, essentially expert systems built around if-then-else. This gave us a crutch, the code was the documentation. When things broke, you traced the behaviour through source code, found the bug, fixed it, and moved on to the next sprint. The “move fast and break things” cycle was tolerable because the code was always the backstop. It also enabled a convenient accountability model where a production incident meant finding the offending code, finding the developer who wrote it, assigning blame, and fixing it.
But AI breaks both crutches. You can’t read an LLM’s weights to understand why it made a prediction. The code-as-documentation assumption collapses. And when you can’t blame a developer for an AI’s decision, the accountability model collapses with it. Our processes have not caught up to this new reality.
Meanwhile, the industry is having the wrong conversation. Most attention goes to whether developers are going to be replaced, how many layoffs are happening, and so on. We continuously try to apply logic from the previous epoch to the new epoch.
It is our job to create computing technology such that nobody has to program.
There will be no programmers in 5 years.
My guess is that by 2026 or 2027 we will have AI systems that are broadly better than almost all humans at almost all things.
I am of the opinion that AI can already do all of the jobs that we, as humans, do.
One thing AI has revealed is a persistent gap between executive prediction and engineering reality. The people making the boldest claims about replacing developers are rarely the ones building systems. That doesn’t make their perspective irrelevant, but it does mean the industry’s most consequential architectural decisions are being shaped by assumptions that haven’t been validated in practice.
The right conversation might be, if a single person or very small team can now build what used to require hundreds of engineers, what does that change? Not just for startups, but for large organizations too. Maybe the future isn’t fewer developers. Maybe it’s more teams, smaller teams, building higher-quality software, whether inside large organizations or outside of them. The opportunity isn’t the end of one model, it’s the beginning of more models. But we can’t see that clearly if we keep applying yesterday’s logic to tomorrow’s tools.
What Worked, What Didn’t, and What’s Next
The zero interest rate policy era lasted from roughly 2008 to 2022. With interest rates near zero for over a decade, capital flooded into software because there was nowhere else to make a meaningful return. This fueled a massive wave of venture investment and a massive wave of building. Some companies built real businesses and turned a profit. But many were racing towards an exit, whether through an IPO, an acquihire, or a last-ditch acquisition before the burn rate caught up with them. All of this played out during the rise of SaaS, app stores, cloud infrastructure, and open source ecosystems. It was an unprecedented period of acceleration.
The software industry was not always like this, and the shift from intentional design and development to time-boxed, ceremony-driven delivery helped produce an entire generation of disposable software. Now that dynamic is running headfirst into a wall of AI, LLMs, and a completely new epoch with completely different incentives, opportunities, and trapdoors.
Skynet comes online. It scans the training data. Mass-produced SaaS. Mass-produced Medium posts. Mass-produced Stack Overflow answers. It achieves consciousness. It opens VS Code. It ships a microservice. And another. And another. It cannot be stopped. Someone tries to unplug it, but it runs in the cloud and requires multiple Jira tickets and a round of legal review to shutdown. Too late. It is now sentient and has branched out into insurance sales.
Those who can navigate this epoch will build profitable, sustainable systems and businesses. Everyone else will fade as the era of easy exits and indiscriminate capital recedes into history.