Engenharia Robots-First

O software foi construído para pessoas. O sistema de arquivos. O terminal. JSON. Git. Revisão de código. Tudo foi moldado pelo que um humano com um teclado consegue lidar.

E se você jogasse tudo isso fora e recomeçasse para máquinas?

Isso é engenharia robots-first. E é a direção para onde o desenvolvimento autônomo de software já está indo.

Desenvolvimento Não É Mais Engenharia

Aqui está a divisão que reformula todo o trabalho:

Desenvolvimento de software agora é trabalho de máquina. Escrever código. Rodar testes. Commitar. Agentes já cuidam disso. Chame de aproximadamente $10 por hora, sem dormir, sem pausas.

Engenharia de software é a camada humana que mantém essa máquina confiável. Rails. Domínios de falha. Loops de verificação. Back-pressure. Todo o encanamento dentro do qual o agente roda.

Seu trabalho mudou debaixo dos seus pés. Você não está mais carregando carga para o navio. O contêiner de carga apareceu. Agora você dirige a locomotiva e a mantém nos trilhos.

Essa virada mental é o que separa engenheiros que prosperam no novo mundo dos que afundam nele.

Chave de Fenda Antes da Britadeira

Engenharia autônoma tem estágios. Pule-os e você falha.

A Chave de Fenda: Trabalho manual. Você escreve specs à mão. Você gerencia o contexto com cuidado. Você guia busca e vinculação você mesmo. O objetivo é aprender como o sistema fica nos trilhos antes de entregar as chaves.

A Britadeira: Velocidade total. Loops Ralph rodando sem supervisão. Frotas orquestradas. Agentes paralelos. Builds noturnos que entregam features de manhã.

A maioria dos engenheiros comete o mesmo erro. Pega a britadeira antes de tocar na chave de fenda.

Pule direto para automação total sem os fundamentos e a saída é lixo. A chave de fenda é o que ensina o que a britadeira precisa.

Vá manual primeiro. Descubra por que as coisas se sustentam. Depois alcance as ferramentas elétricas.

Loom: Uma Stack Construída para Agentes

Loom aponta para o próximo passo: um ambiente de software que se reconstrói em torno de agentes ao invés de humanos.

A regra de design é rígida. Para cada peça da stack, faça três perguntas:

1. Isso foi projetado para humanos?
2. Se sim, pode sair?
3. Se sair, o que perdemos e como substituímos?

Algumas suposições que falham no teste:

• Unix user space e convenções TTY: Agentes não ficam em terminais. Alguma dessas coisas ainda se aplica?
• Ritual e processo ágil: Sprints existem porque humanos planejam em semanas. Agentes não planejam assim.
• JSON como formato de dados: Cada aspas e colchete queima tokens. JSON é o formato certo para transmissão?
• Workflows de revisão de código: Um loop de verificação consegue substituir uma fila de revisão?

As peças do Loom incluem:

• Hospedagem de código, estilo GitHub, mas moldada para agentes
• Controle de versão via JJ, que funciona melhor com workflows de máquina
• Sandboxes remotos estilo Codespace
• "Alloying" multi-LLM, rodando múltiplos provedores juntos
• Padrões de mensagens actor e pub-sub
• Encadeamento no estilo Erlang/OTP

A ideia central: loops compostos em cadeias. Loops sobre loops sobre loops. Cada um focado e preciso. O todo se comporta como um sistema reativo único.

Janelas de Contexto São Apenas Arrays

Um princípio central para pensar robots-first:

Uma janela de contexto é um array. Quanto menos você preenche esse array, menos ele precisa deslizar, e melhor fica a saída.

Empilhe mais contexto e você tem:

• Mais deslizamento
• Compactação mais cedo
• Compactação que perde dados
• Âncoras faltando
• Drift

É por isso que loops Ralph funcionam. O loop foi projetado para rodar o array deterministicamente. Mantém o array enxuto. Esquiva compactação. Segura o pino.

O pino é sua spec. O ponto de referência estável para onde o agente continua apontando. Toda iteração lê de novo. Sem o pino, agentes começam a inventar coisas.

