What If a Venture Capital Firm Could Build Its Own Companies?

Why the Hell Am I Building Relay?

A few people have asked me a perfectly reasonable question.

You’re a software engineer. You’ve spent years building software products for clients and being paid to deliver them.

And now you appear to have developed a machine that can build software at a frankly rather frightening rate.

Well, always one to have a Dick Dastardly plan up my sleeve. Relay is going to be a lot more than a software development tool. Read on…

Relay can architect things, break them into work, dispatch engineers, review what comes back, test it, reject bad work, fix things, integrate everything and keep going. We’re approaching the point where producing three or four functioning software systems in a day doesn’t sound completely ridiculous anymore.

I also gave Relay a physical office, because apparently building an autonomous software company was not ridiculous enough. You can zoom into departments, inspect workers, watch them writing code, and see the exact moment one of them gives up and raises a little “Stevie?” sign. It is Sims for software architecture, except everyone is cheaper, quieter, and somehow still needs management.

Which raises an obvious question.

Why the fuck would anybody need to do that?

Who needs four software systems a day?

What’s the commercial point?

What exactly am I planning to do with this bloody thing?

And I think I’ve done a slightly poor job of explaining the answer, because Relay isn’t really about producing software quickly.

That’s just one third of it.

The bigger idea is closer to an automated venture studio. Or, in some respects, a venture capital company which can make hundreds of tiny investments, except instead of primarily investing money into other people building companies, the machine can discover the opportunity, investigate it, build the product, take it to market and then decide whether to keep investing in it.

That’s the actual thesis.

And it starts from an assumption which is hardly revolutionary anymore:

The cost of creating software is collapsing.

We all know this.

You don’t need another article from a software engineer breathlessly announcing that AI can write code.

Yes. It can.

Next.

The interesting question is what happens after that becomes normal.

Because if producing the software itself stops being the expensive part, the economics of starting digital businesses change rather dramatically.

And that’s what I’m building Relay to exploit.

The software isn’t the system

For most of my career, software production was the enormous constraint.

Somebody had an idea. Then you needed developers, architects, testers, infrastructure people, product managers and somebody to manage everybody else.

Then meetings.

Obviously meetings.

Possibly even meetings to discuss why the previous meeting hadn’t resulted in anything actually being built.

Eventually, after spending £100,000 or £500,000 or £2 million, some software might appear.

That meant you couldn’t pursue every vaguely interesting idea.

You had to choose.

And you had to choose bloody carefully.

AI is making that constraint disappear remarkably quickly.

But here’s the thing.

If software costs almost nothing to produce, that doesn’t mean opportunity costs almost nothing to find.

The difficult things become everything around the software.

Which markets are worth entering?

What problems are actually painful enough that people will pay to solve them?

What regulatory change has just created a new requirement?

What tiny community is currently fighting with spreadsheets because nobody has bothered building the obvious tool?

Is there distribution?

How many customers exist?

What are they worth?

Can you reach them?

Are you three years too early?

Six months too late?

Is there already somebody much better?

Are people complaining loudly enough that a business might exist?

And, inevitably, are you lucky?

Those become the scarce resources.

So Relay isn’t intended merely to industrialise software creation.

The eventual system industrialises the entire process of finding, creating and testing businesses.

There are three parts.

1. Discovery

The first part barely exists today.

It’s opportunity discovery.

Think R&D, market research and a slightly deranged investment analyst rolled into one.

There will be looping research agents whose entire job is to go hunting.

New markets.

Bad existing products.

Regulatory changes.

New APIs.

Search trends.

Industry complaints.

Communities with unsolved problems.

Changes in technology.

New ways of combining things which weren’t economically viable twelve months ago.

Potential opportunities enter a funnel.

Then other processes attack them.

How many potential users are there?

What do they currently use?

How much do they currently pay?

Who are the competitors?

How hard would it be to reach customers?

What’s the support burden?

What’s the regulatory exposure?

What’s the realistic revenue at 0.1%, 1% or 5% penetration?

How expensive would this thing be to build and operate?

Most ideas should die here.

In fact, I want an absolute massacre.

A thousand possibilities might become fifty serious investigations.

Fifty might become five.

And perhaps one gets built.

That isn’t failure.

That’s the machinery working.

Traditional venture capital operates on a related principle. You don’t expect every investment to become enormous. You build a portfolio because the returns are asymmetric: a small number of exceptional winners can pay for an awful lot of losers.

I’m applying something similar much earlier in the chain.

Except rather than waiting for entrepreneurs to bring opportunities to me, I want machinery continuously looking for them.

2. Relay

Then the survivors reach Relay.

Relay is the factory.

This is the bit I’ve been obsessively building.

It contains the engineering organisation: architects, workers, reviewers, publishers, governance, work decomposition, memory, escalation, testing and all the assorted machinery required to stop autonomous AI agents wandering around setting fire to things.

Relay has reached the point where it is not just building products. It is finding its own broken bits, raising defects against itself, assigning agents to fix them, redeploying, restarting, and carrying on. This is either self-healing software or the opening scene of a film where somebody really should have pulled the plug earlier.

Once an opportunity has survived the research funnel, Relay gets a wonderfully simple instruction:

Build the bloody thing.

Not prepare a twelve-month roadmap.

Not create a 73-slide PowerPoint presentation about the transformational potential of the initiative.

Build it.

Put it somewhere people can use it.

Then find out whether the original hypothesis was right.

