In a recent episode of the OVRFLO podcast Beyond the Brief, Brian Foody and I chatted about where software is heading now that AI agents can do so much more of the actual building. Brian’s a prolific founder and engineer who has worked across fintech, AI products, voice agents, and business automation, so the chat reflected his actual experience. He is using this new method to build real systems, but is still intently focussed on ensuring code quality.

Brian made a comment within our chat though that pricked up my ears. He said he thinks the last decade of software may end up looking like the dark ages. It sounded dramatic at first. The last decade was great right? It gave us mature cloud infrastructure, mobile apps, SaaS, APIs, design systems, and companies built almost entirely out of digital products. The output was incredible. But after thinking about it, he’s right. It’s all too expensive. We’ve developed crazy ceremonies around small changes to lower risk. With spiking costs, innovation and accessibility have suffered.

Moving a button on a screen should be cheap. A small interface change should be able to happen without a delivery pod, two planning meetings, a Jira ticket, a design review, QA, release notes and a CAB. The button itself was cheap, but the crazy system we created that’s wrapped around changing it is what’s made it expensive.

That cost shaped the industry. It made software feel like some precious, elitist thing. It made small ideas uneconomical. It pushed companies toward big bets, big teams, big platforms, and big coordination systems. Thousands of useful little things never got built because the process required to build them cost more than the thing itself. It’s the coordination tax, I’ve written about this before.

But with AI and agentic development the cost of making and changing software has collapsed. This dramatic change has led to a lot of doom about software development as a profession. But I see a different path, a brighter one. My bet is that cheaper software will produce far more software. More attempts, more tools, more prototypes, more internal systems, more failed experiments, and more products that could never justify the old cost structure. This, as I see it, is the opportunity.

Software Was Artificially Scarce But It Won’t Be

Plenty of useful software just wasn’t possible with the old model: the internal workflow that only three people use, the local business process that still runs through spreadsheets and email or the niche product built for 1,000 people that wasn’t trying to be venture-scale.

The old cost structure killed these ideas before they started. Software had to clear a very high bar before it deserved to exist, and that pushed the industry toward large, general-purpose platforms. SaaS became huge partly because custom software was too expensive. You bought the closest thing that existed, bent your workflow around it, paid per seat, and then spent the next five years complaining that it did not really fit. Sound familiar?

That was the bargain though. You got software, while the software was built for a broader market category instead of your actual need. The cost of custom building was too high, so people adapted themselves to generic tools. This can still make sense, but a new category is emerging fast.

Jevons Now Comes For Software

There is an old economic idea called the Jevons paradox. It comes from William Stanley Jevons, who wrote The Coal Question in 1865. Britain was becoming much more efficient at turning coal into industrial power, and the common assumption was that better steam engines would conserve coal. But Jevons argued that better engines would simply expand coal use by making coal-powered work cheaper.

Cheaper power made more coal-powered work worth doing. More factories, railways, ships, furnaces, and machines became economically viable. Coal per unit of work could fall while total coal use still rose. Jevons’s point was about demand. When a capability gets cheaper, people find new uses for it.

Lighting followed the same pattern. Artificial light became thousands of times cheaper. Researchers Roger Fouquet and Peter Pearson estimate that by 2000, lighting services in the UK cost less than 1/3000 of their 1800 level. We used the savings to light streets, factories, homes, offices, stadiums, shops, signs, screens, and entire nights. Cheaper light changed what humans could do after dark.

Computing is another example. The cost of computation has clearly collapsed in our lifetimes. William Nordhaus estimated that computer performance per constant dollar improved by roughly one trillion to five trillion times since 1900. Cheap computation has now expanded into personal computers, phones, search, cloud software, SaaS products, streaming services, social networks, and even fridges and toasters.

What seems to be true is that efficiency lowers cost, then our imaginations expand, and usage expands.

I believe we’re at the bottom of the hockey stick with software here. We’re on the cusp of this next explosion.

Think about it, when a prototype takes three months to build, only the safest ideas will make the cut. When every internal workflow needs a full delivery team, most workflows stay as they are. Agents lower the cost of creating and changing software, and the market will respond by demanding software in places where software never made economic sense before. This is hugely exciting to me.

The future has less hand-written boilerplate and just more software.

The Doomer Mistake

The doomers will say that engineering is dead. That the industry is hell bent on deleting roles. This is because the doomer argument usually counts the current amount of people required per feature versus the new expected. If an agent can produce the code that used to take five developers, the assumption is that a company needs fewer developers for that feature. And perhaps per unit of software, that may be true. But here me out, the denominator is wrong.

What’s more important now is what features become worth building. What workflows become worth automating? How many products become worth testing? How many local, internal, temporary, personal, or industry-specific tools become worth making?

The world clearly wants more software once software gets cheaper. It is full of manual processes, awkward tools, duplicated work, bad UIs, half-built workflows, and ideas too small for the old economics. Lower the cost of software enough and the backlog is basically every process in every interaction within civilisation.

The New 90%

