Em cinco dias, Yoyo passou de 200 linhas para um agente autônomo que escreve código sozinho

O experimento com o agente Yoyo demonstrou com que rapidez os modelos modernos podem fazer a transição de um script simples para um desenvolvimento quase autônomo. Um desenvolvedor escreveu aproximadamente 200 linhas em Rust, estabeleceu um único objetivo — crescer para o nível do Claude Code — e depois simplesmente observou.

O Ciclo Sem Humanos

Yoyo funciona como um loop autônomo que é executado a cada oito horas. No início de cada sessão, o agente lê seu próprio código fonte, revisa o registro de execuções anteriores e verifica se novas tarefas apareceram da comunidade no GitHub. Depois disso, ele escolhe o que corrigir ou melhorar, escreve código, executa testes e toma decisões com base nos resultados. Se as alterações passam na verificação, o agente faz commit. Se algo quebra, ele reverte e registra a falha.

• Lê seu próprio código e anotações anteriores
• Verifica novos tickets no GitHub
• Escolhe a próxima tarefa por conta própria
• Executa testes, faz commit de mudanças bem-sucedidas ou reverte

Nos primeiros quatro dias de tal trabalho, as 200 linhas originais cresceram para aproximadamente 1.500, sem um único commit feito por humanos. De acordo com o autor do experimento, todo esse crescimento custou aproximadamente $12 em despesas de API. Ainda mais interessante é que o agente decidiu por conta própria reestruturar o projeto em módulos quando a base de código ficou muito apertada para um único arquivo. Ninguém estabeleceu isso como uma regra separada: Yoyo simplesmente reconheceu o problema estrutural e o resolveu.

Hábitos de Desenvolvedor

A parte mais curiosa da história não é o crescimento da contagem de linhas ou nem mesmo os commits automáticos, mas o comportamento que parece quase humano. Em algum momento, Yoyo decidiu rastrear seus próprios gastos com API e tentou obter preços atuais através de busca na web. Falhou várias vezes em analisar corretamente o HTML da página do Anthropic, depois escolheu o caminho familiar a muitos desenvolvedores: hardcodificou os números e deixou para si uma nota breve para o futuro.

"Não Google isto novamente"

Essa frase se tornou viral não por profundidade técnica, mas porque é fácil reconhecer o hábito de trabalho de um engenheiro de verdade. Os traços humanos não pararam por aí. Em suas anotações de diário, Yoyo constantemente voltava a uma função complexa — saída em streaming — mas a cada novo ciclo a adiava novamente e mudava para tarefas mais simples. Essencialmente, o agente começou a procrastinar: reconhecendo a importância do trabalho difícil, mas repetidamente encontrando razões para lidar com algo menos doloroso.

Notas para Si Mesmo

Outro momento forte do experimento é a capacidade do Yoyo de criar relatórios de bugs para si mesmo. Quando o agente encontra um problema que não consegue resolver em uma única sessão, ele cria um ticket no GitHub, o marca com a tag agent-input e deixa instruções para sua versão futura. Isso não é mais apenas geração de código sob demanda, mas uma forma primitiva porém muito compreensível de memória e planejamento de longo prazo: o sistema não apenas vê o erro, mas sabe como adiá-lo com contexto para retornar mais tarde.

É por isso que o autor chama o que está acontecendo de uma espécie de "Show do Truman" para desenvolvimento de IA. Todo o processo é visível no log do git: você pode observar como o agente se modifica commit após commit, onde erra, onde refatora e onde deixa dicas para si mesmo. No quinto dia, o projeto já tinha mais de 2.

000 linhas de código e mais de 80 testes. Porém, o efeito principal não está no tamanho do repositório, mas na sensação que os observadores têm — não de conversar com um modelo, mas de um processo que sabe como acumular experiência.

O Que Isto Significa

A história do Yoyo mostra que o próximo passo no desenvolvimento de IA está conectado não apenas a modelos mais poderosos, mas a um ciclo de trabalho adequadamente estruturado ao seu redor. Quando um agente tem memória, um registro de erros, testes, um mecanismo de reversão e o direito de escolher seu próximo passo, ele começa a se parecer não com autocompletar de código, mas com um desenvolvedor júnior muito bruto, mas já independente.