# Dark factory, software factory e human in the loop: o espectro

> Três nomes para três lugares da pessoa no pipeline, e onde o padrão do T25 fica.

- Por: Djan Magno
- Publicado em: 2026-10-25
- Atualizado em: 2026-10-25
- URL: https://t25.io/blog/dark-factory-software-factory-e-humano-no-loop/
- Pesquisa · dark factory, software factory, human in the loop, gate de aprovação, agentes de código

> **Resumo:** > - Dark factory, software factory e human in the loop nomeiam coisas diferentes. A primeira é um modo com pouca leitura humana. A segunda é a estrutura de estados, papéis e isolamento. A terceira põe a pessoa como estado em que o pipeline espera.
> - No padrão do T25 a spec espera uma pessoa, o plano depende do risco e o merge sai por `t25 merge` ou pela rota. A aprovação automática de spec nasce desligada. Promover o merge ou ligar a delegação não dispensa a pessoa.
> - Risco baixo dispensa a aprovação do plano. A entrega com pull request continua pedindo PR utilizável e merge antes de DONE.
> - As fontes externas desse argumento estão no post lights-on. Este aqui é o mapa dos interruptores.

## Três nomes, três lugares para a pessoa

Uma dark factory de software é um modo de operar: a pessoa entrega o objetivo e a máquina segue até a mudança integrada, com pouca leitura no meio. Uma software factory é a estrutura que torna isso possível, com estados, papéis, gates e isolamento. Human in the loop é outra regulagem em cima da mesma estrutura. A pessoa vira um estado, e a tarefa não avança enquanto esse estado não fecha.

Os três cabem no mesmo repositório. O que muda é qual transição a política deixa a máquina concluir sozinha. O [artigo sobre o que é uma software factory](https://t25.io/blog/o-que-e-uma-software-factory-para-agentes-de-codigo/) descreve a estrutura. Este descreve quem assina cada passo.

## Onde o padrão do T25 fica

| Passo | Padrão | O que empurra para uma dark factory |
|---|---|---|
| Spec | Humano. `t25.auto_approve_spec` nasce `false`. A escada de promoção não relaxa `approve_spec`. | Ligar `auto_approve_spec` assina spec de risco `low` ou `medium` quando não há gate de spec, comentário aberto nem critério faltando. `high` e `critical` continuam manuais. |
| Plano | `require_plan_approval` nasce `true`. Sem overlay no projeto, risco cujo `approval` não seja `none` para em `AWAITING_APPROVAL`. | `low` usa `approval: none`, então o plano segue sem esse gate, salvo `planApprovalLowRisk` no projeto. O overlay `requirePlanApproval` do projeto ganha da flag global: `false` tira o gate mesmo com a flag ligada, e `true` mantém o gate mesmo com a flag desligada. |
| Merge | Humano. O merge sai por `t25 merge` ou pela rota da API. `merge` fica `requires_human` até a promoção `delegated`, e a delegação institucional nasce com `enabled: false`. São travas separadas. | Promover `merge` a `delegated` e ligar `delegation.actions.merge` não bastam, juntas ou separadas. `executeMergeIntervention` não é chamado por rota, CLI nem estágio, e a semântica nasce desligada, em `shadow`. |
| Entrega | Até o risco `low` exige PR utilizável e `MERGED` antes de `DONE`. Teste verde não fecha a entrega. | No caminho com pull request não há atalho de DONE sem merge. Projeto só local troca a cadeia por QA e `LOCAL_APPROVED`. |

Os defaults de risco estão em `src/core/config.ts`: `low` pede `none`, `medium` pede `plan`, `high` pede `plan_and_pr` e `critical` pede `human_required`. Uma task `chore` nasce `low`. Os outros tipos nascem `medium`, em `defaultRiskForType`.

O merge continua um comando ou uma rota da API, e o registro leva o nome de quem executou. O [post lights-on](https://t25.io/blog/lights-on-humano-no-merge/) conta por que o padrão fica nesse ponto, com as fontes de fora. Os nomes das chaves estão na [referência de configuração](https://t25.io/docs/configuration.html).

## O que cada nome não cobre

Dark factory, aqui, não é um produto à parte. É o extremo em que a spec e o plano saem do caminho da pessoa, dentro do que o código ainda segura: risco alto e crítico ficam fora da aprovação automática de spec, e a entrega com PR continua pedindo um merge feito por uma pessoa.

Human in the loop também não é uma pessoa lendo cada token. No padrão, a pessoa assina a spec, o plano quando o risco pede, e o merge. No meio, os papéis de agente rodam sozinhos, cada um na worktree da tarefa. O isolamento dessa worktree está em [uma ordem, um worktree](https://t25.io/blog/uma-ordem-um-worktree-isolando-agentes-de-codigo/).

## Como ler o seu YAML

1. Olhe `t25.auto_approve_spec` e `t25.require_plan_approval`. O overlay `requirePlanApproval` do projeto ganha da flag global.
2. Olhe `risk.<nível>.approval` no risco que as suas tasks realmente usam. Chore e o resto não nascem no mesmo nível.
3. Olhe se `delegation.enabled` está ligado e se `merge` já foi promovido a `delegated`. As duas são travas separadas e não dispensam a pessoa do merge: `executeMergeIntervention` não entra no pipeline, e a semântica nasce desligada ou em `shadow`.
4. Com spec e plano no padrão, a operação é human in the loop nesses pontos, e o merge continua por `t25 merge` ou pela rota. O código registra qual interruptor mudou.

## Perguntas frequentes

### Dark factory e software factory são a mesma coisa?

Software factory é a estrutura: estados, papéis, gates e isolamento. Dark factory é operar essa estrutura com o mínimo de parada humana. Dá para ter a estrutura e ainda parar para uma pessoa.

### Human in the loop é uma pessoa em cada linha?

No padrão do T25 a pessoa entra na aprovação da spec, no plano quando o risco pede, e no merge. O meio do pipeline é agente, na worktree da tarefa.

### Risco baixo tira o humano do merge?

Risco `low` dispensa a aprovação do plano, porque o `approval` padrão é `none`. A entrega com pull request ainda exige PR utilizável e merge antes de `DONE`.

### O T25 aprova a spec sozinho?

Só com `t25.auto_approve_spec` ligado. Vale para risco `low` e `medium`, e só quando a spec não tem gate, comentário aberto nem critério faltando. `high` e `critical` ficam manuais.

### Desligar o gate de plano deixa a tarefa sem ninguém?

Tira a parada do plano. A spec e o merge seguem as regras deles. São interruptores separados.
