The Builder and the Billion Dollar Lie

How three decades of building for machines led us to the moment we can finally build for ourselves.

I was fourteen years old, sitting in my bedroom, typing commands into an Amstrad.

No tutorials. No Stack Overflow. No YouTube walkthroughs. Just a manual, a blinking cursor, and the kind of stubbornness you only have when you are too young to know what you do not know.

I spent hours, then days, learning syntax the way you learn a second language when you are dropped in a foreign country. One character wrong and nothing worked. One character right and something appeared on the screen that had not existed before you put it there.

That feeling, making something from nothing on a machine, never left me.

I have spent the last thirty years watching the technology industry promise that feeling to everyone, then slowly take it away.

The tools that let everyone in

A few years later I moved to a Commodore Amiga. Then eventually to an Apple Mac, which opened up desktop publishing and multimedia in a way nothing else could at the time. QuarkXPress. Photoshop. The beginnings of an entire creative industry running on a single machine.

From there I went to university to study multimedia and production, which felt like the frontier of everything. We were in the early days of Macromedia and Adobe, and what those companies did was remarkable. They gave ordinary people the ability to build.

Dreamweaver let you construct websites without writing every line of HTML by hand. Macromedia Director let you build interactive CD-ROMs. Contribute was an early attempt at content management. And then there was Flash.

Flash was magnificent and terrible in equal measure.

It let anyone create animation, interaction, and rich experiences that felt alive. Suddenly the web was not just documents. It was a canvas. Between 1997 and 2003, it felt as though the tools had finally caught up with imagination. Anyone could build, and everyone did.

The problem was that we also built a lot of mess.

Some of it was brilliant. Some of it was beautiful. Much of it was noise. Flash also broke something important. It existed outside the DOM. It could not properly interact with open standards. It traded accessibility and interoperability for spectacle, and it took years to unwind the consequences.

But the instinct underneath it was right. Technology was supposed to help more people create. That was the promise. And every time the industry drifted away from it, something eventually pulled us back.

Until it didn’t.

The era of other people’s platforms

What happened next is the part people rarely talk about honestly. The instinct to democratise building did not just stall. It got captured.

I lived through the enterprise software wave. SAP, Salesforce, OpenText, Red Dot. Content management systems, enterprise platforms, intranets, ERPs that cost millions and took years to deploy. I was on both sides of it, inside software companies building products, and inside organisations trying to implement them.

It was hard. It was always hard. It required engineering teams, IT infrastructure, consultants, integrators, and levels of patience that bordered on absurd.

And the quiet truth running through all of it was this: much of the complexity existed not because the problems were inherently complex, but because the tools were.

We built entire industries around making technology work. Not making it useful. Making it work.

The original promise of the bedroom and the blinking cursor was gone. In its place came procurement cycles, licensing agreements, and implementation roadmaps measured in years. The ability to build had been professionalised to the point where most people inside most organisations could no longer create anything without submitting a ticket and waiting.

This was not a moral failure. It was a structural one.

Building software was expensive. Enormously expensive. Creating anything meaningful required capital, technical labour, and organisational commitment at a scale only large institutions could sustain. And when only large institutions can afford to build, what gets built tilts toward whatever generates the biggest returns. Not what solves the most problems. What captures the most value.

Renting your own solution

Then SaaS arrived and, for a while, it looked like the answer.

It promised to sweep away the heaviness of the enterprise era. No huge implementation programme. No servers in the basement. No army of consultants. Just subscribe, log in, and start solving your problem.

And in many ways, it was an improvement. SaaS made software cheaper, faster to deploy, and easier to access. It lowered the barrier to capability and gave smaller organisations access to tools that would once have been out of reach.

But it also preserved the same dependency in a cleaner, more elegant form.

Most organisations were still not solving their own problems. They were renting somebody else’s interpretation of them.

That distinction matters.

When a company buys software to manage sales, service, planning, hiring, operations, or internal knowledge, what it is often really buying is a packaged abstraction of its own pain. A third party ingests just enough of the complexity to become useful, but rarely enough to remove the dependency altogether.

The incentive is not usually to eliminate the problem so completely that the customer no longer needs the product. The incentive is to remain embedded in the workflow, to expand into adjacent needs, and to add more layers: modules, seats, admin controls, compliance features, reporting tiers, integration costs.

Not necessarily out of malice. Out of economics.

That is why so much modern software still leaves organisations feeling strangely unresolved. The interface improves. The billing model gets lighter. The stack gets longer. But the underlying problem is often only partially solved, now surrounded by a fresh layer of subscriptions.

We did not remove complexity. We outsourced it.

And because we outsourced it, we also outsourced agency.

