~ $ cd #content
back to writing

~ $ cat writing/dark-software-factory.md

The Dark Software Factory

·5 min

Walk onto the floor of a modern car plant at night and you might find the lights off. Not because the plant is closed. Because nobody is standing on the floor. Robots weld, stamp, paint and move parts in the dark, since a robot does not need to see what it is doing. The lights only come on when a human walks in, and a human almost never walks in.

That is a dark factory. The term is speaking, the industry calls it lights-out manufacturing, and the car world has been creeping toward it for years. I have spent a good while working with manufacturing customers, and the image stuck with me.

A dark factory is not "a factory with some automation." Every factory has some automation. A dark factory is the limit case, the place where the humans moved up and out. They design the line, they set the targets, they read the dashboards. They stopped touching the product.

Before you fall in love with that picture, hold one story next to it. Tesla. Around 2018, ramping the Model 3, Tesla tried to automate almost the entire line. It did not go well. The over-engineered line became the bottleneck, the company burned through cash, and it came uncomfortably close to not making it. Afterwards Musk said the quiet part out loud: "Excessive automation at Tesla was a mistake. To be precise, my mistake. Humans are underrated." They ripped out a "crazy, complex network of conveyor belts" that simply was not working.

So even the company most willing to bet everything on robots learned that a line has a wrong amount of automation, and that wrong amount is not "all of it." Atleast, not all at once.

Keep that in your back pocket. We will come back to it.

The dark software factory

Here is the claim I want to make: we can now build the same kind of factory for software. Call it the dark software factory.

The product is the running system. The workers are agents. And most days, nobody touches the code. Nobody touches production.

I am not asking you to imagine a far-off world. The pieces exist already in different places, and this post is me connecting the dots. We have coding agents that open pull requests. We have agents that watch production and propose fixes. We have platforms that give all of them shared context. None of it is science fiction anymore. What is missing is the picture of how it fits together, and the honesty about where it should stop.

This is the first post in a short series. Here I want to paint the big picture and convince you the factory is real. In later posts I will go deep on each of the three phases that make it run.

Why software wants this more than cars do

It is tempting to assume the dark software factory is just car automation with different parts. It is similar, but the difference is striking.

A car factory builds a template. The 2026 model rolls off identical to the one before it, and the one after it. Variation is a defect. You tune the line once, then it just runs, and it keeps running the same way until next year's model.

Software is the opposite. The artifact is creative. There are countless valid ways to build the same feature, and the "correct" one keeps moving. Variation is not a defect, it is the job. And the line never stops. You swap Java for Go, you change the database, you tear out a service, all while the thing you built is live in production serving real people.

Car factory versus software factory

A skeptic will push back here, and they are right to. Car factories retool too. They do, but on a yearly plan, decided by humans, between model years. The dark software factory retools continuously, and the trigger is not a calendar. It is a signal from the running system. That is the real difference, not "things change" versus "things stay the same," but who decides to change, and how often.

That is also why this matters more for leaders than it might first look. When the artifact is creative and the line never stops, the bottleneck stops being how fast people can type. It becomes how fast you can decide, build, run and learn, safely, without a person in the middle of every step. The organizations that figure this out get to ship more digital product, faster, with their best people spending their time on judgment instead of plumbing. That is the prize.

Enough talk. Show me how.

The dark software factory has three phases. Feature creation, build, and operate. Evolution is not a fourth phase, it runs through all of them, which I will come back to.

But first, the building itself.

The foundation: many agents, one platform

A factory needs a building before it needs workers. For the dark software factory, that building is a platform.

The point of one platform is shared context, shared guardrails and shared memory. The agents can see each other's work, the previous decisions, the repo, the pipeline, the metrics. They are workers on the same floor, not a thousand lonely chat windows each rediscovering the codebase from scratch.

The failure mode without a platform is easy to picture. Copy-paste agents, no shared state, every one of them starting cold. That is the well-lit factory where everyone trips over everyone else. The whole model rests on getting this part right first.

Here is how work moves across that floor, start to finish.

Inside the dark software factory: signals enter the platform, agents create and build the change, it passes the human approval gate, deploys to production, and production signals loop back to intake

Notice the one station that stays lit. Everything else can run in the dark, but the change still passes through a human who puts their name on it before it ships. Hold that thought, because it is the whole argument at the end of this post. The rest of this section walks the three phases the diagram lays out.

Phase one: feature creation

Where does the work come from when no product manager is typing tickets?

Two places. Inside signals and outside signals.

Inside, the running system reports on itself. Latency creeping up. A funnel quietly dropping. A feature that nobody uses. The factory notices its own product is underperforming and proposes work to fix it.

