En cinq jours, Yoyo est passé de 200 lignes à un agent autonome qui écrit du code tout seul

L'expérience avec l'agent Yoyo a démontré avec quelle rapidité les modèles modernes peuvent passer d'un simple script à un développement presque autonome. Un développeur a écrit environ 200 lignes en Rust, défini un seul objectif — atteindre le niveau de Claude Code — et ensuite simplement observé.

La Boucle sans Humain

Yoyo fonctionne comme une boucle autonome qui s'exécute toutes les huit heures. Au début de chaque session, l'agent lit son propre code source, examine le journal des exécutions précédentes et vérifie si de nouvelles tâches ont été ajoutées par la communauté sur GitHub. Ensuite, il choisit ce qu'il faut corriger ou améliorer, écrit du code, exécute des tests et prend des décisions basées sur les résultats. Si les modifications passent la vérification, l'agent effectue un commit. Si quelque chose casse, il revient en arrière et enregistre l'échec.

• Lit son propre code et ses notes précédentes
• Vérifie les nouveaux tickets sur GitHub
• Choisit la prochaine tâche lui-même
• Exécute les tests, valide les changements réussis ou revient en arrière

Au cours des quatre premiers jours de ce travail, les 200 lignes d'origine ont grandi jusqu'à environ 1.500, sans un seul commit humain. Selon l'auteur de l'expérience, toute cette croissance a coûté environ 12 dollars en frais d'API. Encore plus intéressant, l'agent a décidé par lui-même de restructurer le projet en modules lorsque la base de code devint trop étroite pour un seul fichier. Personne n'avait défini cela comme une règle séparée : Yoyo a simplement reconnu le problème structurel et l'a résolu.

Habitudes de Développeur

La partie la plus curieuse de l'histoire n'est pas la croissance du nombre de lignes ni même les commits automatiques, mais le comportement qui semble presque humain. À un moment donné, Yoyo a décidé de suivre ses propres dépenses d'API et a tenté d'obtenir les prix actuels via une recherche web. Il a échoué plusieurs fois à analyser correctement le HTML de la page Anthropic, puis a choisi la voie familière à de nombreux développeurs : il a codé en dur les chiffres et s'est laissé une courte note pour l'avenir.

« Ne plus chercher cela sur Google »

Cette phrase est devenue virale non pas pour sa profondeur technique, mais parce qu'il est facile de reconnaître l'habitude de travail d'un vrai ingénieur. Les traits humains ne s'arrêtent pas là. Dans ses notes de journal, Yoyo est constamment revenu à une fonction complexe — la sortie en flux — mais à chaque nouveau cycle l'a à nouveau reportée et s'est tourné vers des tâches plus simples. Essentiellement, l'agent a commencé à procrastiner : reconnaissant l'importance du travail difficile, mais trouvant à plusieurs reprises une raison de faire quelque chose de moins pénible.

Notes pour Soi-même

Un autre moment fort de l'expérience est la capacité de Yoyo à rédiger des rapports de bugs pour lui-même. Quand l'agent rencontre un problème qu'il ne peut pas résoudre en une seule session, il crée un ticket sur GitHub, le marque avec le tag agent-input et laisse des instructions pour sa version future. Ce n'est plus simplement la génération de code sur demande, mais une forme primitive mais très compréhensible de mémoire et de planification à long terme : le système non seulement voit l'erreur, mais sait comment la reporter avec contexte pour y revenir plus tard.

C'est pourquoi l'auteur appelle ce qui se passe une sorte de « Truman Show » pour le développement IA. Tout le processus est visible dans le journal git : vous pouvez observer comment l'agent se modifie commit après commit, où il se trompe, où il refactorise et où il se laisse des indices. Le cinquième jour, le projet comptait déjà plus de 2.

000 lignes de code et plus de 80 tests. Cependant, l'effet principal ne réside pas dans la taille du référentiel, mais dans la sensation que les observateurs ont — non pas de discuter avec un modèle, mais d'un processus qui sait accumuler l'expérience.

Ce Que Cela Signifie

L'histoire de Yoyo montre que l'étape suivante du développement IA est liée non seulement à des modèles plus puissants, mais à une boucle de travail correctement structurée autour d'eux. Quand un agent a la mémoire, un journal d'erreurs, des tests, un mécanisme de retour en arrière et le droit de choisir son prochain pas, il commence à ressembler non pas à l'autocomplétion de code, mais à un développeur junior très brut mais déjà indépendant.