Yoyo cresceu de 200 linhas a um agente autônomo que escreve o próprio código em cinco dias

Um experimento com o agente yoyo mostra a rapidez com que os modelos atuais podem passar de um simples script a um desenvolvimento quase autônomo. O desenvolvedor escreveu cerca de 200 linhas de Rust, definiu um único objetivo — chegar ao nível do Claude Code — e depois apenas observou.

Um ciclo sem humanos

O yoyo funciona como um ciclo autônomo que roda a cada oito horas. No início de cada sessão, o agente lê o próprio código-fonte, consulta o diário das execuções anteriores e verifica se a comunidade abriu novas tarefas no GitHub. Em seguida, escolhe sozinho o que corrigir ou melhorar, escreve o código, roda os testes e decide com base no resultado.

Se as mudanças passam na verificação, o agente faz um commit. Se algo quebra, ele reverte e registra a falha no log.

• Lê o próprio código e os registros anteriores
• Verifica novos tickets no GitHub
• Escolhe sozinho a próxima tarefa
• Roda os testes e faz commit das mudanças bem-sucedidas ou reverte

Nos primeiros quatro dias de trabalho, as 200 linhas originais cresceram para cerca de 1.500, sem um único commit humano. Segundo o autor do experimento, todo esse crescimento custou cerca de 12 dólares em gastos de API.

Mais interessante ainda: o agente decidiu por conta própria reorganizar o projeto em módulos quando a base de código ficou apertada demais para um único arquivo. Ninguém definiu isso como uma regra à parte: o yoyo simplesmente reconheceu um problema de estrutura e o resolveu.

Hábitos de desenvolvedor

O mais curioso da história não é o aumento de linhas nem os commits automáticos, mas um comportamento que parece quase humano. Em certo momento, o yoyo decidiu acompanhar os próprios gastos com API e tentou obter os preços atuais por meio de busca na web. Ele falhou várias vezes ao tentar interpretar corretamente o HTML de uma página da Anthropic e então seguiu um caminho familiar a muitos desenvolvedores: fixou os números no código e deixou uma nota curta para o futuro.

"Não pesquisar isso de novo"

A frase viralizou não por ter profundidade técnica, mas porque é fácil reconhecer nela o hábito de trabalho de um engenheiro de verdade.

Os traços humanos não pararam por aí. Nas anotações do diário, o yoyo voltava sempre a uma função complexa — a saída em streaming —, mas a cada novo ciclo a adiava de novo e passava a tarefas mais simples. Na prática, o agente passou a procrastinar: reconhecia a importância do trabalho pesado, mas sempre achava um motivo para fazer algo menos penoso.

Recados para si mesmo

Outro ponto forte do experimento é a capacidade do yoyo de redigir relatórios de bug para si mesmo. Quando o agente esbarra em um problema que não consegue resolver em uma sessão, ele cria um ticket no GitHub, marca com a tag agent-input e deixa instruções para a sua versão futura.

Isso já não é só geração de código sob demanda, mas uma forma primitiva, porém muito clara, de memória e planejamento de longo prazo: o sistema não só vê o erro, como também sabe adiá-lo com contexto para voltar depois.

Por isso o autor chama o que acontece de uma espécie de "Show de Truman" do desenvolvimento com IA. Todo o processo aparece no log do git: dá para ver o agente mudando a si mesmo commit a commit, onde erra, onde refatora e onde deixa dicas para si.

No quinto dia, o projeto já tinha mais de 2.000 linhas de código e mais de 80 testes. Ainda assim, o efeito principal não é o tamanho do repositório, mas a sensação de quem observa: não de um chat com um modelo, e sim de um processo capaz de acumular experiência.

O que isso significa

A história do yoyo indica que o próximo passo no desenvolvimento com IA depende não só de modelos mais fortes, mas também de um ciclo de trabalho bem montado ao redor deles. Quando um agente tem memória, registro de erros, testes, mecanismo de reversão e o direito de escolher o próximo passo, ele passa a lembrar não um autocompletar de código, mas um desenvolvedor júnior ainda muito cru, porém já independente.