Simon Willison deixa a IA construir o próprio agente de código

Simon Willison é uma das vozes mais ouvidas quando o assunto é usar modelos de linguagem no dia a dia de quem programa. Criador do Django e da biblioteca LLM, ele documenta em público, há anos, cada experimento com IA aplicada a código. Em 2 de julho de 2026 ele publicou um post curto, quase um recibo de commit, que carrega uma tese grande sobre como o trabalho de programar está mudando. Vale ler com atenção ao método, não ao brinquedo.

O que ele fez

Willison lançou o llm-coding-agent 0.1a0, um agente de código construído sobre a própria biblioteca LLM dele. Nas palavras do autor: "Now that my LLM library has evolved into more of an agent framework it's time to see what a simple coding agent would look like built on it." Ou seja, a biblioteca virou um framework de agentes, e ele quis ver como seria um agente de código simples em cima dela.

O detalhe que interessa não é o resultado, é como ele chegou lá. Willison não sentou e escreveu o agente linha por linha. Ele partiu de um template de projeto Python e deu à IA dois comandos, na ordem. O primeiro: escrever uma spec.md do projeto, que dependeria da última versão alpha da biblioteca LLM e implementaria um agente de código no estilo Claude Code, com ferramentas para ler, editar arquivos e rodar comandos. O segundo, e é aqui que mora a lição: "Commit the spec, then build it using red/green TDD in a series of sensible commits (each with passing tests and updated docs)." Comite a spec, depois construa por TDD red/green, numa série de commits sensatos, cada um com testes passando e docs atualizadas.

Repare na sequência. Primeiro a especificação. Depois o código, guiado por testes, em passos pequenos e verificáveis. A IA fez o trabalho braçal. A inteligência do processo estava no roteiro que ele deu.

"Slop-alpha": a honestidade que falta no hype

O que torna Willison uma voz confiável é a ausência de deslumbramento. Ele mesmo classifica o que publicou como "slop-alpha", uma versão alfa reconhecidamente rascunhada, gerada por IA. E ainda assim registra, sem pudor: "It's pretty good for a first attempt", está muito bom para uma primeira tentativa. As duas frases juntas dizem a coisa mais útil sobre codar com IA hoje. O resultado é bom o bastante para ser real, e cru o bastante para não ser confiado às cegas. Chamar de slop é a maneira dele de manter os pés no chão enquanto usa a ferramenta a sério.

A IA escreveu o código. A disciplina de escrever a spec antes e o teste antes continua sendo trabalho humano, e é ela que separa software de rascunho gerado.

Essa honestidade conversa direto com o teste franco que a Birgitta Böckeler fez ao rodar modelos locais para codar: ambos usam a IA de verdade e ambos recusam a fábula de que ela dispensa julgamento. É o mesmo espírito de quem opera IA em produção e sabe que a mágica só vira produto quando alguém verifica.

A disciplina migrou de lugar

Aqui está o ponto que vale levar para a sua operação. Durante décadas, a habilidade central de programar foi escrever o código. Willison está mostrando, na prática, que a habilidade central está migrando para duas outras coisas: especificar bem o que se quer, e verificar bem o que voltou.

A especificação vem primeiro no roteiro dele por um motivo. Uma spec clara é o que transforma um pedido vago num contrato que a IA pode cumprir e que o humano pode conferir. Sem ela, você gera código bonito que resolve o problema errado. A spec é a hipótese escrita, no mesmo espírito da Lean UX aplicada à IA: decida o que é sucesso antes de produzir, não depois.

A verificação vem embutida no método. TDD red/green significa escrever o teste que falha, depois o código que faz o teste passar, e só então seguir. Cada commit pequeno é um ponto de verificação onde o humano confere antes de acumular risco. É exatamente a tese de que o gargalo da IA moderna não é gerar, é confiar no que foi gerado, que aparece quando Karpathy fala em saber o que você consegue verificar. Willison não pediu à IA para cuspir o agente inteiro num bloco. Pediu para construí-lo em passos que ele conseguisse validar um a um. A arquitetura do processo já é a arquitetura da verificação.

Como levar isso para o seu time

O post de Willison é um manual disfarçado de nota de release, e três práticas dele se transplantam para qualquer time que usa IA para produzir código ou conteúdo.

A primeira é exigir a spec antes da geração. Antes de mandar a IA construir, faça a IA, ou a pessoa, escrever o que vai ser construído, com critério de pronto. Isso corta metade do retrabalho, porque erro de entendimento aparece no texto barato, não no código caro.

A segunda é comitar em passos pequenos com verificação embutida. Um teste que passa por etapa vale mais que um code review heroico no final. Passo pequeno é passo que o humano ainda consegue revisar de verdade, e revisar de verdade é o que impede o acúmulo silencioso de defeito.

A terceira é nomear a imaturidade sem medo. Willison chama o próprio trabalho de slop-alpha e mesmo assim publica, porque deixa claro o nível de confiança. Um time que sabe dizer "isto é um rascunho gerado, ainda não confie" toma decisão melhor do que um time que finge que todo output de IA nasce pronto.

A tese de Willison, resumida, é reconfortante para quem temia que a IA aposentasse o rigor. Ela não aposentou. Só mudou o rigor de lugar. Saiu de digitar o código e foi para especificar com clareza e verificar com método. Quem dominar essas duas pontas vai tirar da IA um trabalho que se sustenta. Quem confiar no meio, sem spec na frente e sem teste atrás, vai colecionar slop sem o alpha.

Se o seu time usa IA para gerar código ou conteúdo e você quer montar o arreio de spec e verificação em volta disso, chame a gente no WhatsApp que a gente ajuda a desenhar o processo.