This is where extremely high software throughput suddenly makes commercial sense.

I don’t actually need four new software products every day.

I need the ability to produce four because that means the cost of testing each opportunity becomes tiny.

And that fundamentally changes what constitutes a viable opportunity.

This is where it started to get silly. Relay is no longer merely accepting work; it is blistering through it. Work chains and Git worktrees now let it tackle related knots of work in parallel, land fixes, complete work orders, and build out its own operating system at a speed that feels faintly indecent.

3. Imprint

Then comes the third part.

Imprint.

Software engineers have a wonderful habit of believing that if they build something sufficiently clever, humanity will somehow detect its existence through vibrations in the Earth’s crust.

Unfortunately, this does not appear to be how markets work.

Somebody has to distribute the bloody thing.

That’s Imprint.

Imprint is the outreach and distribution organisation.

Instagram.

Reddit.

YouTube.

SEO.

Email.

Partnerships.

Community outreach.

Landing pages.

Tutorials.

Advertising experiments.

Articles.

Videos.

Hundreds or potentially thousands of small attempts to put a product in front of the people who might care about it.

But Imprint isn’t merely a marketing department endlessly pumping content onto the internet.

Its most important output is signal.

This audience responded.

That one didn’t.

This Reddit post generated twenty registrations.

That Instagram reel generated absolutely bugger all.

People are signing up but not paying.

People keep requesting the same feature.

We thought accountants wanted this, but for some inexplicable reason German dentists appear to be going berserk for it.

Those signals return to the system.

And that’s where the three pieces become one thing.

The loop is the product

Discovery finds something.

Relay builds it.

Imprint pushes it into the world.

The world responds.

Those responses become signals.

Relay changes the product.

Imprint changes the message.

Discovery recalculates whether the opportunity still deserves investment.

Then it goes around again.

Discover → analyse → build → distribute → measure → learn → reinvest or kill.

That’s Relay.

Or at least that’s what Relay is becoming.

And this is why merely saying “AI makes software cheaper” misses the interesting part.

Cheap software is just the enabling condition.

The actual opportunity is what you can build around that fact.

You don’t have to be right very often

This might be the part that excites me most.

Conventional software economics force you to be right quite a lot.

If every attempt costs £500,000, you cannot casually test twenty ideas.

But suppose the cost falls by two orders of magnitude.

Now you can be wrong.

A lot.

And being allowed to be wrong is incredibly powerful.

I don’t necessarily need a magical AI capable of identifying the next billion-dollar company with prophetic accuracy.

I’d actually be deeply suspicious of anybody claiming to possess one.

I need something much less glamorous.

I need a machine capable of finding plausible opportunities cheaply enough that we can test a lot of them.

That’s essentially portfolio theory applied to building businesses.

Some go immediately to zero.

Fine.

Some survive but never become particularly exciting.

Fine.

Some become small profitable products.

Lovely.

And perhaps occasionally one goes absolutely fucking bananas.

That’s where the return comes from.

The machine doesn’t have to predict the winner perfectly.

It just has to keep producing sufficiently cheap bets.

Small suddenly becomes interesting

And collapsing development costs do something else.

They make markets interesting which traditional software companies wouldn’t touch.

Imagine a software product capable of making €8,000 a month.

For a conventional funded startup, that’s barely worth getting out of bed for.

You’ve got engineers, managers, salespeople, offices, SaaS subscriptions, investors and an expensive espresso machine to pay for.

But if that €8,000 product cost almost nothing to create and requires almost no human labour to operate?

That’s a lovely little business.

Now have fifty of them.

This is where the venture-capital analogy actually becomes rather useful.

I’m not necessarily looking for one company which consumes every resource I possess.

I’m thinking in terms of a portfolio.

Except instead of owning shares in fifty companies, the system can potentially create and operate the fifty companies itself.

And because the cost base is radically different, the minimum viable market becomes radically smaller too.

There could be thousands upon thousands of profitable little niches which historically weren’t worth serving because the economics of software development made them ridiculous.

Those become interesting again.

So that’s the actual plan

That’s why I’m building Relay.

Not because the world desperately needs a machine capable of producing four software systems before lunch.

That would be an extraordinarily stupid objective on its own.

I’m building the engineering machinery because it sits in the middle of something much bigger.

Discovery finds opportunities.

Relay turns them into reality.

Imprint puts them into the world and listens to what comes back.

Then the whole thing reallocates its effort based on what it learns.

It’s part software factory, part R&D organisation, part marketing operation, part venture studio and, in a slightly peculiar sense, part venture capital portfolio.

The long-term objective is not:

“Build software incredibly quickly.”

It’s:

“Continuously discover potentially profitable things, test them incredibly cheaply, and invest more heavily in the ones which show signs of life.”

Maybe it doesn’t work.

Entirely possible.

I may ultimately discover that I’ve spent an extraordinary amount of effort constructing the world’s most sophisticated autonomous machine for producing software nobody wants.

There would be something magnificently appropriate about that.

But that’s the bet.

Software becoming cheap isn’t the destination.

It’s the starting gun.

Because once execution becomes cheap enough, you don’t need to make one enormous bet.

You can make hundreds of tiny ones.

And that’s my slightly deranged Dick Dastardly, rubbing-my-hands-together-in-the-corner plan.

Relay isn’t being built so that I can create four software products a day.

It’s being built so that, eventually, I can afford for three of them to be wrong.