⏱️ 8 min de leitura
No capítulo anterior, a IA saiu do meu volante durante o dia. Eu passei a definir, acompanhar e aprovar, e a ferramenta fazia o resto. À noite, a fábrica ainda dependia de mim: quando eu ia dormir, ela parava.
Este capítulo é sobre a primeira noite em que isso não aconteceu.
O ensaio
A primeira tentativa foi na véspera. Passava da meia-noite quando coloquei para rodar a primeira execução com duas tarefas agrupadas e fui dormir.
A execução terminou bem, à 01h42. Depois disso, a máquina parou, porque não tinha mais nada na fila. Acordei com duas tarefas prontas e o computador parado havia mais de seis horas.
Para a máquina trabalhar a noite inteira, alguém precisava deixar a noite organizada antes: o que roda, em que ordem, o que pode rodar junto e o que não pode. De dia, quem fazia isso era eu, entre uma sessão e outra. À noite, não tinha ninguém.
O roadmap da primeira noite
Esse alguém chegou no dia seguinte: o Product Owner de IA do capítulo 2, ainda em uma versão bem mais simples. E quem entregou o PO foi a própria ferramenta. A execução que construiu o PO terminou às 21h21. Quatro minutos depois, começou a primeira etapa do primeiro roadmap que ele montou.
Eram sete etapas. Nas da madrugada, o PO montou pares de tarefas que não mexiam nos mesmos arquivos, para rodar ao mesmo tempo, em duas frentes. As duas últimas etapas eram diferentes: cada uma juntava duas tarefas de tela em uma execução só, porque elas mexiam nos mesmos lugares.
Todas as tarefas estavam no modo Automático, inclusive as de tela: do código até a integração, sem parar para eu olhar.
A noite quase não começou. Às 22h23, uma segunda cópia do aplicativo, aberta sem querer, bagunçou o roadmap, e ele parou. A IA consertou o arquivo, e às 22h47 o roadmap voltou a rodar. Contei esse susto no capítulo 1, e ele tem um capítulo próprio: Um sistema que a IA lê, a IA conserta (capítulo 8).
Hora a hora
Às 23h30 começou a terceira etapa. Pouco depois, mandei a última mensagem da noite para o Claude:
"Cancela o monitor, vou dormir e deixar o PC rodando."
O monitor era o Claude acompanhando as execuções por mim. Cancelei para não gastar uma IA olhando outra IA trabalhar enquanto eu dormia. Essa ideia volta no capítulo 5, O token mais caro é o de uma IA esperando.
Depois disso, não mandei mais nenhuma mensagem até as sete da manhã. O que aconteceu nesse intervalo eu só vi de manhã, nos registros.
- 23h30. Duas execuções. Uma ensinava o Write & Review a enriquecer uma tarefa e gravar o resultado de volta nela. A outra criava o supervisor de plantão. A primeira levou 55 minutos. A segunda levou 80, porque o revisor devolveu o código uma vez.
- 00h49. O supervisor em todas as telas, com um chat que sabe em que tela eu estou, e um fluxo de triagem que transforma um pedido em tarefa, com notas de impacto e de complexidade. A triagem passou três vezes pelo revisor antes de ser aprovada.
- 01h33. Um índice ao lado dos arquivos de estado, para consultas rápidas, e a entrada por voz, com a transcrição feita no próprio computador. O índice teve o único conflito da noite: duas mudanças no mesmo trecho. O fluxo resolveu sozinho, em cerca de um minuto, e testou tudo de novo.
- 02h33. A primeira etapa com uma execução só. Os itens do roadmap ganharam títulos, selos e a troca de modo com um clique, e as mudanças de tela ganharam regras próprias, com a captura de cada estado e uma revisão visual.
- 03h07. A última etapa: a tela de aprovação com os artefatos de cada execução e o botão Run App, que abre a versão nova do aplicativo com um clique.
- 04h02. A última execução terminou, e a máquina parou.
Os registros mostraram um detalhe que eu não tinha previsto: cada etapa só começava quando a anterior terminava inteira. Às 00h25, uma das frentes ficou livre e esperou 24 minutos pela outra. A noite andava no ritmo da execução mais lenta de cada etapa.
O que a fábrica construiu enquanto eu dormia
Olhando a lista de manhã, uma coisa me chamou a atenção: tudo o que a fábrica construiu naquela noite foi para ela mesma. E boa parte era justamente o que faltava para ela trabalhar sem mim:
- o supervisor de plantão, para acompanhar as execuções que eu não estaria acompanhando;
- a triagem com notas de impacto e complexidade, o começo da triagem do PO do capítulo 2;
- a entrada por voz, o ditado que eu usava e que virou funcionalidade;
- o Run App e a tela de aprovação com as capturas, que viraram o modo Validated.
A ferramenta passou a noite construindo as ferramentas que iam me deixar dormir. O Run App, que eu uso hoje para aprovar uma tela, foi feito sem mim, às três da manhã.
De manhã
O resultado da noite:
- 10 tarefas entregues em 8 execuções, todas com sucesso.
- 23 commits e mais de 10 mil linhas na main, em quatro horas e meia.
- Nenhuma execução parada esperando por mim.
- Um conflito, resolvido pelo próprio fluxo.
- Em 3 das 8 execuções, o revisor devolveu o trabalho para correção antes de aprovar.
O que eu senti naquela manhã ficou registrado em uma conversa com a IA:
"Pensando na filosofia ágil, para mim pareceu muito melhor eu ir dormir e acordar com propostas já mergeadas, onde eu posso fazer um refinamento em cima do que já foi feito."
Em vez de imaginar uma tela antes de ela existir, eu tinha a tela pronta para julgar. Essa ideia tem um capítulo próprio: Refinar antes ou reagir depois? (capítulo 7).
A manhã também mostrou um risco. A última etapa usou as regras e os componentes de tela criados na etapa anterior. Se eu não gostasse do trabalho das 02h33, a correção não ficaria só nele, porque já tinha trabalho apoiado em cima. Em uma noite sem ninguém olhando, o custo de errar em uma tela cresce a cada etapa. A regra que ficou: à noite, tela pode ir no Automático, mas sem empilhar na mesma noite telas que dependem uma da outra.
E a revisão da manhã precisa caber em uma hora. Dez entregas só cabem nesse tempo se cada uma chegar com evidência: capturas, registros e o app rodando com um clique. Sem isso, eu passaria a manhã lendo código.
Às 08h47, abri a etapa seguinte. A primeira tarefa do dia era a correção definitiva do susto das 22h23: uma única cópia do aplicativo por pasta de trabalho.
Os números daquelas 24 horas também tinham um lado menos bonito. Eu mandei 76 mensagens, espalhadas por 12 horas diferentes, e 23 delas foram às dez da noite, consertando o roadmap. De madrugada, a fábrica trabalhou sem mim. De dia, eu ainda estava longe das duas horas.
As 4h45 paradas
Somando as 24 horas, de oito da manhã a oito da manhã, a fábrica teve alguma execução rodando por quase 15 horas. No dia anterior, foram pouco mais de 7.
O número que mais me incomodou foi outro. Das 04h02 às 08h47, a máquina ficou 4 horas e 45 minutos parada. Ela não falhou, não travou e não esperou aprovação. Só não tinha mais trabalho planejado.
Foi aí que escrevi uma frase que virou princípio do projeto:
"Desenvolvedor bom não fica parado. Quando acaba o backlog que ele tinha, ele vai buscar mais ou pergunta ao PO, e o PO vai empurrando trabalho."
Essa lacuna virou três tarefas:
- Roadmap vivo: quando a última etapa termina, o PO é chamado sozinho e acrescenta as próximas tarefas prontas. É o roadmap que se reabastece, do capítulo 2.
- Computador acordado: 24x7 depende de uma coisa simples, o PC não entrar em modo de espera. Um botão segura o modo de espera enquanto houver trabalho rodando.
- Vigia noturno: um agente com algumas permissões a mais durante a noite, para destravar o que pode ser desfeito e deixar para mim o que é decisão minha.
O roadmap vivo ainda não estava pronto na noite seguinte. Então, com a ajuda da IA, emendei à mão três etapas pequenas no fim do roadmap, só para a máquina não parar. Ela não parou: foram cerca de 25 tarefas até as sete da manhã.
A métrica também mudou. Para uma fábrica 24x7, a pergunta mais importante talvez não seja quantas tarefas ela entrega por noite, e sim quantas horas de trabalho bem definido estão prontas quando eu vou dormir. Um dia, quero abrir o backlog e ler: "tem cinco noites de trabalho prontas".
A aprovação mudou de hora
Nenhuma execução parou para pedir a minha aprovação naquela noite. Isso não contraria a regra do projeto. A aprovação não sumiu: ela mudou de hora. O roadmap que eu aceitei antes de dormir já dizia o que podia entrar sem mim, em que ordem e em qual modo.
Quando uma tarefa precisa de mim, a noite espera. Na madrugada seguinte, uma tarefa chegou a um ponto em que o fluxo exige a minha aprovação e ficou mais de duas horas parada, esperando eu acordar.
A regra continua a mesma dos capítulos anteriores: a automação nunca atravessa uma aprovação humana.
O próximo passo
Quando somei o tempo das etapas daquela noite, uma conta não fechava. Testar levou mais do que desenvolver: cerca de 3h15 contra 2h10. E 1h20 desse teste foi um agente esperando um comando terminar.
No próximo capítulo, O gargalo não é o código, é o teste (capítulo 4), conto por que escrever código deixou de ser a parte cara do trabalho e o que eu mudei para as noites seguintes não gastarem o relógio esperando.