The Criticality Shift, Part 1.

But something shifted. We started feeling it late last year when Opus 4.5 dropped. When projects like Gas Town, Beads, and GSD hit the scene. The models got a bit better, the harnesses caught up, the tooling evolved to meet the moment. And that combo unleashed something. Solo devs shipping what used to take teams. Whole systems standing up in days instead of months. The promise of agentic coding stopped being a promise.

So... is software development changing forever? Are the traditional devs right, or are they missing the moment?

Those aren't even the right questions. The right question is simpler and harder: what do we even mean when we say "software"?

Everyone talks about AI writing code. Almost nobody is talking about what kind of code it's writing, and why that matters more than the code itself.

Here's the thing most people get wrong about the new software engineering paradigm: they treat all software like it's equal. A bash script that saves someone an hour a day is not the same as a payroll system processing checks for 100,000 employees every month. Treating them the same is where most of the confusion lives.

Criticality is a composite index to summarize the overall complexity of a given software system. It consists of the following constraining attributes: number of users, speed and latency requirements, complexity of the problem, reliability expectations, and accuracy demands.

On the low end, you've got personal scripts, one-off automations, bespoke tools for a single person or a small team. Few users, low complexity, and honestly, nobody cares if it takes a few extra seconds to run.

In the middle, you've got the world of SaaS. Business software. Departmental tools. Hundreds to thousands of users, moderate complexity, reasonable performance expectations. Think about how many SaaS products exist that people actually use. It's north of 10,000. That's where most of the software in the world has lived for the past two decades.

At the high end, you've got Google. AWS. Global financial infrastructure. Millions of simultaneous users, extreme complexity, sub-second performance requirements. Or even systems like the software running the Mars Rover or dialysis machines. Very few discrete systems exist at this level. But each one is highly critical. People notice when it's down, lives are significantly affected, lots of money is lost.

Historically, software has not been evenly distributed across this spectrum.

What happened at the low end? Almost nothing. If you needed a tool that did one specific thing for you, or for your three-person team, you either hacked something together yourself (if you could code) or you didn't have it. The economics just didn't work. Nobody was going to fund a development team to build a custom tool for five people.

Meanwhile, the high end of the criticality spectrum was also relatively sparse, but for different reasons. Building Google-scale infrastructure is extraordinarily difficult and extraordinarily expensive. Only a handful of companies in the world have the resources and talent to operate at that level.

The result was something like a bell curve, concentrated in the middle. The mid-range is where the math worked. That's where SaaS happened. That's where enterprise software lived. That's where 10,000 products compete to somewhat-poorly solve problems for broad audiences.

And that "somewhat-poorly" part is important. Because the economics of SaaS force a particular design philosophy: build for the many, not the few. A SaaS product has to be general enough to serve thousands of customers, which means it's never quite right for any of them. Every user makes compromises. Every company bends its workflows to fit the tool instead of the tool fitting the workflow.

What changed? AI coding tools, specifically LLMs and agentic coding workflows, have made it possible to produce simple functional software in a single prompt. One shot. Or a few shots at most.

And more complex software is now being built with agentic harnesses like Claude Code that shift the capability of software creation into the hands of people who previously were nowhere near software developers.

Think about what that means for the low end of the criticality spectrum. The entire reason that zone was empty was economic: it cost too much to build software for a small audience. That constraint just evaporated. If you can describe what you need and get working code in minutes, suddenly it's viable to build a tool that only five people will ever use. Or one person. Or a tool that gets used once and thrown away.

This isn't theoretical. It's happening right now. People are building bespoke internal tools, personal automations, custom dashboards, one-off data transformers — things that would never have justified a development sprint, let alone a product team. The long tail of software is being unlocked.

The area of the chart with low criticality is suddenly exploding. It is a completely new kind of software that has the potential to fundamentally change how we build and use software. And this shift isn't just about adding a new category — it's reshaping the entire landscape. It effectively cannibalises the previously meaty centre of the software world.

Think about why people buy SaaS products. Not because they love the product. Because it's the closest available approximation to what they actually need, and the cost of building something custom was prohibitively high. Remove that cost barrier, and the calculus changes completely.

The mid-range isn't going to disappear overnight. Complex, high-user-count SaaS products with deep integrations and network effects will stick around. But the long tail of mediocre SaaS products — the ones that survive because the alternative was "build it yourself" and most people couldn't? Those are vulnerable.

So the new distribution doesn't just have a bigger left tail. It has a slightly deflated middle. Bespoke is eating generic. Custom is replacing compromise.

That's the demand-side story. But there's a supply-side story that's equally important, and it's about capability.

In 2022 and 2023, AI code generation was reliably good at the very low end. Simple scripts. Single-function utilities. One-file automations. One-shot generation. This was genuinely useful, but it was a narrow slice of the spectrum.

By 2024 and into 2025, the capability frontier moved significantly. Agentic coding workflows can now produce multi-file applications. Full features. Complex interactions. Things that would have previously required a small team and a few sprints.

And it keeps climbing. Today, we're seeing AI systems start to handle orchestration, multi-service architectures, complex state management. Not perfectly, not without human oversight, but reliably enough to be genuinely useful for systems of real complexity.

At some point, the question becomes: where does it stop? Mission-critical, Google-scale infrastructure? That feels like it's still firmly in human territory. For now. But "for now" is doing a lot of work in that sentence.

Two things are happening simultaneously, and they compound each other. The explosion of low-criticality software means the total volume of software in the world is about to increase dramatically. And the rising capability frontier means that AI isn't just filling in the low end — it's progressively taking over more of the spectrum.

For developers, this requires genuine adaptation. The instinct is to retreat upward along the criticality spectrum. "AI can do the simple stuff, but it can't do what I do." And that's true today, for some value of "what I do." But the floor is rising. Domain expertise, systems thinking, taste, judgment about what to build and why — those are the things that compound with AI capability rather than compete against it.

For companies, the build-vs-buy equation just fundamentally changed. "Buy" used to win almost by default for anything below enterprise scale. Now, building bespoke is fast and cheap for a large and growing portion of the spectrum. Companies that recognise this shift early will end up with tighter, more effective tooling.

And for the SaaS industry itself? The 10,000 products competing in the mid-range are about to face a new kind of competition. Not from each other, but from their own customers, who can now build exactly what they need instead of settling for the closest available approximation.

The total amount of software in the world is going to increase by orders of magnitude. Most of it will be low-criticality, bespoke, and built with AI. A lot of it will be ephemeral — built for a specific purpose and discarded when the need passes.

The mid-range will compress. Generic SaaS will consolidate. The products that survive will be the ones with genuine network effects, deep integrations, or levels of complexity that bespoke tools can't easily replicate.

The capability frontier will keep climbing. What AI can reliably build this year will look quaint next year. The pace matters.

And the nature of software development as a profession will shift, likely quite dramatically. The ratio of thinking to typing was already changing. It's about to change a lot faster.

This is where we are. The criticality shift isn't coming. It's here.