What happened next split this story in two directions.

Inside organisations, software became something you rented to manage complexity. The promise was operational: subscribe, configure, integrate, repeat.

Outside organisations, on the public web, the model shifted differently. The promise was not that you could solve your own internal problems. It was that you could participate, publish, and reach people without needing to build your own destination on the internet.

That felt like democratisation. In some ways, it was.

But it also created a second form of dependency.

Businesses learned to rent capability. Individuals learned to rent visibility.

Participation without ownership

If SaaS taught organisations to rent capability, social platforms taught individuals to rent visibility.

You no longer needed to build a website, maintain your own corner of the web, or figure out how to attract an audience from scratch. You could just post. Publish. Upload. Comment. Participate.

That felt like liberation. And in some ways it was. The barrier to being seen collapsed.

But the trade was profound.

You were not building on your own land. You were performing on somebody else’s platform, under somebody else’s incentives, in exchange for borrowed reach that could be amplified, throttled, or withdrawn at any moment.

The offer was seductive. Free tools. Free distribution. Free participation. In return, you gave the platforms everything: your data, your images, your relationships, your attention, your ideas, your stories. Every post, every photo, every interaction became part of a system designed to capture and monetise attention at scale.

This model was not new. Print, radio, and television had all worked on some version of the same logic. Capture attention, then monetise access to it. What social platforms did was make that model continuous, personal, and algorithmic.

The web stopped being primarily a place you built things and increasingly became a place you fed.

Some of the most sophisticated engineering talent on the planet spent two decades optimising not for human capability, but for human retention. Not how to help people build, but how to keep them consuming, reacting, returning, and scrolling.

And it worked.

The attention economy became the dominant model for how technology interacted with individuals. Not by making them more capable, but by making them more predictable.

That is why social media belongs in this story. It was not the same as SaaS. It was the consumer-facing mirror of the same deeper pattern: access without ownership, participation without control.

That is the full arc. We started with a teenager in a bedroom making things on a screen. We ended with organisations renting their operational capability and individuals renting their visibility, while platforms and vendors captured more and more of the value in between.

The building instinct never disappeared. It was redirected, captured, and monetised by someone else.

That is the billion dollar lie.

Giving people access to platforms is not the same as giving them the ability to build. It never was. One creates value for you. The other extracts value from you.

The feeling I recognise

I have been around technology long enough to become suspicious of hype. I have seen enough cycles come and go to know that most claims about total transformation are overstated.

But something is happening now that I recognise.

And I do not recognise it from the enterprise era, the SaaS era, or the social era. I recognise it from before that. The Amstrad. The Amiga. The Mac. The early Macromedia days. The first time I made something appear on a screen that had not existed before.

The agentic AI era feels like the return of that original instinct, except the entry point has changed in a way that matters enormously.

In 1997, you needed to learn Dreamweaver or understand enough HTML to shape a page. In 2026, you need to be able to describe what you want. You speak to a model. You speak to an agent. And that agent can increasingly code, build, deploy, and manage logic and workflows on your behalf.

The tools are starting to feel less like software and more like collaborators.

What they enable is not just a lower barrier to building. It is the beginning of something much more important: a reduction in dependence on other people’s platforms and pre-packaged abstractions. For the first time in decades, the direction of travel is not toward more subscription, more extraction, and more reliance on third-party systems.

It is toward ownership.

The problems that were never worth solving

This is where I think the conversation needs to go.

Most discussion about AI stays trapped inside the language of productivity, efficiency, automation, and cost reduction. Those are real. But they are small framings of a much bigger shift.

The more important question is not what AI can automate. It is what technology should have been doing all along.

Think about the systems that waste your time not because the work matters, but because the surrounding machinery is broken. A GP appointment flow designed around the limitations of a telephone exchange. A school communicating through four different apps that do not talk to each other. A company procurement process that takes eleven steps instead of three. A council planning system that is opaque by default.

These are not glamorous problems. They are not billion-user problems. No venture-backed company was ever going to build a breakout startup for your local handover process, school admin flow, or neighbourhood planning bottleneck.

And that is precisely the point.

For thirty years, the economics of software meant only problems with enormous addressable markets were worth solving. If your problem did not scale to millions of users, it did not get a product. It got a workaround.

Worse still, the people who best understood these broken systems were rarely software engineers. They were the people living inside them every day. A nurse knows where patient handover fails. A teacher knows where curriculum delivery collapses. A small business owner knows which administrative rituals consume half the week.

Until now, that knowledge was stranded.

The person who understood the problem could not build the solution. The person who could build the solution rarely understood the problem.

