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

Coding agents didn't invent the software factory, the steps from ticket to production. They swapped one box in it.

A person built each change in 2022. Now an agent does, in minutes instead of days. Everything else stayed, and the slow part 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 software factory back to 1968, the year the term "software engineering" was coined.

Then he draws the factory most teams ran in 2022. I liked it so much I redrew it. Next to it, I put the agentic factory and the lights-off one: only build and review change.

The software factory, from 2022 to lights-off

Every box stays, only build and review change

BuildReview

2022Someone builds the thingA human tests and reviews the change

AgenticAn agent stack builds the thingbottleneckAgentic review joins the human oneThe work queues here

Lights-offAn agent stack builds the thingskippedNobody reads the codeWork moves as fast as the checks allow

Every other box stays: the team, the tracker, the pull request, the checks, prod, users and monitoring.

Redrawn from Dex Horthy's State of the Software Factory keynote, AGNTCon + MCPCon Europe 2026.

Everything was already in the 2022 factory

Follow one change through it. A team with a vision puts work in a tracker. Someone pulls a ticket, builds it, runs the tests, tries it in a browser and opens a pull request.

CI runs its 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:

Rework. Review finds a problem and the PR goes back to whoever built it.
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.

The 2022 factory's two loops

Two loops send work back, and neither is AI

Loop 1Rework

Review finds a problem
The pull request goes back to whoever built it

Loop 2Feedback

Users file requests and complaints
Monitoring wakes someone at 3 a.m.
All of it lands on the team's list

It's how most teams have shipped for a decade.

The two loops of Dex's 2022 factory, pulled out on their own. Both were there long before any agent.

Only the builder changes

The agentic factory keeps every box. Only the builder changes: it becomes a stack of orchestration, a harness (the program around the model), a sandbox and a model.

Its agents test their own work, sometimes in a real browser.

Building now takes minutes or hours. Review still takes hours or days.

So teams bring agents into review too: agentic code review, and agentic regression tests that catch small problems. It helps, but review often stays the bottleneck.

In the agentic factory, work flies through build and waits at review.

The one box that changes

Building got faster, review didn't

2022Agentic

Who buildsA personAn agent stack: orchestration, harness, sandbox, model

TestingTests, then a try in a browserAgents test their own work, sometimes in a real browser

BuildDaysMinutes or hours

ReviewHours or daysStill hours or days

Agentic review helps, but review often stays the bottleneck.

The builder box from Dex's diagram, before and after. The times only show the order of magnitude, not measurements.

Nobody reads the code

Next comes what Dex calls the "lights-off" factory, like a plant that runs in the dark with nobody inside. Nobody reviews; the checks decide.

Invest enough in CI, agentic testing and monitoring, and it could almost work.

The problem 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, an automatic grader, can score. 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: if unattended model code gets worse over time, then for now, read the code.

Best scores, as Dex gave them in the talk

Around 95% in one shot, 14.8% when the spec grows

Whole spec at once, like Terminal-Bench~95%

Spec in checkpoints, SlopCodeBench14.8%

His conclusion: for now, read the code.

Dex's two numbers from the talk, drawn to scale. The top bar is his "around 95%" for everyone on single-shot benchmarks, not one measured score. The bottom one is GPT 5.5, the best at launch.

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 or the running app pushes back, so they check their own work before a human does.
Feed the second loop straight in. The pager alert comes with the PR the agent thinks fixes it. Merge and 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.

The rest of Dex's talk, on the same diagram

Five practices, each on a box that was already there

The practiceWhat it does

TrackerPlan before you buildTwenty or thirty minutes up front saves hours at review

BuildGive agents back pressureA browser, curl or the running app: they check their own work first

Loop 2Feed it straight inThe pager alert arrives with the PR the agent thinks fixes it

ShipLet agents experimentFeature flags, three versions of a UI, real users pick

BuildCompoundPast sessions become skills and memory

The five practices from the list, each pinned to the box it changes. Loop 2 is the feedback loop from users and monitoring back to the list.

My factory is the agentic one

Work goes into GitHub Issues. An agent builds in its own worktree.

A model from another vendor reviews the change. Every change ends as a pull request I merge myself.

My review queue is the slow part, as drawn.

My setup, on Dex's boxes

Agents build and review, my review queue is the slow part

TrackerGitHub IssuesWork goes in as an issue.
BuildAn agentIt builds in its own worktree.
ReviewAnother modelA model from another vendor reviews the change.
MergeMeEvery pull request waits for me to merge it.

My setup on the same boxes. The slow part is the queue of pull requests waiting for me.

Watch the ten minutes where Dex draws the factory; they're worth it. If your team really skips human review, I'd like to know how you keep the code easy to change.

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