The Code Factory Needs a Foreman

There is a factory where the lights never go off. No shift change, no tea break, no weekend — just hundreds of machines building software through the night, so that by morning the loading bay is stacked with crates of freshly written code, sealed, labelled and waiting. None of this is speculative; these factories are running today. But watch what happens at dawn. Before a single crate leaves the building, a human walks the line, prises the lids off and inspects what the machines actually made. Pull that person out and the factory does not run itself. It buries you in boxes nobody has opened.

The interesting question stopped being can the machines build it? They can. The real question is who writes the work order and who signs for the crate — and that job is getting more expensive, not less.

The Swarm Is Real

In January 2026, Cursor switched on the biggest factory floor yet: hundreds of machines pointed at a single goal and left to run for about a week. They wrote over a million lines of code and assembled a working web browser from scratch. The revealing part was the management structure. Left to coordinate as equals, the machines got in each other's way. What worked was a hierarchy any mill owner would recognise: planners to break the work down, workers to build it, and a judge at the end of each cycle deciding whether the batch was good enough to continue. And the biggest lever was not the machinery at all. It was the prompts — the written instructions posted at every station.

Simon Willison — a developer who tests claims rather than repeating them — took that browser home, compiled it on his own machine and read real web pages with it. He had pencilled in AI-built browsers for around 2029, and concluded he "may have been off by three years." This is not a demo reel. Enterprises now report machines that run unattended for hours inside codebases of more than ten million lines and land a complex change in a single run. Leaving work orders on the bench at midnight and arriving to a loading bay full of finished work is now an ordinary Tuesday, not a party trick.

The adoption numbers track the capability. A majority of enterprises with engineering teams already run at least one coding agent in production, and most developers now use AI as part of their daily work. The factory floor is real, it is busy, and it never closes.

But the Foreman Never Left

Now walk one of these floors and look for the humans. They are not at the workbenches. There is one, up on the gantry with a clipboard: breaking a big job into work orders, dispatching five, ten, twenty machines across the floor, then opening every crate that comes off the line before it ships. The machines do the making. The human decides what gets made, owns the blueprint, and keeps the gate.

That gate is not temporary scaffolding, waiting to be automated away. The same teams shipping with agents say they can fully hand over only a small share of their tasks — even though they use AI across most of their work. And the industry's own forecast is telling: the next milestone is not a machine that needs no supervision, but one that knows when to stop and call the foreman over. Escalation, not independence, is the feature people actually want.

So the bottleneck moved — from the workbench to the inspection bench. The line now fills crates faster than any human can open them, and opening them is the part that still takes judgement.

Making It Was Never the Slow Part

Here is the trade's uncomfortable secret: for a competent team, making the thing was never the slow part. Knowing whether the thing is right — that was always the scarce resource. The machines have flooded the cheap half of that equation and left the expensive half untouched.

The trust gap is wide, and well measured. Most developers say they do not fully trust the accuracy of machine-written code. Teams that adopt agents watch the crates stack up at the gate — more of them, and heavier — while inspection time climbs to match. Net out that extra checking and the real gain is far smaller than the speed of the line suggests. Trust, not generation, has become the real bottleneck. The throughput is real. The value you keep is whatever survives inspection.

The instinctive answer is to stand a second machine at the gate and have it inspect the first machine's work. That helps with the mechanical layer — the loose screws, the missing bolts, the obvious faults. But it raises a sharper question. Does a second machine add trust, or just dress up the lack of it? A machine that approves another machine's work has not added judgement. It has put a more confident-sounding stamp on the same unopened crate.

The Economics Invert

Run the arithmetic and a strange thing happens. By the hour, the machines are absurdly cheap. They work every hour of the year; a salaried engineer works a fraction of them. But price the output per crate of trusted code — code a person has opened, inspected and signed for — and the picture flips. All of it still has to be verified, and verification is paid for in senior salaries.

And the size of the bill is not even the real story. The swing is. A salary is a fixed, predictable number you can write into a budget. The machines run on metered fuel — tokens, billed by the drop, spiky by nature — and the meter can blow through its budget in a quarter. One major chipmaker's leadership says engineers should be burning tokens worth a large share of their salary every year; one experimental fleet of around a hundred machines ran up a seven-figure fuel bill in a single month, across hundreds of billions of tokens.

The Apprenticeship Paradox

Every factory town knows where foremen come from: they come up off the floor. Years at the bench, hands on the work, mistakes made and remembered — that is what trains the eye that can glance into a crate and spot the flaw. It is precisely that training the factory is now cutting off. Studies of junior engineers who lean hard on AI show a measurable drop in how well they understand their own code — and a sharper drop in their ability to debug it. The ones who handed the making entirely to the machines were the worst at explaining how their own systems worked.

At the same time, the bottom rungs of the ladder are being pulled up. Entry-level technical hiring has fallen sharply, and organisations are flattening — the middle layers thin out as the machines absorb the coordination work. The pattern is consistent. The machines take over the work apprentices used to learn on, while making the master's judgement count for more. The org chart loses its bottom and middle before it loses its top.

When the Factory Has No Foreman

Now picture the factory with nobody on the gantry at all — an owner who has never worked the line, shipping crates straight to customers, unopened. That is what it means when someone who has never written software ships a production system built entirely by machines. The failure that follows is predictable, because the thing that breaks is invisible to the person at the controls.

One launch became the cautionary tale. Its founder proudly noted he had written not a single line of code. Researchers soon found the platform exposing roughly 1.5 million API keys and tens of thousands of user emails — all because one database setting was never switched on. To its builder, the application worked in every sense he could perceive: pages loaded, users signed up. Working was never the thing that needed checking. Veracode found that AI-generated code carries a security flaw in close to half of all cases — a flaw a non-developer has no way to see and no framework to catch.

The boundary is not "can the machines build it." They can. The boundary is whether anyone out there is motivated to break it. A foreman-less factory is genuinely useful for internal tools, prototypes and throwaway automation — code with no real users, no personal data and no adversaries. The moment real users, real data or real attackers enter the picture, the empty chair at the gate becomes the whole risk.

Building the Gate

If inspection is the constraint, then the work worth doing is making inspection cheaper and harder to fool — not bolting more machines onto the line. That is a practitioner's problem, and it has practitioner's answers.

It starts with writing the work order down so it outlives the shift. We run spec-driven workflows: the specification — not a closed chat window — is the source of truth the machines build from. The wider industry is making the same shift — the spec becomes the lasting artefact, and the code is derived from it. On top of that sits a row of checks the machines cannot talk their way past. Static analysis runs on every change — a metal detector at the gate. End-to-end and visual tests catch what a confident machine misses. And we keep the architecture small and readable, so a person can genuinely open every crate instead of waving it through. We run this across a portfolio of production codebases — the only honest way to know the gate holds. A gate that makes a person read and understand each change is also where the next foreman is trained: the apprenticeship the factory is eroding, rebuilt at the point of inspection.