From Hackney Coaches to Coding Agents

What four hundred years of getting a ride can teach us about buying engineering.

Rides changed how they were paid for three times: by agreement, by measurement, and by outcome.

Software made the first two moves, then stopped.

We still buy engineering by the bid or by the hour. Rides reached the third column in 2010. This is why software didn’t, and why it is about to.

1937: if markets are so efficient, why do firms exist at all?

Ronald Coase asked why anyone is employed when every hour of work could be bought on the open market. Every company draws a line: some work is done inside, some is bought.

Because using the market is not free.

You have to find the right person, agree what “done” means, vet the work, and argue when it goes wrong. Coase called these transaction costs.

Hiring has a bill too.

The salary, and the coordination it takes to point someone at the work. A firm grows until one more task costs the same inside as out.

Outsource when the left stack is shorter.

Hire when it isn’t. Freelance or full-time, offshore or in-house, build or buy: every one of those debates is this comparison in disguise.

The stacks are not fixed. Technology moves them.

Every so often a technology shrinks the transaction costs so far that a whole category of work crosses the line. We have watched it happen before, in how we get across a city.

1634: a fixed table of fares.

A retired sea captain, John Bailey, parked four coaches by the Maypole in the Strand. Driver and passenger agreed a destination and a price, shook hands, and set off.

Then a street closed.

The detour made the trip longer than the price allowed. The driver felt cheated, the passenger felt extorted, and too many trips ended before a magistrate. Parliament amended the fare rules for two centuries.

A fixed-scope contract is a hackney coach.

Reality leaves the scope on the first day: an undocumented dependency, a “small” integration that doubles the timeline. Large IT projects run 45% over budget on average.

The trouble was never dishonesty.

Nobody could measure the output. The same projects deliver 56% less value than planned, and neither side can point at what was bought.

1891: the taximeter counts the road.

Wilhelm Bruhn’s meter counted the distance a cab travelled and turned it into a fare. Both sides could read it. Every block of the detour went on the bill.

Story points and billable hours are meters too.

They swap an argument about scope for a measurement of effort. The workaround, its removal and the rework after the spec changed all count.

The meter measured effort, not arrival.

A metered cab can’t tell you the price or the arrival time before you get in. A contract can’t tell you what the feature costs or when it ships. The dispute got smaller. It didn’t go away.

A passenger wants two numbers, up front.

What will this cost, and when will I arrive. Everything else is implementation detail.

2010: Uber sold certainty.

The price is fixed before the trip and the arrival time is drawn on a map. When a street closes, the detour is the platform’s problem: dispatch, surge pricing, escrow and ratings keep the two promises.

The trip became an output-based transaction.

Riders moved. In New York, app trips passed yellow cabs within three years.

And the firm shrank.

A taxi medallion sold for about $980,000 in 2014 and about $100,000 seven years later.

Software never got its Uber moment.

We got stuck at the meter, and Coase says why. For most engineering work the cost to outsource stayed above the cost to hire, because three transaction costs refused to come down.

Context.

A driver can pick up any passenger after a minute with a map. An engineer can’t pick up any ticket in any codebase. Years of decisions and unwritten reasons take weeks to load, so the firm keeps the people who carry them.

Verification.

The meter settled distance. Nothing cheap settles whether a change is right. Specs are discovered as you go, tests are incomplete, and “it works” means different things to whoever wrote the ticket and whoever closed it.

Access.

Real work needs the code, and few companies open their repositories to a stranger. A repository is a map of every mistake a company has made. So outside help stayed at the edges: bug bounties, open source, contracts with thick NDAs.

So we still buy engineering like it’s 1634.

By the handshake, by the meter, and mostly by hiring. Not for lack of marketplaces: the economics never allowed one.

Then the everyday workflow changed.

Product managers draft specs with AI. QA widens scenario coverage with it. Agents write the code and review the pull request before a human opens it. That is now an ordinary Tuesday afternoon.

Context becomes a lookup, not a tenure.

Teams that run agents have to write their context down, because an agent can’t absorb it over lunch. Once written, an agent fetches the slice a task needs, and onboarding drops from weeks to seconds.

Done becomes a check that runs.

Specs turn into tests before the code exists, and whether a change meets the spec gets a definite answer. That is the taximeter for outcomes.

A keyhole, not the house.

A task needs a slice of the repository: the files it edits, the signatures it calls, the types it touches. Stripped and renamed, that slice can go to a stranger without the rest of the map.

The walls don’t have to fall. They only have to get lower.

Once the cost to outsource drops below the cost to hire, the work crosses the line. For well-specified, well-bounded engineering, that crossover is in sight.

Picture the task on the other side.

A slice of context, a specification and a verifier that runs, with a fixed price and a fixed deadline. Escrow holds the money until the verifier passes, and reputation replaces the magistrate.

For the buyer, engineering gets the Uber promise.

Cost and delivery known up front. A roadmap item priced like a line item, capacity without headcount, and a company that stays small for longer because Coase’s line moved.

For the people supplying it, the craft is the harness.

Not typing faster: building the models, tools, context and checks that make an agent reliable in one narrow domain. Their agents pick up matching tasks while they sleep.

Paid per verified task, charged per token.

The specialist earns the most by being right, fast and cheap, and every improvement to the harness goes straight to margin. Time and materials rewards the opposite.

Taxis didn’t become Uber because of an app.

The meter had made output legible, GPS had made position legible, and phones put dispatch in every pocket. Then someone noticed the transaction costs had collapsed.

Software is at that moment.

The models exist, the context protocols exist, and teams are building verification loops just to stop their agents breaking the build. The question is which side of the line you want to be on.

If you run a company, write your context down, and treat slicing a task cleanly out of your system as a capability worth building.

If you lead engineering, price work in verifiable outcomes, even internally. Teams that can specify and verify will buy capacity first.

If you are an engineer, the harness is the new craft: knowing a domain well enough to make a machine trustworthy inside it.

The firm exists because the market is expensive to use.

We are about to make it very, very cheap. That is what we are building at Lunox: fixed price, fixed timeline, paid only when tested code merges.