What is a software factory operator?
A software factory operator is the person who runs a software factory. The operator asks for changes, answers the decisions that a goal leaves open, and tries what comes out. The operator does not write the code, and the role does not depend on reading it.
The role exists because a software factory gives the building to agents and keeps the judgment with a person. It is a form of human-in-the-loop work, with the person placed at the two ends of the loop.
The role needs a habit that one operator calls calibrated distrust. Calibrated distrust is the habit of doubting an agent's report in step with how confident it sounds. The cleanest reports get the hardest checks.
How does an operator run a software factory?
In one operator's published log, the work repeats in four steps:
- The operator types a short request, e.g. one sentence about a menu.
- A coordinating agent turns the request into a written goal and reads back each open decision with a default.
- The operator answers only the decisions that should change, and says go.
- The operator reads the report when the phase ends and tries the result in the running product.
The requests are short, and there are many of them. In that log, the operator sent about 24 prompts a day to the coordinating agent and made a median of 7 decisions a day.
The same operator names three skills for the role:
- Brief. The operator states what "done" means in a form that a machine can check, e.g. a command that must exit with 0. A longer request can take the form of a PRD.
- Steer. The operator stops a run that is going wrong and adds the missing context. That work is context engineering under time pressure.
- Verify. The operator tries the result and compares it with the request.
Reading a goal before any agent builds is close to plan mode in a single agent session. The factory process fixes where that reading happens.
What is an example of an operator's day?
Here is an illustrative example. An operator at Acme Co., which sells furniture online, starts the day with the factory's overnight report. The day has five steps:
- The report lists 3 finished phases, and each one links to the running change.
- The operator opens the store and tries the first change, a date picker for deliveries.
- The operator types the next request, "Let customers edit their delivery address during checkout."
- The coordinating agent reads back 4 open decisions with defaults. The operator changes one and says go.
- In the afternoon the check stage reports a failure on that phase. The address saved, but the cart emptied.
The operator read no diff at any step. The decisions, the reports, and the running store were enough to direct the work. This example is simplified. A real day also includes requests that the operator cancels and rules that the operator adds after a mistake.
What does an operator stop doing?
An operator stops writing code and may stop reading most of it. At some sizes, reading every line is impractical. In the log cited above, a software factory deployed to production 72 times in 31 days. Its median change touched 4,578 lines of code across 47 files.
Advice on pull request size assumes that a person reads every line, so it does not fit changes of that size. The operator relies on verifying unread code instead, which means judging the software by what it does.
An operator also stops approving each step. An agent that asks permission for every command produces approval fatigue. The factory in that log moves approval to two points, the goal at the start and the result at the end.
What are the limits of one operator?
The operator who published that log lists costs of the role. The first two limits below are on that list, and the last two follow from it:
- Shared understanding is hard to keep. One person holds the picture of a product that changes every day. That picture is hard to pass to anyone else.
- Skill is delegated. An operator who never writes in a language does not build skill in it. The result is comprehension debt, which grows while nobody reads the code.
- One person is one point of failure. A queue that stops overnight waits until the operator comes back.
- Attention runs out. A factory runs on tokens and on the operator's attention, and only the tokens can be bought.
How is an operator different from a code reviewer?
A code reviewer reads a diff and approves or rejects it. An operator approves a goal before the work and judges the running result after it. The reviewer's evidence is the code. The operator's evidence is the behavior of the software.
A reviewer also meets each change once. An operator owns the queue, so the same person decides what is built next and what is dropped. In a dark factory, no person reviews the code, and the operator's decisions are the only human ones.
How can an operator check work without reading the code?
Try each change in the running product, and ask the factory for evidence of what its checkers did. A check from outside the factory's own agents gives a second view of each one. The guide to working on main shows one place for that check.
RunStory independently runs the software against your change and returns evidence to the coding agent. When something breaks, your coding agent receives the actions RunStory took and evidence of the unexpected result. The operator cited on this page runs the factory that builds RunStory. Your team keeps the final release decision.
FAQs
What is calibrated distrust?
Calibrated distrust is the habit of doubting an agent's report in step with how confident it sounds. An operator who works this way checks the cleanest reports the hardest. A summary that ends with the word "done" is a claim until someone reproduces the result.
How many decisions does a factory operator make in a day?
The number of decisions a factory operator makes depends on the factory. One operator's published log reports a median of 7 decisions a day. The coordinating agent gives each open decision a default, so the operator answers only the ones that should change.
Does a factory operator need to know how to code?
A factory operator needs to judge software more than to write it. The operator has to state what "done" means in a form that a machine can check, and has to tell when a result is wrong. Experience with code helps with both.
Can several people operate one software factory?
Several people can share one software factory, and the one published account expects that to be much harder. That log describes a factory of one, in which a single person holds the queue. A team has to agree on who orders the queue and who answers each open decision.
What does a factory operator read instead of code?
A factory operator reads goals, open decisions, and reports. The goal says what will be built, the decisions show what the goal left open, and the report says what the checks found. The operator then tries the running result.