Dario Amodei made a comment at a Council on Foreign Relations event in March 2025 that was repeated a lot. He said AI was close to writing 90 percent of code, and that within another year we might be in a world where AI is writing essentially all of it. At first I had the same reaction as most, that this was about role replacement.

But in our podcast episode Brian raised a great point. What if that 90 percent is just a new 90 percent?

If agents write most of the code, then human work concentrates around the decisions that govern the code. Then that human layer becomes more leveraged because it manages a much larger amount of output.

Amodei alluded to this anyway, it just got lost in translation. The engineer still needs to specify the requirements, the conditions, the design decisions, how the code works with other code, and whether the design is secure. That work remains valuable as generation gets cheaper. Much more valuable.

So I think the real question is what happens when agents make ten times more software than before. Software engineers face more code, more systems, more generated work to review, more prototypes to judge… The list goes on. More. The agent-written code creates a new surface area of human work around it.

The Missing Middle Comes Back

One of the strongest arguments for AI in software is the return of the missing middle. The old way favoured extremes either way. On one side, you had generic tools that served everyone badly enough just to be useful. And at the other, you had expensive custom software for companies with the budget to justify it. In the middle sat thousands of ideas that never got made due to cost and accessibility.

Software does not always need to become a company. Sometimes it only needs to be useful. It can be a working sketch, a temporary process improvement, a better interface for an awkward workflow, or a small tool that saves a team from repeating the same dumb task every week.

The golden age is a thousand smaller things that were never worth building before. But that can now not only be built, but can have impact in a business.

Developers Move Up The Stack

Developers and engineers remain central, although the shape of the role changes. AI can now scaffold features, generate tests, refactor components, wire up APIs, and produce a working first pass faster than you could have a 4 person meeting a year ago. When an appropriate harness is deployed, code generation now handles a real share of production implementation work.

Frederick Brooks wrote about this decades ago in No Silver Bullet. Software has accidental complexity and essential complexity. Accidental complexity is the friction around the work: syntax, boilerplate, build setup, mechanical translation from one format to another. AI is very good at solving that.

Essential complexity is different. What should the system do? What should it refuse to do? What happens when the happy path breaks? What data matters? What risk are we accepting? What should be fast? What should be reversible? What should be boring? What should be delightful? What should stay human?

That work becomes more visible as code appears faster. The valuable developer becomes the person who makes software systems reliable enough to trust.

They understand the existing system so they can set the appropriate boundaries. They review generated work. They know when the agent is solving the wrong problem. They know when a change introduces future pain. They know when a working demo is still a long way from production software. In the old world, a lot of that judgement was hidden behind implementation effort. In the new world, it stands unique and valuable.

When Everyone Can Build, Design Matters More

The same shift happens to design. When everyone can make the interface, the interface is no longer the moat. That can sound threatening if you only treat design as creating a UI in Figma. I see design as the layer that gives software identity, coherence, and emotional weight.

Generated products already reach a level where the layout is fine, the buttons are fine, the onboarding is fine, and the typography is just fine. The whole thing can be technically acceptable and still feel like nothing. Fine is a terrible place to compete.

When anyone can spin up a product, the scarce layer becomes identity, taste, positioning, interaction quality, language, trust, and how your customer feels when using your product. It becomes the ability to know what is distinctive, what is generic, what is worth sharpening, and what should be cut.

Currently agents are very weak at that layer. They can remix patterns, produce competent screens, follow a design system, generate variants, and imitate the visual language of successful products but they really struggle to create an emotionally resonate product experience with a coherent UI across hundreds of flows.

They do not understand this emotional contract between a business and its customers at all. They do not know when a brand should be quiet, strange, premium, local, technical, or almost invisible. They do not know when the right move is to get out of the way.

That is design work: direction, judgement, and taste. The more AI builds, the more valuable that direction becomes.

The New Scarcity Is Direction

So what matters then? With the old scarcity being production capacity now eradicated, what’s valuable?

Direction.

The new scarcity is direction. What should we build? Why should it exist? Who is it for? What should it feel like? What should it connect to? What should it avoid? What should it replace? What should stay human? What proof do we need before we trust it?

This is where designers, developers, founders, and product people start to converge. The brief is no longer a request for output. A good brief in this world is much more than ‘make me a screen’ or ‘build me an app’. It is context, constraints, behaviour, audience, tone, edge cases, evidence, and taste.

It tells the agent what good work means. It tells the developer what must be true. It tells the designer what should be protected. It tells the business what bet it is actually making.

The future belongs to people who can give output direction.

What I Think Is Coming

We’re entering the golden age of software. The work will get messier. There will be more bad software, more abandoned prototypes, more generated slop, more half-built internal tools, and more products that should never have made it past the first prompt. Abundance always creates waste, but it also creates opportunity.

We’ll see more wonderful ideas get tested. More people will build. That’s what I’m excited for.

Software has spent decades being reserved for ideas big enough to survive the old cost structure. That world is dead. The next one will be noisier, weirder, and harder to control. But it will also be much more creative.

The golden age begins when software stops being reserved for ideas big enough to survive the old cost structure.