Outside, the signals are the order desk. A support ticket. A competitor's move. A new API, a new regulation, a direct user request. These come in, get understood, and turn into candidate work.

The interesting and slightly uncomfortable part is that the factory can propose its own backlog. The candidate list writes itself. Humans still own the direction, the "should we even do this," but they are choosing from a list the factory drafted rather than staring at a blank page. For a leader, this is the shift worth sitting with. The question moves from "what should we build" to "of the things the system thinks are worth building, which do we approve."

Phase two: build

This is the part that already half exists, so I will not oversell it.

An agent picks up a specification, implements against it, runs the tests, and opens a pull request. On a shared platform it can do this with real context, not a guess at what the rest of the system looks like.

The one thing I want to stress, because it is the hinge the whole thing swings on, is the ownership boundary. However the change was produced, by a fully autonomous agent or a developer steering one, it converges at the same gate. A pull request, with the same quality checks, approved by a named human who takes responsibility for it. The dark software factory can be dark right up to that line. The accountability is not dark. This, however, is a slope of maturity. Once the system provides enough trust, we can move beyond the synchronous nature of accountability.

Phase three: operate

Building is the easy half. Running it is the job.

The good news is that operations might be the most agent-ready domain we have. It is already drowning in telemetry and runbooks, which is exactly the structured, repetitive material agents are good with. Specialized agents for triage, for rollback, for incident response, fit naturally here. This is the bottom of the flow diagram above: the running system, watched and operated by agents, feeding its signals back to the top.

This is also where the dark software factory gets genuinely scary, and I am not going to pretend otherwise. A bad deploy at 3am with no human watching is a real risk, not a hypothetical. So you build brakes. Blast-radius limits, so a bad change can only hurt so much. Automatic rollback, so the system can undo itself. And the human pager as the last resort, not the first.

A real dark factory still has an emergency stop and a skeleton night crew. The software equivalent is the same idea. "Dark" does not mean "nobody is responsible." It means the humans are not on the floor for the routine, and they are very much reachable when it counts. This also reiterates the trust angle I mentioned before. Before we trust the operation part of the dark software factory enough to allow it to take more and more accountability.

Running through all of it: evolution

Here is the piece with no clean car analogy, which is exactly why it is the most interesting.

A car line is mostly fixed once the template is set. That is a simplification, but it holds up well enough. Software is the opposite. It changes far more often than my car does, and frankly I am glad my car does not get retooled every Tuesday.

So the factory has to do something a car plant never does. It has to watch its own output, learn which patterns keep failing, and update its own templates, guardrails and agents based on what it shipped last week. The line retools itself.

Evolution runs through every phase. The factory watches what it ships and updates its own templates, guardrails and agents

It is worth separating two kinds of change here, because they are not the same animal.

One is changing the product. New features, fixes, the everyday output. That is phases one through three doing their job.

The other is changing the factory. A new language, a new architecture, better agents, tighter guardrails. That is the loop above, and it is the part that genuinely breaks the manufacturing metaphor. A car plant does not redesign itself based on the cars it built. The dark software factory can, and that is what makes this new rather than just "more automation."

I will be honest about the seams. Parts of this exist today and work well, like agents watching production and drafting fixes. Other parts, the factory cleanly rewriting its own guardrails from what it learned, are closer to the frontier than to the warehouse. I would rather tell you that than sell you a finished thing that does not exist yet.

The Tesla lesson, on purpose this time

Now back to the conveyor belts.

Tesla's near-miss was not a story about robots being bad. It was a story about removing humans from the wrong places, all at once, before the line was ready for it. The fix was not to abandon automation. It was to put people back exactly where their judgment mattered and let the robots keep the rest.

That is the lesson for going dark with software, and it is the note I want you to leave with.

Maturity is a dial, not a switch. Each of the three phases, feature creation, build and operate, can be turned up toward more autonomy independently, and at its own pace. A team with excellent tests and a tight rollback story can run its build phase much darker than a team without them. The same team might keep feature creation firmly in human hands a while longer. That is not indecision, that is the right amount of automation for where you actually are.

And there is one dial you never turn all the way. Accountability. The factory floor can go dark. The pager still rings a human. Every change that ships still has a name on it. The moment "the agent did it" becomes an acceptable answer is the moment you have automated away the one thing you cannot afford to lose.

So the lights stay off. The robots keep working through the night. But someone is still paying the electricity bill, and someone is still deciding what the place builds and how far to trust it. The humans did not leave the factory.

They moved upstairs.