# Dark factory vs software factory: the human-in-the-loop spectrum

> Three names for three places a person can sit in the pipeline, and where T25's defaults land.

- By: Djan Magno
- Published: 2026-10-25
- Updated: 2026-10-25
- URL: https://t25.io/en/blog/dark-factory-vs-software-factory/
- Research · dark factory, dark software factory, human in the loop, approval gate, coding agents

> **TL;DR:** > - A dark software factory is an operating mode with little human reading. A software factory is the structure of states, roles and isolation. Human in the loop makes the person a state the pipeline waits on.
> - T25's defaults wait for a person on the spec, on the plan when risk asks for it, and on the merge through `t25 merge` or the route. Automatic spec approval ships off. Promoting merge or turning delegation on does not dismiss the person.
> - Low risk skips plan approval. A pull-request delivery still needs a usable PR and a merge before DONE.
> - Outside sources for that choice live in the lights-on post. This one is the map of the switches.

## Three names, three places for a person

A dark software factory runs like this: someone states the goal, and the machine carries the change through to integration with little reading along the way. A software factory is the machinery that makes any of these modes possible: fixed states, roles, gates and an isolated checkout. Human in the loop is a third setting on that machinery. The person becomes a state, and the task stays there until that state closes.

You can keep all three words and still have one repository. The policy decides which transition the machine may finish alone. The [article on what a software factory is](https://t25.io/en/blog/what-is-a-software-factory-for-ai-coding-agents/) covers the structure. This one covers who signs each step.

## Where the T25 defaults sit

| Step | Default | What moves it toward a dark factory |
|---|---|---|
| Spec | A person. `t25.auto_approve_spec` ships `false`. The promotion ladder never relaxes `approve_spec`. | Turning `auto_approve_spec` on signs a `low` or `medium` spec when there is no spec gate, no open comment and no missing acceptance criterion. `high` and `critical` stay manual. |
| Plan | `require_plan_approval` ships `true`. With no project overlay, any risk whose `approval` is not `none` stops in `AWAITING_APPROVAL`. | `low` uses `approval: none`, so the plan continues without that gate unless the project sets `planApprovalLowRisk`. The project overlay `requirePlanApproval` wins over the global flag: `false` drops the gate even when the flag is on, and `true` keeps the gate even when the flag is off. |
| Merge | A person. The merge runs through `t25 merge` or the API route. `merge` stays `requires_human` until the `delegated` promotion, and institutional delegation ships with `enabled: false`. Those are separate locks. | Promoting `merge` to `delegated` and turning on `delegation.actions.merge` are not enough, alone or together. `executeMergeIntervention` has no caller in a route, the CLI or a pipeline stage, and the semantics ship off, in `shadow`. |
| Delivery | Even `low` risk requires a usable PR and `MERGED` before `DONE`. A green test does not close the delivery. | On the pull-request path there is no shortcut to DONE without a merge. A local-only project swaps that chain for QA and `LOCAL_APPROVED`. |

The risk defaults live in `src/core/config.ts`: `low` asks for `none`, `medium` asks for `plan`, `high` asks for `plan_and_pr`, and `critical` asks for `human_required`. A `chore` starts at `low`. Every other task type starts at `medium`, via `defaultRiskForType`.

The merge is still a command or an API route, and the record stores the name of whoever ran it. The [lights-on post](https://t25.io/en/blog/lights-on-human-at-merge/) explains why the default sits at this point on the spectrum, with the outside sources. The key names are in the [configuration reference](https://t25.io/en/docs/configuration.html).

## What the names do not cover

A dark factory, in this piece, is the far end of the same product: the spec and the plan leave the person's path, inside the limits the code still holds. High and critical risk stay out of automatic spec approval, and a pull-request delivery still asks for a merge a person runs.

Human in the loop is also not a person reading every token. On the defaults, a person signs the spec, the plan when risk asks, and the merge. Between those points the agent roles run on their own, each one in the task's worktree. That isolation is in [one task, one worktree](https://t25.io/en/blog/one-task-one-worktree-isolating-ai-coding-agents/).

## How to read your YAML

1. Check `t25.auto_approve_spec` and `t25.require_plan_approval`. The project overlay `requirePlanApproval` wins over the global flag.
2. Check `risk.<level>.approval` for the risk your tasks actually use. A chore and everything else do not start at the same level.
3. Check whether `delegation.enabled` is on, and whether `merge` has already been promoted to `delegated`. The two locks are separate, and neither dismisses the person from the merge: `executeMergeIntervention` is not on the pipeline, and the semantics ship off or in `shadow`.
4. With spec and plan at the defaults, the operation is human in the loop at those points, and the merge still runs through `t25 merge` or the route. The code records which switch changed.

## FAQ

### Are a dark factory and a software factory the same thing?

A software factory is the structure: states, roles, gates and isolation. A dark factory is running that structure with as few human stops as possible. You can have the structure and still stop for a person.

### Does human in the loop mean a person on every line?

On T25's defaults a person shows up for spec approval, for the plan when risk asks, and for the merge. The middle of the pipeline is an agent, in the task's worktree.

### Does low risk take the human off the merge?

`low` risk skips plan approval, because the default `approval` is `none`. A pull-request delivery still requires a usable PR and a merge before `DONE`.

### Can T25 approve the spec on its own?

Only with `t25.auto_approve_spec` turned on. That path covers `low` and `medium` risk, and only when the spec has no gate, no open comment and no missing criterion. `high` and `critical` stay manual.

### If I turn off the plan gate, is nobody left?

That removes the plan stop. The spec and the merge keep their own rules. The switches are separate.
