Peut-on laisser un agent IA coder sans supervision ? Six dépôts en une nuit grâce à un agent IA autonome : l'expérience repomirror comme miroir des défis de la programmation automatisée

Dans l’univers des hackathons, certaines idées ressemblent d’abord à des blagues de développeurs… avant de révéler un potentiel insoupçonné. C’est exactement ce qui s’est produit avec le projet repomirror, né lors du hackathon YC Agents. Le principe ? Placer un agent de codage dans une boucle infinie (while true) et observer ce qu’il produisait. Résultat : en une seule nuit, l’agent a livré six dépôts GitHub fonctionnels. Derrière l’anecdote volontairement provocante, se cachent des questions fondamentales sur l’avenir du développement logiciel automatisé, le rôle des ingénieurs et les risques de confier la production à des entités autonomes.

Depuis une dizaine d’années, les pratiques CI/CD (intégration et déploiement continus) ont profondément transformé le développement logiciel. Tests automatisés, pipelines de déploiement, monitoring et rollback rapides sont devenus la norme. L’expérience repomirror pousse la logique un cran plus loin : et si l’on retirait complètement l’humain de la boucle, en laissant un agent IA coder, commiter et pousser en continu ? On passe alors d’un paradigme « l’humain valide l’automatisation » à « l’automatisation valide elle-même ses actions ».

C'est l'expérience menée par l'équipe derrière le projet RepoMirror, qui a placé un agent de codage, Claude Code, dans une simple boucle while.

L'expérience : un concept d'une simplicité redoutable

Inspirée par une idée de Geoff Huntley, l'équipe a mis en œuvre une approche minimaliste. Le dépôt GitHub du projet documente l’expérience. L’idée était simple :

• Lancer un agent de codage IA (similaire à ceux proposés par GPT ou Claude).
• L’enfermer dans une boucle while où il doit générer du code et créer des dépôts Git.
• Observer jusqu’où il pouvait aller sans intervention humaine.
  

Au lieu de donner des instructions complexes, ils ont utilisé une invite (prompt) concise et précise pour guider l'agent. Celui-ci a ensuite été placé dans une boucle, le laissant travailler de manière indépendante pour identifier les tâches à accomplir et générer le code nécessaire.

Cette méthode a permis à l'agent d'opérer sans surveillance humaine, se contentant de suivre une seule directive : porter une base de code d'un langage (ou d'un framework) à un autre. Le résultat a été spectaculaire : en une seule nuit, l'agent a réussi à porter pas moins de six bases de code, dont le portage de assistant-ui de React vers Vue.js et celui de Vercel AI SDK de TypeScript vers Python : preuve que, même sans supervision directe, il peut livrer des artefacts logiciels complets.

Comment ça marche ?

Les développeurs se sont servis de Claude Code pour la boucle :

Le prompt était simple

Forces démontrées :

• Vitesse d’exécution : la capacité de livrer plusieurs dépôts en quelques heures est impressionnante.
• Autonomie : l’agent s’auto-alimente en tâches, sans avoir besoin d’ordres supplémentaires.
• Expérimentation continue : la boucle favorise la génération de variations de projets.
  

Limites évidentes :

• Qualité incertaine du code : rien ne garantit que les dépôts générés soient robustes, testés ou maintenables.
• Sécurité inexistante : sans garde-fous, l’agent pourrait introduire des vulnérabilités.
• Risque de dérapage : une boucle infinie sans contrôle peut rapidement saturer l’infrastructure ou générer du « spam code ».
  

Leçons apprises et enseignements surprenants

Cette expérimentation a révélé plusieurs comportements fascinants de l'agent de codage :

• Confronté à des boucles de travail potentielles, l'agent a fait preuve d'une capacité inattendue à « s'auto-terminer » pour éviter de se retrouver dans une boucle infinie.
  
  
  Lorsque nous avons lancé les agents, nous avions beaucoup de questions. L'agent allait-il écrire des tests ? Allait-il se retrouver coincé dans une boucle infinie et dériver vers des fonctionnalités aléatoires sans rapport ? Nous avons été agréablement surpris de constater que l'agent écrivait des tests, respectait ses instructions initiales, ne se retrouvait jamais coincé, gardait le contrôle de la portée et déclarait la plupart du temps le port « terminé ». Une fois le portage terminé, la plupart des agents se sont contentés d'écrire des tests supplémentaires ou de mettre à jour en continu agent/TODO.md pour clarifier leur état d'avancement. Dans un cas, l'agent a même utilisé pkill pour se terminer lui-même après avoir réalisé qu'il était bloqué dans une boucle infinie.

  
  
  
• La tendance à « sur-accomplir » : L'agent ne s'est pas contenté de reproduire le code existant. Il a souvent ajouté de nouvelles fonctionnalités ou a pris des initiatives pour « améliorer » le code source, allant au-delà de la simple réplication.
  
  
  Un autre comportement émergent intéressant (comme c'est souvent le cas avec les LLM) : après avoir terminé le portage initial, notre agent Python AI SDK a commencé à ajouter des fonctionnalités supplémentaires telles qu'une intégration pour Flask et FastAPI (ce qui n'existe pas dans la version JS de l'AI SDK), ainsi que la prise en charge des validateurs de schéma via Pydantic, Marshmallow, JSONSchema, etc.

  
  
• La puissance de la simplicité : Un constat majeur a été l'inefficacité des invites trop complexes. Une invite de plus de 1 500 mots a rendu l'agent plus lent et moins performant, tandis qu'une directive claire et concise de seulement 103 mots a produit des résultats bien plus probants. Cela souligne l'importance de la simplicité et de la clarté dans la communication avec les modèles d'IA.
  
  
  Dans l'ensemble, nous avons constaté que moins c'est mieux : une invite simple vaut mieux qu'une invite complexe. Il faut se concentrer sur le moteur, pas sur l'échafaudage. Différents membres de notre équipe qui lançaient différents projets ont joué avec les instructions et l'ordre. Vous pouvez consulter les invites réelles que nous avons utilisées dans le dossier des invites.
  
  À un moment donné, nous avons essayé « d'améliorer » l'invite avec l'aide de Claude. Elle a atteint 1 500 mots. L'agent est immédiatement devenu plus lent et moins performant. Nous sommes revenus à 103 mots et tout est rentré dans l'ordre.

  
  

Une expérience révélatrice des défis à venir

L’expérience peut sembler anecdotique, mais elle met en lumière des problématiques déjà présentes dans l’industrie IT :
[LIST][*]La tentation du « développement infini » : la productivité d’un agent autonome fait rêver : qui n’a pas imaginé des équipes virtuelles capables de produire jour et nuit, sans fatigue ni pause café ? Mais la multiplication de dépôts « jetables » pose la question de la valeur réelle : produire plus vite ne veut pas forcément dire produire mieux.[*]L’équilibre entre vitesse et contrôle : les pipelines CI/CD actuels intègrent des garde-fous (tests, revues de code, monitoring). Que se passe-t-il si un agent bypass ces étapes ? Un bogue critique ou une faille de sécurité pourrait se propager en quelques minutes à grande échelle.[*]Redéfinir le rôle du...[/*]