That gap explains more about the last thirty years of enterprise technology than most strategy decks ever will. Entire industries were built inside that gap. Consulting. Systems integration. Transformation programmes. Translation layers between domain expertise and technical capability.

Agentic AI starts to close it.

Not fully. Not cleanly. Not overnight. The systems still hallucinate. They still make confident mistakes. They still require supervision. Anyone telling you otherwise is selling something.

But structurally, the gap is narrowing.

The person who understands the problem can now describe it to a system that can build toward a solution. Domain expertise becomes the valuable input. The nurse, the teacher, the operator, the business owner: they start to become architects of their own tools.

For decades, humans had to translate problems into machine language. Now machines are getting better at receiving human intent directly.

That changes who technology is for. It changes who gets to build. And it changes what gets built.

What actually changes

If your organisation has first-party data, understands its own processes, and can connect that data to models and agents through APIs, something becomes possible that was not possible five years ago.

You do not have to subscribe to a third-party platform for every important workflow. You do not have to ship your context out into the world and pay someone else to package it up and sell it back to you.

You can build your own software. Expose your own APIs. Create your own products. Build application layers shaped around the way you actually work. Operate more like a platform yourself instead of permanently renting space on somebody else’s.

This is not the end of engineering. We will still need specialists, deep technical expertise, infrastructure, security, and serious system design. Third-party software does not disappear. SaaS does not vanish. Partnerships still matter.

But the balance of power is moving.

For the first time in a long time, organisations are not limited to choosing between internal backlog and external vendor. They can begin building more of their own destiny on top of infrastructure, APIs, models, and agents, shaped around their own context.

The ability to build, shape, and control more of your own value chain is no longer locked behind the same wall of technical complexity and licensing cost.

The old stack does not vanish. It gets surrounded.

But something new grows alongside it: an economy of specific problem solving that was never viable before. Millions of people building solutions to contextual problems they actually understand, and capturing more of that value directly.

Before the printing press, the production of books belonged to a narrow specialist class. The press did not replace that world overnight. It created an entirely new layer of human activity by making written production vastly more accessible.

That is the pattern I think is emerging now. Not because the old economy vanishes, but because a much larger surface area of human need suddenly becomes addressable.

The problems we never got to

I think back to my fourteen year old self, sitting in front of that Amstrad, and what drove me was never the syntax.

It was possibility.

The chance to make something that did not exist before. The machine was just the vehicle. The real energy was the act of creation.

We lost sight of that.

For thirty years, a huge amount of creative and technical energy was absorbed by the mechanics of making machines cooperate. We solved infrastructure. We solved deployment. We solved distribution. We solved attention.

And while we were doing that, bigger problems sat waiting.

Healthcare. Education. Climate. Governance. Care. Community. The systems that shape daily life.

Not because nobody cared. But because the human capability required to address those problems was trapped in the plumbing.

That is the part worth seriously thinking about.

The reason so many important problems remained under served was not a lack of intelligence or ambition. It was that too much of our intelligence was tied up in the overhead of making technology function.

When that infrastructure layer simplifies, some of that capability gets released. We move up the stack. Not necessarily toward more complicated technology, but toward more meaningful work.

The first phase of this transition will still look familiar. Faster apps. Cheaper SaaS. More efficient advertising. A lot of noise. And, just as in the Flash era, a lot of what gets built will not be very good.

That is normal.

Decades of being trained as consumers have made people instinctively reach for subscription before creation. The habit of waiting for products runs deep. The instinct to build has weakened.

But the direction is clear. The cost of building is collapsing. The capability of the tools is rising. And the gap between understanding a problem and being able to solve it is narrowing faster than at any point in modern computing.

What stays with me

I keep coming back to that bedroom. The Amstrad. The blinking cursor. The feeling of something appearing on a screen that was not there before.

The promise of technology was always simple: give people the ability to make things that matter.

For a while, we lived up to that promise. Then the instinct got captured. We built complexity for its own sake. We built platforms that extracted more than they enabled. We built an economy around capturing attention instead of solving problems.

Now that instinct is returning.

You do not need to learn syntax. You do not need to master a stack. You do not need to subscribe to someone else’s product and hope it bends to the shape of your needs.

You need to understand your own data, your own processes, and your own problems. You need to think clearly about what you want to create and why it matters.

The capability is real. The barrier is falling. The window is open.

What are you going to build?

---

Craig Hepburn is an AI strategist and builder, Perplexity Fellow, former CDO at Art Basel and UEFA. Works across tech, business and system design shaping how AI operates responsibly.

If this resonated, subscribe. The next piece looks at why Jensen Huang just told every CEO in the world they need an OpenClaw strategy, and what that actually means for the organisations paying attention.