The agentic software factory is the 2022 one with one box swapped

Coding agents didn't invent the software factory. They swapped one box in it. In 2022 a person built the thing; now an agent does, in minutes instead of days. Everything else stayed, and the slow part of shipping moved from building to review.

That framing comes from Dex Horthy's keynote at AGNTCon + MCPCon Europe, State of the Software Factory. He traces the idea of a software factory back to 1968, the year the term "software engineering" was coined, then draws the factory most teams ran in 2022. I liked that diagram so much I redrew it. Switch the tabs and watch where the yellow squares pile up.

The 2022 factory already had everything

Read it top to bottom. A team with a vision puts work in a tracker. Someone pulls a ticket, builds it, runs the tests, pokes it in a browser and opens a pull request. CI runs its battery of checks, a human tests the change, a human reviews it. It ships behind rollouts, feature flags and canaries. Users use it.

Then the two loops:

1. Rework. Review finds a problem and the PR goes back to whoever built it.
2. Feedback. Users file feature requests and complaints, monitoring wakes someone up at 3 a.m., and all of it lands back on the team's list.

None of this is AI. It's how most teams have shipped for a decade.

Swap the builder, move the bottleneck

The agentic factory keeps every box. Only the builder changes: it becomes a stack of orchestration, a harness, a sandbox and a model, with agents that test their own work, sometimes by driving a real browser.

Building now takes minutes or hours. Review still takes hours or days. So teams bring agents into review too, with agentic code review and agentic regression tests that catch the small stuff. It helps, but review often stays the bottleneck. In the agentic tab the squares fly through build and wait at review.

Lights-off: stop reading the code

The next step is what Dex calls the lights-off factory. Nobody reviews; the checks decide. Invest enough in CI, agentic testing and monitoring and it could almost work.

The catch is maintainability. A test tells you a feature works. Nothing tells you quickly whether the code will still be easy to change in two months. Models get better at what a verifier can score, and maintainability has no fast verifier, so nothing in training pushes them toward clean architecture.

SlopCodeBench, from the University of Wisconsin–Madison, measures exactly that. Agents don't get the whole spec up front. They get it in checkpoints and have to extend their own code each time, the way real projects grow. Dex's number from the talk: at launch, the best model on it, GPT 5.5, scored 14.8%. On single-shot benchmarks like Terminal-Bench, he says everyone is around 95%.

His conclusion is simple: if unattended model code gets worse over time, then for now, read the code.

So what actually changed

Who builds: a person became an agent stack you configure. Where the time goes: from typing code to planning it, reviewing it and wiring up feedback. What the job is: less writing, more deciding.

The rest of Dex's talk maps onto the same diagram:

• Plan before you build. Twenty or thirty minutes up front saves hours at review.
• Give agents back pressure. A browser, curl, the running app, so they can check their own work before a human does.
• Feed loop 2 straight in. A pager alert that arrives with the PR the agent thinks fixes it. Merge, go back to bed.
• Let agents experiment. Feature flags, three versions of a UI, and let real users pick.
• Compound. Read past agent sessions and turn what went wrong into skills and memory.

My factory runs on the agentic tab

My own setup sits right there. Work goes into Beads, one of the trackers Dex names. An agent builds in its own worktree, a model from another vendor reviews the change, and every change ends as a pull request that I merge myself. The slow part is my review queue. Exactly as drawn.

Watch the ten minutes where Dex draws the factory, it's worth it. And if your team really runs lights-off, I'd like to know how you keep the code base from rotting.

Plain text: software-factory-2022-to-lights-off.md · Atom feed · All notes