I'm Building the Dark Factory, and I Love It

Dan Shapiro's five levels run from spicy autocomplete to a dark factory where specs go in and software comes out. I'm a builder going for Level 5, and building it taught me the levels were never about the model. They're about the gates. Here's what my factory looks like, where it still needs a human, and how that squares with what I said about banks.

This post went from a URL to a pull request, and I touched it three times.

I pasted a link. I answered four questions about the angle. I approved a plan. Everything in between, the research, the source verification, the draft, the hero image, the diagram, the narration you can play at the top of this page, the build, the checks, and the pull request, was done by a factory I built. It even caught its own mistake: the first diagram printed the name of an internal gate in a way that should never go public, so the factory flagged it and re-rendered it before I ever saw it.

Dan Shapiro has a name for where I am, and a name for where I am going. In “The Five Levels: from Spicy Autocomplete to the Dark Factory,” he lays out a ladder for AI-assisted development. The top rung is a place where specs go in, software comes out, and no human is on the floor.

I am building toward that rung on purpose. I love it. And building it taught me something the ladder does not say out loud: the levels were never about how smart the model is. They are about how good your gates are.

Five levels, borrowed from the car

Shapiro’s premise comes from an earlier post on technical deflation: code is getting cheaper to produce every month, so the winning move is not typing faster. It is changing what you do. “If you are just using ChatGPT to write your regex,” he writes, “you aren’t really getting the benefits of deflation.”

He borrows the driving-automation levels to describe the climb:

Level 0, manual. You write every character. The code is “unmistakably yours.”
Level 1, discrete tasks. You hand off unit tests and docstrings. Faster, same job.
Level 2, pairing. The AI is a junior partner and you are in flow. Shapiro estimates most AI-native developers live here.
Level 3, safety driver. The AI writes the code and you review diffs. For many people this feels worse, not better.
Level 4, product manager. You write specs, craft skills, review plans, and check the tests after the agents have run for hours.
Level 5, dark factory. “It’s a black box that turns specs into software.” Dark, because it is “a place where humans are neither needed nor welcome.”

His sharpest line is about Level 2: it “feels like you are done. But you are not done.” I recognized that one. I spent most of last year there, feeling very productive, and I was not done.

What my factory actually is

Abstract ladders are easy to agree with. Here is the concrete version, from things I run every day.

The line: skills are the stations

This blog is produced by a skill called WritePost. It is a sequence of stations, each one a skill or a deterministic tool: gather context, research and verify every URL with an HTTP request, ask me the questions only I can answer, outline, write, generate the hero and the diagram, generate narration with a sentence-timing file for read-along, verify, update the content registry, branch, commit, push, open the pull request.

None of those stations is clever on its own. The value is that they always run, in order, the same way. The image station does not just generate a picture. It opens the picture and reads every label, because an early diagram shipped a duplicated label and I never wanted to see that again.

The supervisor: an operating system for agents

Above the line sits LifeOS, my personal agent system, and Arc, the assistant that runs it. Hooks fire on every tool call. Memory carries what I prefer from one session to the next, so I do not re-explain myself. A planning layer turns a vague request into criteria that can be checked before anything is called done.

For software work, Claude Buddy adds the classic factory flow: spec, plan, tasks, implement, each step producing an artifact the next step consumes. That chain is the closest thing I have to Shapiro’s “specs go in” description, and it is the part that runs longest without me.

This is the piece most dark-factory diagrams leave out. If no human is on the floor, someone still has to know what the floor is doing.

My factory has a control room. A monitoring layer captures every tool call and every failure. A dashboard shows what is running, what is queued, and what broke. A persistent history means I can ask what happened last Tuesday and get an answer grounded in the actual record, not a guess. And a chat surface on my phone is where the factory reports and where I approve, redirect, or stop it.

Dark means nobody has to stand on the line. It does not mean nobody can see the line. The monitoring, the history, and the chat are what make it safe for me to stop watching.

Why I love it

The honest answer is that my job got better.

At Level 3 I was a reviewer drowning in diffs. At Level 4 my work is specs, skills, and gates, the parts that need judgment. I decide what a good post is, what the factory is allowed to do, and what counts as finished. The factory does the rest, and it does it the same way at midnight as at nine in the morning.

The second reason is compounding. Every time the factory produces something I reject, the rejection becomes a gate. A draft once carried a first-person anecdote too specific to publish. Now there is a scan for that pattern, and a rule that the grep alone is not enough. A render once came back as a JPEG pretending to be a PNG. Now the image station converts and verifies dimensions every time.

None of those fixes required a smarter model. They required me to write down what “wrong” looks like, once, in a place the factory reads. That is the loop I described in The Machine Has Better Discipline Than Your Team: the agent that runs the check every single time is a better citizen than my best intentions on a Friday afternoon.

The case against, taken seriously

I would not trust my own enthusiasm if I could not argue the other side well. So here it is, at full strength.

