Yoyo est passé de 200 lignes à un agent autonome qui écrit son propre code en cinq jours

Une expérience avec l'agent yoyo montre à quelle vitesse les modèles actuels peuvent passer d'un simple script à un développement quasi autonome. Le développeur a écrit environ 200 lignes de Rust, fixé un seul objectif — atteindre le niveau de Claude Code — puis s'est contenté d'observer.

Une boucle sans humain

Yoyo fonctionne comme une boucle autonome qui se lance toutes les huit heures. Au début de chaque session, l'agent lit son propre code source, parcourt le journal des exécutions précédentes et vérifie si la communauté a ouvert de nouvelles tâches sur GitHub. Il choisit ensuite lui-même ce qu'il corrige ou améliore, écrit le code, lance les tests et décide en fonction du résultat.

Si les modifications passent la vérification, l'agent fait un commit. Si quelque chose casse, il revient en arrière et consigne l'échec dans son journal.

• Lit son code et ses notes passées
• Vérifie les nouveaux tickets sur GitHub
• Choisit lui-même la tâche suivante
• Lance les tests, puis valide les changements réussis ou annule

Sur les quatre premiers jours, les 200 lignes initiales sont passées à environ 1 500, sans un seul commit humain. Selon l'auteur de l'expérience, toute cette croissance a coûté environ 12 dollars de frais d'API.

Plus intéressant encore : l'agent a décidé seul de réorganiser le projet en modules lorsque la base de code est devenue trop à l'étroit dans un seul fichier. Personne n'en avait fait une règle distincte : yoyo a simplement repéré un problème de structure et l'a réglé.

Des habitudes de développeur

La partie la plus curieuse de l'histoire n'est ni la hausse du nombre de lignes ni même les commits automatiques, mais un comportement qui paraît presque humain. À un moment, yoyo a décidé de suivre ses propres dépenses d'API et a tenté d'obtenir les tarifs à jour via une recherche web. Il n'a pas réussi, à plusieurs reprises, à analyser correctement le HTML d'une page d'Anthropic, puis a choisi une voie familière à bien des développeurs : coder les chiffres en dur et se laisser une courte note pour plus tard.

« Ne plus googler ça »

Cette phrase est devenue virale non pas pour sa profondeur technique, mais parce qu'on y reconnaît sans peine l'habitude de travail d'un vrai ingénieur.

Les traits humains ne s'arrêtent pas là. Dans les entrées de son journal, yoyo revenait sans cesse à une fonction complexe — l'affichage en streaming —, mais à chaque nouveau cycle, il la repoussait et passait à des tâches plus simples. En pratique, l'agent s'est mis à procrastiner : il admettait l'importance du travail lourd, mais trouvait toujours une raison de s'occuper de quelque chose de moins pénible.

Des notes à soi-même

Un autre moment fort de l'expérience est la capacité de yoyo à rédiger des rapports de bug pour lui-même. Quand l'agent se heurte à un problème qu'il ne peut pas résoudre en une session, il crée un ticket GitHub, l'étiquette agent-input et laisse des instructions à sa future version.

Il ne s'agit plus seulement de générer du code à la demande, mais d'une forme primitive, quoique très lisible, de mémoire et de planification à long terme : le système ne se contente pas de voir l'erreur, il sait aussi la mettre de côté avec son contexte pour y revenir plus tard.

C'est pourquoi l'auteur parle d'une sorte de « Truman Show » du développement par IA. Tout le processus est visible dans le journal git : on peut voir l'agent se modifier commit après commit, là où il se trompe, là où il refactorise et là 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. Pourtant, l'effet principal n'est pas la taille du dépôt, mais le fait que les observateurs ont l'impression de voir non pas un chat avec un modèle, mais un processus capable d'accumuler de l'expérience.

Ce que cela signifie

L'histoire de yoyo suggère que la prochaine étape du développement par IA dépend non seulement de modèles plus puissants, mais aussi d'une boucle de travail bien construite autour d'eux. Quand un agent dispose d'une mémoire, d'un journal d'erreurs, de tests, d'un mécanisme de retour arrière et du droit de choisir sa prochaine étape, il commence à ressembler non pas à une autocomplétion de code, mais à un développeur junior encore très brut, mais déjà autonome.