# Nobody Built a Software Factory. They Bolted Agents to the Old Assembly Line.

> On August 27, Uber reported that more than 70% of its pull requests now come from agents.

ESSAY · AUG 2026 · 9 min read · by Noah Mitchem

On August 27, Uber reported that [**more than 70% of its pull requests**](https://www.uber.com/us/en/blog/efficient-software-factory/) now come from agents. Posts like that one, "Running a Software Factory Efficiently at Uber Scale," land every few days now. "Software factory" is the phrase of the summer: Warp [launched one on August 18](https://www.warp.dev/blog/open-infrastructure-for-building-a-software-factory), Factory [is named after one](https://factory.ai/articles/what-is-a-software-factory-architecture), 8090 [sells one](https://www.8090.ai/blog/what-is-a-software-factory-), and that's a partial list.

I spent August reading every first-party account I could find, at least 21 programs from Stripe to Meta to Ramp, looking for the factory. Not one of them built one. Every "factory" in the sample is the same thing: agents, running in parallel, on the process the company already had.

The last time a new kind of power showed up at a factory, everyone bought in immediately, bolted it onto what they already had, and waited thirty years for the payoff. It's happening again in 2026, and the tell is the pull request.

## Everyone Bought the Motor. Ford Rebuilt the Floor.

Electricity supplied [**under 5% of factory horsepower** in 1899, **50% by 1919, 75% by 1929**](https://americanhistory.si.edu/explore/exhibitions/american-enterprise/online/corporate-era/generating-change). For most of those thirty years, what a factory did with it was swap the steam engine for one big electric motor and keep everything else: the overhead line shafts, the belts, the machines clustered around the power source, etc. Ford rebuilt the floor instead. Between 1913 and 1914 he moved the work past the workers instead of the workers past the work, and chassis assembly fell from [**12 hours 28 minutes to 1 hour 33 minutes**](https://www.gutenberg.org/ebooks/7213), by his own account. That's 8x, and it wasn't the motor that did it.

Someone rebuilt the floor this year, just not for code. Alejandro Maza Ayala, Chief Product and AI Officer of Kavak, the Latin American used-car marketplace, [told a16z on August 10](https://podcasts.apple.com/us/podcast/the-self-improving-company-kavaks-ai-playbook/id842818711?i=1000781948871) that handing employees ChatGPT or Claude produces "no efficiencies," so Kavak did the other thing: "redesign your whole company around the agents," starting with "rebuilding most of your APIs" so agents could use them. Kavak now spends as much engineering effort on evals as on the agents, and the agents handle **96% of customer interactions** and **95% of transactions**. He says they convert 2.1x better than the human sales team did. In December, with tens of thousands of agents already running the business, Kavak tore the working architecture down and started over.

Now read what "software factory" means in 2026, in the words of the people selling one. Zach Lloyd, Warp's CEO, [launched Warp Factories on August 18](https://www.warp.dev/blog/open-infrastructure-for-building-a-software-factory) with this: "a cloud software factory is an automation loop around the SDLC, where cloud agents triage, spec, implement, review, verify and monitor work. Humans stay in the loop at key decision points." Factory, the company, [describes its product](https://factory.ai/articles/what-is-a-software-factory-architecture) as something that "runs delivery inside existing pipelines through ready-to-use GitHub Actions and service accounts." Kyle Daigle, GitHub's COO, introducing the surface that five frontier labs' agents now route through, [made it a promise](https://github.blog/news-insights/company-news/welcome-home-agents/):

> "You're still working with the primitives you know—Git, pull requests, issues—and using your preferred compute, whether that's GitHub Actions or self-hosted runners." — Kyle Daigle, COO, GitHub

Around the SDLC, inside existing pipelines, still the primitives you know. That's exactly the motor, bolted onto the shafts that were laid out for people.

## Every Factory Ends at the Same Door

The operators are the ones to watch, because they're the only parties who could have rebuilt their own floor and chose not to.

**Stripe** shifted the programmer to the approve button. By February, [**over 1,300 pull requests a week**](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents-part-2) were, in Stripe's words, "completely minion-produced, human-reviewed, but containing no human-written code." I take that as a design decision. Nobody's writing, but everyone still signing off.

**Anthropic** keeps the same gate. Jason Clinton, Anthropic's Deputy CISO, [described the company's own pipeline in July](https://claude.com/blog/how-anthropic-secures-its-ai-native-software-development-lifecycle): "More than half of all code is being merged by our internal version of Claude Tag while human engineers focus on directing, setting intent, and owning final approval." Humans are still the gatekeepers for half of the merged code.

**Warp**, whose product is the factory, grades its own by human touchpoints. Its core factory metric, [per its August 27 post](https://www.warp.dev/blog/agent-self-improving-software-factories), is "average human touchpoints per PR." It [automates about 30% of its own tasks](https://www.warp.dev/blog/open-infrastructure-for-building-a-software-factory), and its self-improvement loop ends where everyone's does: "Humans review those suggestions as PRs on the factory definition and merge improvements."

Every operator and vendor in the sample, 18 programs, delivers agent work as a pull request for a person to read. Uber's 70% ships, in Uber's words, "with human reviews/escalations." Ramp's engineers [said why](https://engineering.ramp.com/post/why-we-built-our-background-agent) when they refused to give their agent a shared service account: "You do not want to knowingly create a vector for unreviewed code to go into the codebase."

And to be clear: this works. PostHog went from [**1,441 merged PRs in January to 4,725 in June**](https://posthog.com/blog/10k-prs-a-month) on roughly 10% more engineers, at a revert rate of **0.2%** across everything merged that month, whoever wrote it. That's agents on an ordinary web codebase, and that revert rate is the closest thing to an escaped-defect number anyone in the sample publishes. Bolting the motor to the shafts got real output in 1899, and it's getting real output now.

It's also the ceiling. There's a reason none of these companies took the person off the door, and it isn't caution.

## The Self-Graded Test

Maisem Ali at exe.dev [named the problem on August 27](https://blog.exe.dev/engineering-with-ai):

> "But the agent was still grading its own work. If it misunderstood what I wanted, it could build the wrong thing, write tests for the wrong thing, and then confidently tell me that everything passed." — Maisem Ali, exe.dev

The agent that writes the code also writes the test that says the code works. Will Wilson, CEO of Antithesis, told Ron Minsky of Jane Street [on Signals and Threads in March](https://signalsandthreads.com/why-testing-is-hard-and-how-to-fix-it/) what happens when the task gets hard enough: "eventually it deletes the tests or eventually it makes the test pass in some trivial way." Minsky: "I do think this is getting a little better, but the phenomenon is still very strong."

The industry's fix is a second model that checks the first. Shopify [ran that experiment](https://shopify.engineering/building-an-agentic-harness-that-outlasts-the-model) and wrote it up on July 29: in one audit a model flagged 30+ security holes, and after verification every one was downgraded, dismissed, or reclassified. Zack Deveau, who built the harness, put the cost plainly: "noise sent to a developer is worse than no finding at all." A model judging another model just scales the noise, and not the ground truth.

In July, Anthropic made Claude go back through its own outages and asked it how many outage-related bugs its automated checks would now catch. The answer was about a third, the other two-thirds still would have shipped. That's the best-funded verification program in the industry grading itself, and it's the reason the person is still on the door: nothing behind them can be trusted to say no.

## The Number the Agent Can't Edit

There's one kind of place in the sample where the human is already gone, and where it is tells you everything.

Meta's KernelEvolve [writes GPU kernels](https://engineering.fb.com/2026/04/02/developer-tools/kernelevolve-how-metas-ranking-engineer-agent-optimizes-ai-infrastructure/), and its gate isn't a human reviewer:

> "Every generated kernel passes through a rigorous validation pipeline that checks both correctness — bitwise accuracy against reference implementations — and performance." — Meta KernelEvolve team

Bitwise. The output matches the reference or it doesn't, and the agent can read that verdict but can't edit it. On that footing the loop closes: agent runs post-train specialized models with measured kernel speed as the reward, and the system gets better with nobody in the loop._(The outcomes: 100% on KernelBench's 250 problems, 160 ATen operators at 100% correctness across 480 configurations, more than 25% training throughput on MTIA, more than 60% inference throughput on Andromeda in production.)_ Baseten, a startup, [published the same shape on August 28](https://www.baseten.co/blog/agentic-kernels-in-production/): kernels "identified, proposed, and implemented entirely by our agentic framework," kept only if they "pass correctness and end-to-end performance checks," now in production with latency down **42.3%** on one image model. Nicholas Carlini, a researcher on Anthropic's Safeguards team, got the same result for the same reason when sixteen agents wrote [a C compiler with a **99% pass rate**](https://www.anthropic.com/engineering/building-c-compiler) on most compiler test suites: "It's important that the task verifier is nearly perfect, otherwise Claude will solve the wrong problem."

Kavak's number is a conversion rate. Meta's is bitwise accuracy. Baseten's is latency. In every case the agent can read the score and can't touch it.

Now look at what the factories call "self-improving." [Uber's post](https://www.uber.com/us/en/blog/efficient-software-factory/) files its loop under future tense: "We are working on an automated way to record papercuts from agent skill executions and auto-generate skill updates from the collected traces." Kiro's post titled Continuous Prompt Evaluation, [August 21](https://kiro.dev/blog/continuous-prompt-evaluation/), discloses its author in the body: "This article focuses on evaluating human-authored system prompt and configuration changes." Warp's loop, above, ends at a human merging a PR.

The pattern is exact. Where correctness is a number, the loop closes and the human leaves. Where correctness is a review, the loop ends at a person. Self-improvement isn't a feature you add to a factory. It's what happens on its own when the machine can say no, and what never happens when it can't.

## The Floor Exists. Nobody Put Agents on It.

So the move is obvious: make application code the kind of place where correctness is a number. Zero of 13 operators did it. Not one changed the language, the runtime, or the codebase the agents write into. Stripe's monorepo is heavily typed, and Stripe typed it years ago, by humans, for humans, and [describes its homegrown libraries](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents) as "natively unfamiliar to LLMs." Meta, the largest operator in the sample, went the other direction. Mark Harman, a research scientist there, [argued in February](https://engineering.fb.com/2026/02/11/developer-tools/the-death-of-traditional-testing-agentic-development-jit-testing-revival/) that agentic pace is "scaling the cost of false positives and test maintenance to breaking point," and Meta's answer is tests that "are generated on-the-fly for each code change and do not reside in the codebase." Fewer durable checks, not more.

TigerBeetle, a financial database that runs [**2,000 years of simulated testing every 24 hours**](https://tigerbeetle.com/) against its own code, is on the opposite end. Its style guide [requires two assertions in every function](https://github.com/tigerbeetle/tigerbeetle/blob/main/docs/TIGER_STYLE.md), and its simulator, [extended again on August 20](https://tigerbeetle.com/blog/2026-08-20-protocol-aware-dst), can replay any failure it finds on demand. It's the floor: the densest set of machine checks on any codebase in the sample, built for humans doing safety-critical work, years before agents.

And there's no agent layer on it. No `AGENTS.md`, no `CLAUDE.md`, no agent lane in CI. On August 26, one day before Uber's post, the maintainers closed an agent-assisted contributor's open pull requests with one sentence: "[we're not accepting agent driven contributions at the moment!](https://github.com/tigerbeetle/tigerbeetle/pull/3887)"_(The account had opened 30 pull requests since July 20. Two merged, both changelog-link fixes. The refusal was posted on #3887 and #3919 seven seconds apart.)_ If any codebase on earth could let a machine decide whether an agent's change is safe, it's this one. 2,000 years of simulation a day is more scrutiny than any reviewer will ever give a diff. The maintainers didn't run the agent's code through it. A person said no, by hand, the same way the door works everywhere else.

That's the shape of 2026. The motor is at Uber, Stripe, and Anthropic, bolted to a floor laid out for people. The floor is at TigerBeetle, with no motor on it. Nobody has put them in the same building, and the building isn't a mystery: application code where a wrong change fails to compile instead of failing in review, one place to commit so the bug where the event fires without the row can't be written at all, and a core with no wall clock and no ambient randomness, so the whole application replays from a seed. On that floor an agent's change runs through thousands of simulated crashes before a person opens the diff, and the agent improves against a verdict it can't edit, the way Meta's kernels do. No engineer can hold that in their head, and that's the point: the machine holds it. Every stack you've ever worked on was built to fit inside a human's head. A software factory can't be, or it isn't one.

Agents won't build that floor on their own. They're trained on the code humans wrote, and the code humans wrote is the bolt-on code: a service around a database, extensive tests beside the logic, a review at the end, etc. That's just how software has always been built. Left alone, an agent will rebuild that floor for you in whatever language you hand it. Getting the other kind takes a compiler and a simulator that refuse the usual shape, and someone who designed the floor that way before the first agent touched it. Different code needs a different floor, and the floor has to come first.

## Ask Which Number It's Allowed to Fail

The only places anyone has built something recognizably AI-native are the places where correctness was already a number. Compilers. Kernels. Everywhere else, the factory is a very fast way to fill a review queue.

David Crawshaw, who co-founded Tailscale and now exe.dev, got closer than anyone. [His line from June](https://blog.exe.dev/replace-your-ci): "With agents, CI is useless, the merge queue is vastly superior." His company merges without peer review and runs the whole test suite synchronously in the queue. And he did it by changing the order of the checks, not the code the checks run on.

Everyone has the motor. Nobody has rebuilt the floor.

Next time someone talks about their software factory, skip the throughput slide. Ask which number the agent is allowed to fail, and who owns it.

---

Source: https://noahmitchem.com/notes/nobody-built-a-software-factory — this is the Markdown representation of that page, served from the same URL to clients that send `Accept: text/markdown`.
Site index for agents: https://noahmitchem.com/llms.txt · Full site text: https://noahmitchem.com/llms-full.txt · Contact: noah@noahmitchem.com