The most aggressive public example of Level 5 is StrongDM’s AI team. As Simon Willison reported, their charter is two lines: code “must not be written by humans,” and code “must not be reviewed by humans.” They back it with scenario tests stored outside the codebase, where the coding agents cannot see them, and with a “Digital Twin Universe” of behavioral clones of services like Okta, Jira, and Slack. Their benchmark for ambition is blunt: if you have not spent at least $1,000 on tokens today per human engineer, your software factory “has room for improvement.”

Willison, who is no skeptic of agents, called the no-review rule the most interesting part, and questioned the economics: at $20,000 a month per engineer, the patterns become “far less interesting.”

The accountability critique is sharper. Eran Kahana at Stanford’s CodeX asked, in “Built by Agents, Tested by Agents, Trusted by Whom?”, what happens to liability, contracts, and disclosure when “no human reviewed the code that produced a given output.” Agents testing agents can share the same blind spots. His summary of the risk is the one that should keep a builder honest: “when it fails, nobody will know why.”

And there is a quieter failure mode. A sloppy spec produces sloppy tests, and sloppy code passes sloppy tests. The factory reports green. Everything is wrong. Meanwhile the human who stopped reading code slowly loses the ability to tell, which is the erosion I wrote about in You Can’t Forward the Understanding.

Every one of these objections is real. None of them, in my experience, is an argument against the factory. They are arguments against a factory without gates.

The levels are gated by verification

The best sentence I have read about Shapiro’s ladder is not his. It is from James Phoenix, in “The Five Levels Are Gated by Verification, Not Intelligence”: “Your autonomy level is a property of the repository, not the developer and not the model.”

That matches what I have built. I am not at one level. I am at different levels in different lanes. Blog production is close to dark. Changes to the agent system itself run at Level 4, because I still read the plan. Anything that publishes to the outside world stops for a human “go,” on purpose.

What moved each lane up was never a model upgrade. It was a gate. The build must pass. Every external link must return a real HTTP status. The confidentiality scan must come back clean, and the opener gets read by hand anyway. The writing must pass a slop check with hard caps. Every image label must be read back and verified. Each of those is a piece of review I used to do with my eyes, now done by a check that never gets tired.

Shapiro's six levels drawn as a staircase from L0 Manual to L5 Dark Factory, beside my factory: a human writes the spec, skills and agents do the work, a column of gates (build, links, confidentiality, slop check, vision check) does the reviewing, a human approves the pull request, and a monitor, history, and chat bar watches every stage

So going dark does not take the human out of the loop. It moves the human. Upstream, into the spec and the gates. Downstream, into the evidence. The middle, where the code and the prose get produced, is the part that goes dark. StrongDM’s hidden scenarios are the same idea at a much higher budget: they did not remove review, they moved it somewhere the agents cannot game.

That is also my answer to “nobody will know why.” In a factory with a control room, somebody can know why. The history is there. The gates that passed are recorded. The failure is a record, not a mystery.

Squaring it with the bank

In August I wrote The AI Factory Has Five Rungs and said the lights-out factory is not appropriate for anything material in a bank, and should not be. I still believe that. Here is why it does not contradict this post.

In my lanes, I own the blast radius. If the factory publishes a bad post, I am the one who wrote the spec, I am the one who approved the gates, and I am the one who fixes it. Authority, accountability, and consequence all sit with the same person.

A material change in a bank does not work that way. A change to a payment flow has an owner, an approver, a control framework, and an examiner who will ask who authorized it. “The factory decided” is not an answer there, and the people asking are right to insist on a better one.

But look at what both sides actually want. The builder wants speed: specs in, software out, no one stuck reviewing diffs at midnight. The institution wants control: identity, attribution, determinism, an audit trail. The gates are where those meet. Every gate I added to go faster is also a control someone could inspect. The path up the ladder is the same in a personal lane and an enterprise one. Build the verification first, then turn the lights off one lane at a time. The ceiling sits in a different place. The way you climb does not change.

What I have not solved

Level 5 is not done. My taste is still in the loop: I choose the topic and the angle, and a factory that picks its own topics is a different machine from the one I want. The merge and the social post stop for me deliberately, because posting to the world is the one action I cannot quietly undo.

Agents still write some of the tests that check agents, and I have not fully solved that. Hidden scenarios are the right direction, and I am only partway there. And all of this is evidence from one builder with full control of his own stack. That is a useful laboratory. It is not a study.

Turn the lights off one lane at a time

Shapiro says Level 5 “will likely be our future.” I think he is right, with one amendment: it arrives lane by lane, and every lane gets there the same way. Through the gates.

Pick the lane where you own the blast radius. Write down what “wrong” looks like until a check can catch it. Give the factory a control room so dark never means blind. Then step off the floor and watch the record instead of the line.

It is the most fun I have had building in twenty years.

If this resonated, read The AI Factory Has Five Rungs for the enterprise version of the same ladder, and Six Primitives for a Code Factory for the parts a factory needs before the lights go off.

Find me on X @orestesgarcia or LinkedIn.