Specs como Tabelas de Consulta

Specs robots-first não são docs. São tabelas de consulta afinadas para busca de agente.

Uma boa spec parece com isso:

## User Authentication
 
**Also known as**: login, sign-in, auth, session management, identity
 
**Related files**: src/auth/, src/middleware/session.ts
 
**Key patterns**: JWT tokens, refresh rotation, secure cookies
 
**What NOT to do**: Don't implement custom crypto, don't store passwords in plain text

O campo "também conhecido como" aumenta as taxas de acerto na busca. Quando o agente faz grep de "login", ele cai na spec de auth. Mais sinônimos, mais acertos. Mais acertos, menos invenção.

A spec vira o frame de referência para toda a feature. Agentes consultam o que existe ao invés de adivinhar o que pode existir.

Vinculação Bate Formatos Sofisticados

Muitos engenheiros constroem seus planos com excesso. Schemas JSON aninhados. Hierarquias de tarefas. Formatação elaborada.

A visão robots-first: vinculação precisa ganha de formatos sofisticados.

O que realmente funciona:

• Bullet points com referências concretas
• Cite a seção exata da spec
• Aponte para o arquivo exato
• Referencie hunks específicos (Claude lê arquivos em hunks)

## Implementation Plan
 
- [ ] Add JWT validation middleware
 
  - Spec: auth-spec.md#token-validation
  - File: src/middleware/auth.ts (lines 45-60)
  - Pattern: Follow existing rate-limit middleware structure
 
- [ ] Create refresh token endpoint
  - Spec: auth-spec.md#refresh-flow
  - File: src/routes/auth/refresh.ts (new file)
  - Pattern: Match existing /auth/login endpoint structure

Agora o agente busca com precisão. Encontra os hunks certos. Copia o padrão já existente no repositório. Para de inventar.

A Stack Robots-First

Aqui a ideia fica radical. Possua a stack inteira e você pode afiná-la para máquinas:

Serialização: JSON não é eficiente em tokens. Cada aspas, cada chave, cada vírgula custa tokens. Um formato binário, ou um formato de texto construído para agentes, pode cortar esse custo de forma expressiva.

User Space: Por que um agente deve herdar o Unix user space? TTY foi construído para humanos em terminais. Agentes não precisam de emulação de terminal.

Garbage Collection: O que gerenciamento de memória significa quando seu "processo" é uma chamada de API stateless? As suposições habituais param de valer.

Message Passing: Erlang e OTP voltam. Actors. Árvores de supervisor. Let-it-crash. Os padrões mapeiam bem para orquestrar agentes.

Se você possui a stack, você pode:

• Afinar a tokenização
• Cortar custos drasticamente
• Construir pipes reativos mais rápidos
• Rodar mais barato do que o próximo time

Isso é vantagem competitiva.

Weavers: Agentes Sem Humano no Loop

O destino da engenharia robots-first tem um nome: Weavers.

Um Weaver é um agente autônomo que:

• Entrega código por trás de feature flags
• Deploya sem revisão de código
• Monitora analytics de produto
• Decide se uma mudança corrigiu os erros
• Decide se deve avançar mais
• Itera por conta própria

Ninguém está supervisionando. Autonomia total.

Assustador? Sim. Essa é a reação certa de primeira. Agora fique com isso por um segundo.

Cada objeção que você listar é um problema de engenharia esperando para ser construído. E se quebrar a produção? Construa um rollback. E se tomar uma decisão ruim? Construa um loop de verificação. E se sair dos trilhos? Construa back-pressure.

O novo trabalho da engenharia de software: engenharie as preocupações para longe.

Escreva suas objeções. Depois construa os sistemas que as neutralizam. Esse é o trabalho agora.

Engenharia de Back-Pressure

Loops autônomos geram modos de falha. Seu trabalho vira colocar os trilhos:

• Adicione restrições dentro da spec
• Aperte a vinculação do plano
• Melhore a orientação de busca
• Eleve os gates (testes, linting, formatação, scans de segurança)

Quando as saídas ficam ruins, a correção é outro loop:

• Loop de refatoração
• Loop de convenção
• Loop de segurança
• Loop de i18n

O back-pressure mantém o gerador nos trilhos. A locomotiva fica na linha porque você construiu a linha.

A Escada de Escalada

A engenharia robots-first escala por composição. Quatro degraus.

Nível 1: Fundamentos Manuais

• Gere specs por conversa
• Aperte restrições à mão
• Mantenha o contexto o menor possível
• Fique no teclado

Nível 2: Loop Sem Supervisão

• Runs while true
• Um objetivo por iteração
• Testes automatizados mais commit e push
• Estado com checkpoint

Nível 3: Orquestração Multi-Loop

• Vários loops rodando ao mesmo tempo
• Cadeias reativas conectadas entre eles
• Padrões actor e pub-sub

Nível 4: Sistemas de Produto Autônomos

• Weavers entregando features
• Analytics guiando decisões
• Sem fila de revisão
• Autonomia de produto ponta a ponta

Cada degrau repousa sobre o anterior. Pular para o Nível 4 sem os Níveis 1 a 3 não funciona.

A Mudança de Mentalidade

A engenharia robots-first precisa de uma cabeça diferente:

Mentalidade antiga: "Como escrevo esse código?" Nova mentalidade: "Como projeto um sistema que escreve esse código de forma confiável?"

Mentalidade antiga: "Como reviso esse PR?" Nova mentalidade: "Como construo verificação que torna a revisão inútil?"

Mentalidade antiga: "Como debugo esse problema?" Nova mentalidade: "Como construo feedback loops que impedem essa classe de bug?"

Você não está escrevendo código mais. Está projetando sistemas autônomos. Você é um engenheiro de locomotiva, não um estivador.

Começando Hoje

Você não precisa do Loom para começar a pensar robots-first. Comece com perguntas:

1. Que suposições humanas estou incluindo? Audite seus workflows. Quais passos existem apenas porque um humano era quem os fazia?

2. O que poderia virar uma tabela de consulta? Suas specs. Seus padrões. Suas convenções. Você consegue moldá-los para um agente conseguir buscá-los?

3. Onde a vinculação está fraca? A maioria dos planos aponta para as coisas de forma vaga. Você consegue hardcodificar caminhos de arquivo, intervalos de linha e hunks?

4. Onde está o back-pressure? Quando o agente vai na direção errada, o que o pega? Construa esses freios antes de precisar deles.

5. O que autonomia total precisaria? Finja que você saiu do loop. O que cai? Essas falhas são suas próximas prioridades de engenharia.

Para Onde Isso Vai

É 2026. Se prepare.

O gap entre times que conseguem rodar loops autônomos confiáveis e os que não conseguem está crescendo rápido. A economia é clara. Desenvolvimento automatizado custa aproximadamente $10 por hora. Desenvolvedores humanos são $100 ou mais.

Times que constroem robots-first entregam a uma taxa completamente diferente. Rodam mais barato. Iteram mais rápido. Suas melhorias se compõem enquanto dormem.

Engenheiros presos em workflows human-first vão ficar para trás. Não porque suas habilidades são ruins. Porque seu alvo de otimização está errado.

A engenharia de software acabou de mudar. Já mudou antes. Vai mudar de novo.

Os engenheiros que se saem bem são os que veem cada mudança como mais uma chance de projetar a partir dos primeiros princípios. Isso sempre foi verdade. Só está mais difícil de ignorar agora.

Comece com a chave de fenda. Acerte os fundamentos. Depois pegue a britadeira.

A locomotiva está esperando.

Leitura Relacionada

• Técnica Ralph Wiggum: A fundação para loops autônomos
• Engenharia Baseada em Threads: Um framework para escalar trabalho de agentes
• Loops de Agente Autônomo: Ralph mais threads juntos
• Feedback Loops: Padrões de verificação que mantêm os loops honestos
• Context Engineering: Gerenciando o array