Claude a été codé pendant 24 heures. Les résultats sont incroyables.

Le dernier projet de codage d'Anthropic ressemble à un défi : connecter Claude à un « harnais » d'agent fonctionnant en continu, appuyer sur démarrer et le laisser coder pendant 24 heures d'affilée. Pas de café, pas de pauses, juste un modèle d'IA qui s'attaque à une spécification logicielle massive pendant que vous dormez. L'objectif : voir si un modèle de codage moderne peut se comporter moins comme un système de saisie semi-automatique et plus comme une équipe de développeurs juniors inflexible.

Les tâches longues mettent généralement à mal les agents IA de manières ennuyantes et prévisibles. Après quelques heures, ils saturent leur fenêtre de contexte, oublient les décisions antérieures et hallucinent une structure ou déclarent simplement le projet « terminé » alors que la moitié des fonctionnalités n'existent que dans l'invite. Les outils traditionnels réinitialisent l'état, perdent l'historique des discussions et obligent les humains à surveiller chaque refonte majeure.

Le harnais open-source d'Anthropic attaque directement ce mode de défaillance. Au lieu d'un monologue géant avec le modèle, le harnais coordonne plusieurs agents, répartit le travail sur des fenêtres de contexte distinctes et persiste l'état sur le disque. Il s'appuie sur le développement dirigé par les tests : définir des centaines de cas de test et un cahier des charges détaillé à l'avance, puis laisser les agents itérer jusqu'à ce que les tests soient enfin réussis.

L'expérience de Cole Medin pousse ce dispositif à l'extrême : un marathon de codage de 24 heures pour créer un clone fonctionnel de l'application web de Claude, comprenant des projets, des conversations, des artefacts et des téléchargements de fichiers. Le dispositif active un agent initializer pour générer une liste de fonctionnalités avec environ 200+ cas de test granulaire, structure le projet et configure Git dès le début afin que chaque modification laisse une trace. Ensuite, des agents de codage se relaient pendant des heures, implémentant et corrigeant des fonctionnalités en fonction de ces tests.

Présenté comme un spectacle YouTube, cela préfigure un avenir sérieux pour le codage agentique. Des agents IA de longue durée qui construisent discrètement des MVP, des prototypes en arrière-plan, et des coquilles d'interface utilisateur complètes du jour au lendemain pourraient réduire des semaines de préparation à une seule journée calendaire. Ce coup de maître de 24 heures démontre simplement ce qui se passe lorsque vous arrêtez de considérer l'IA comme une boîte de chat et que vous commencez à la percevoir comme un processus.

L'endurance, et non un quotient intellectuel brut, tue silencieusement la plupart des expériences de codage en IA. Les agents de longue durée dérivent, écrasent leurs propres plans, ou décident tout simplement qu'ils en ont fini une fois que la fenêtre de contexte est remplie de code à moitié réfléchi et d'instructions vagues. La configuration d'Anthropic attaque directement ce mode de défaillance : un harnais qui se souvient de ce que l'agent ne peut pas.

Plutôt qu'un nouvel agent intelligent, le cadre agit comme une couche de coordination enveloppée autour des sessions ordinaires de Claude Code. Il suit les fichiers, les tâches et les résultats de tests sur des heures d'exécution, générant de nouvelles conversations chaque fois qu'un fil devient trop encombré pour rester cohérent. Chaque nouvelle session commence par un instantané distillé de ce qui est important, et non un compte rendu désordonné de tout ce qui s'est passé auparavant.

Des projets massifs se transforment en listes de tâches structurées. Le processus commence avec une spécification d'application en texte brut ou un PRD, puis se déploie en une liste de fonctionnalités comprenant des centaines de petits comportements testables. La course de Cole Medin a ciblé plus de 200 cas de test pour un clone de style Claude.ai, tous générés à partir de cette seule spécification.

Ces fonctionnalités ne se contentent pas d'être des points vagues. Elles deviennent des objets JSON avec des champs tels que la description, les fichiers modifiés et des critères d'acceptation spécifiques. Le harnais peut alors sélectionner une fonctionnalité à la fois, fournir le contexte pertinent à Claude et lui demander de mettre en œuvre ou de corriger uniquement cette partie du système.

Au lieu d'un méga-chat de 24 heures, le système fonctionne avec des dizaines ou des centaines de « sprints » ciblés. Chaque sprint est une session d'agent éphémère avec un objectif précis : ajouter un composant, connecter un appel d'API, faire passer un test. Lorsque la fenêtre contextuelle commence à se remplir, le système clôture cette session et en ouvre une nouvelle, alimentée par l'état actuel du dépôt et la liste des tâches.

L'état réside sur le disque et dans git, pas dans la mémoire du modèle. Le harnais s'appuie sur : - La base de code elle-même - La liste des fonctionnalités en JSON - Une suite de tests croissante et des journaux

En externalisant l'état, le harnais transforme un agent capricieux et oublieux en quelque chose qui se comporte davantage comme un pipeline de compilation déterministe—capable de continuer à coder pendant 24 heures sans perdre le fil.

La mission de 24 heures de Claude avait un objectif d'une clarté brutale : reconstruire l'application web Claude.ai de zéro, sans assistance humaine, sans corrections en cours de route. Ce n'est pas une simple boîte de discussion ludique, mais un clone fonctionnel de l'interface que des millions d'utilisateurs utilisent chaque jour. Même flux fondamentaux, même sensation de finition, fonctionnant de bout en bout sur un code écrit entièrement par une IA qui ne dort jamais.

Cela signifie répliquer l'ensemble de la surface de conversation. L'agent devait établir une gestion de conversation persistante avec un historique des messages, des fils de discussion en parallèle et un routage approprié vers différents projets. Il avait également besoin de véritables téléversements de fichiers et pièces jointes, pas de simples références—gérant des documents, du code et des PDF qui circulent dans le modèle et ressortent en tant que références dans l'interface utilisateur.

De plus, le cahier des charges de Cole Medin exigeait une organisation au niveau du projet et une interface moderne et épurée. Le clone devait inclure : - Création et changement de projet - Conversations regroupées par projet - Support pour les "artefacts" ou sorties enrichies - Une mise en page réactive de style Claude avec un chrome UX léger, et non du Bootstrap brut.

C'est exactement le genre de tâches dans lesquelles les agents de longue durée devraient exceller : un mélange dense de travail front-end en React ou Next.js, de plomberie API back-end et de code d'intégration pour maintenir la cohérence de l'état. Cela oblige Claude à jongler avec le routage, l'authentification, la persistance et l'état de l'interface utilisateur tout en restant en accord avec une spécification produit lisible par un humain. Aucun prompt unique ne peut couvrir cela ; seul un système qui décompose le travail et revisite le contexte sans cesse a une chance.

L'article d'Anthropic sur les Harnais Efficaces pour Agents de Longue Durée - Anthropic utilise un clone de style Claude.ai comme exemple phare, accompagné de centaines de tests et d'un flux de travail multi-agents. Sur le papier, le harnais coordonne les agents d'initialisation et de codage, met en place une structure de soutien et passe en revue plus de 200 cas de test jusqu'à ce que l'application réussisse. Sur YouTube, ce diagramme brillant se transforme en une question brutale : ce même dispositif peut-il réellement produire un clone de Claude.ai en 24 heures sans aucune retouche humaine, ou l'article de blog s'est-il discrètement appuyé sur des ajustements manuels et des captures d'écran soigneusement sélectionnées ?

Ces enjeux font de cela plus qu'un simple jalon. Si un harnais associé à Claude peut vraiment construire un clone de Claude.ai proche de la production sans surveillance, cela laisse entrevoir un avenir proche où « démarrer une nouvelle application » signifie rédiger une spécification, appuyer sur exécuter, et revenir le lendemain matin à un squelette SaaS opérationnel.

L'Agent Initialisateur agit comme l'architecte en chef du projet, mais sans ego et avec une patience illimitée. C'est le premier processus que le système d'Anthropic active, et tout ce qui suit dépend de la qualité de son travail. Avant qu'une seule fonctionnalité ne soit codée, cet agent se penche sur les spécifications de l'application—le pseudo-PRD pour le clone de Claude.ai—et le transforme en un plan entièrement structuré.

Son travail semble simple : « analyser les exigences et mettre en place le projet. » En pratique, cela signifie convertir quelques pages de texte en un plan lisible par machine que d'autres agents peuvent suivre pendant 24 heures d'affilée sans se perdre. Pas de débogage, pas de finition de l'interface utilisateur, pas de refactorisations—juste une mise en place.

Le harnais oblige l'Agent Initialisateur à créer quatre artefacts principaux qui définissent l'ensemble de la construction :

• 1Une liste de fonctionnalités en JSON avec plus de 200 cas de test granulaire.
• 2Un script d'initialisation pour démarrer le projet.
• 3Gabarit de squelette de code pour l'ensemble de la pile
• 4Un dépôt Git fraîchement initialisé

Cette liste de fonctionnalités en JSON effectue discrètement le travail le plus lourd. Elle décompose la spécification du clone de Claude.ai en centaines de petits comportements vérifiables : commencer une nouvelle conversation, télécharger un fichier, changer de projet, rendre des artefacts, gérer des états vides, et bien plus encore. Chaque cas de test devient une cible pour de futurs agents de codage, imposant une sorte de développement piloté par les tests d'origine IA.

Le script d'initialisation assemble l'environnement afin que les futurs agents ne gaspillent pas de jetons à réinventer des étapes de configuration. Il encode des décisions telles que le choix du framework, les gestionnaires de paquets et les commandes de développement—pensez à `npm install`, aux initialisations de base de données et aux équivalents de `npm run dev`, tous capturés dans un point d'entrée reproduisible.

L'échafaudage offre aux agents de codage une carte de la base de code avant qu'ils ne touchent à un seul composant. Vous obtenez des répertoires prédéfinis pour le frontend, le backend, les routes API et les utilitaires partagés, ainsi que des fichiers de programmation qui suggèrent l'architecture : routage, gestion de l'état et points d'intégration pour le chat de Claude, les artefacts et la gestion des fichiers.

Git est le dernier élément non négociable. L’Agent Initialisateur crée un nouveau dépôt, établissant l'historique des versions depuis la première ligne, afin que les agents suivants puissent valider, comparer et revenir en arrière en toute sécurité. Pour les systèmes de codage agentique de longue durée, cet historique est la seule chose empêchant une session de 24 heures de s'effondrer dans le chaos.

Le codage dépend entièrement de son principal moteur : l'Agent de Codage. Une fois que l'Agent Initialisateur a esquissé le plan, cet agent entre dans une boucle implacable, se réveillant avec une nouvelle fenêtre contextuelle, relisant l'état du projet et avançant à travers les fonctionnalités une par une. Pas de discussions, pas de remue-méninges, juste un cycle de rétroaction serré de tests, de modifications et de validations.

Au centre se trouve une discipline rigide de développement piloté par les tests (TDD). Avant qu'une seule ligne de code de production ne change, le système sait déjà à quoi ressemble un "fait" grâce à une liste de fonctionnalités massive au format JSON, comportant souvent plus de 200 cas de test granulaires. Le travail de l'Agent de Codage n'est pas d'être créatif ; il consiste à faire passer ces tests au vert.

Chaque boucle commence par l'agent chargeant un artefact de progression : un fichier structuré qui suit les fonctionnalités existantes, les tests réussis et ce qui s'est récemment cassé. À partir de là, il choisit la prochaine cible - par exemple, "supporter le téléchargement de plusieurs fichiers dans un projet" ou "afficher l'historique des conversations avec des artefacts" - en fonction des priorités et des dépendances. Ce choix se fait à l'intérieur de l'invite, mais l'état qui le guide est stocké sur disque.

Avant de toucher à la base de code, l'agent exécute l'ensemble de la suite de régression. Cela signifie que chaque itération commence par la revalidation de tout ce qui a été construit jusqu'à présent, détectant ainsi les régressions immédiatement plutôt que des heures plus tard. Si un test précédemment réussi échoue, l'agent se concentre sur la correction de cela avant d'ajouter quoi que ce soit de nouveau.

Ce n'est qu'après que les tests de régression ont réussi que l'agent met en œuvre la nouvelle fonctionnalité. Il modifie les fichiers source, met à jour les composants, ajuste les gestionnaires d'API et raccorde le comportement de l'interface utilisateur, le tout via la même interface d'outil. Ensuite, il relance les tests, répétant le processus jusqu'à ce que le nouveau cas passe ou qu'il atteigne une limite configurée de tentatives.

Lorsque la fonctionnalité fonctionne, le harnais oblige l'agent à externaliser sa mémoire. Il met à jour le fichier de progression avec des détails : quelle fonctionnalité a été implémentée, quels tests sont maintenant réussis, les limitations connues et les prochaines étapes logiques. Ce fichier devient un journal des modifications compact et lisible par machine pour la prochaine session.

Chaque boucle se termine par un commit Git. Le cadre considère Git non pas comme une réflexion secondaire mais comme un substrat mémoire central : les différences indiquent à la prochaine instance de l'Agent de Codage exactement ce qui a changé, les messages de commit résument l'intention, et l'historique préserve des erreurs catastrophiques. Associés au fichier de progression, ces commits permettent à une toute nouvelle fenêtre contextuelle de "se souvenir" de 18 heures de travail sans avoir à relire l'intégralité de la base de code.

Les outils en ligne de commande comme Claude Code semblent puissants, mais cette expérience de 24 heures les contourne discrètement. Au lieu de se connecter à une interface en ligne de commande, le système communique directement avec Claude via le Claude Agents SDK en Python, considérant le modèle comme un composant logiciel de premier ordre plutôt que comme une simple commande de terminal sophistiquée.

Le système d'Anthropic génère des agents, planifie le travail et inspecte l'état de git uniquement via des appels SDK. Le processus Python orchestre tout : création de sessions, diffusion des appels d'outils, lecture et écriture de fichiers, et même redémarrage des agents lorsqu'ils sont à l'arrêt. Aucun humain ne tape jamais `claude code` dans une invite une fois l'exécution commencée.

L'accès direct au SDK transforme également le choix du modèle en un détail de configuration plutôt qu'en une reconstruction. Le même dispositif pourrait appeler : - Claude Sonnet 4.5 pour des itérations économiques - Claude Opus 4.5 pour des refactors plus complexes - Des modèles tiers comme Code Llama ou des codeurs de style GPT via des API compatibles.

Le changement de modèle devient une modification sur une seule ligne dans un initialiseur de client, et non un tout nouveau flux de travail. Le harnais traite déjà « Claude » comme une abstraction : un agent de codage avec des outils, un contexte, et un contrat. En dessous, ce contrat peut pointer vers n'importe quel modèle qui parle JSON et respecte le protocole.

C'est pourquoi les SDK semblent être le véritable avenir de la programmation agentique. Les CLIs brillent pour des corrections rapides ponctuelles ou le débogage interactif ; elles atteignent leurs limites lorsque vous avez besoin d'un état persistant, de tâches en arrière-plan ou de coordination entre agents. Les systèmes de longue durée comme celui-ci exploitent des points d'accroche programmatiques pour la journalisation, les nouvelles tentatives, les métriques et les contrôles de sécurité.

Le Guide de démarrage rapide pour le codage autonome d'Anthropic - Référentiel GitHub d'Anthropic intègre cette hypothèse. Le dépôt ne contient que du Python, des invites et un câblage autour du SDK des Agents, donnant au tout moins l'impression d'un outil de développement et plus celle d'un microservice extensible pour la création de logiciels.

Lancer votre propre codeur Claude 24 heures sur 24 commence avec le cadre open-source d'Anthropic sur GitHub. Rendez-vous au guide de démarrage rapide pour la programmation autonome dans le dépôt claude-quickstarts, plus précisément dans le répertoire `autonomous-coding`, et clonez-le localement. Vous disposez d'une structure prête à l'emploi : des invites, des branchements d’agents et des scripts pour faire fonctionner des agents de codage Claude à long terme.

La configuration ressemble davantage à celle d'un outil de développement qu'à une simple démo. Vous installez les dépendances (Python, Node, et les paquets du projet via `npm install` ou `pnpm install`), déposez vos variables d'environnement dans un fichier `.env`, et configurez le système avec vos identifiants Claude. Le dépôt est fourni avec des configurations exemples pour le clone de Claude.ai, vous permettant principalement de modifier plutôt que d’inventer.

Le contrôle des coûts devient la fonctionnalité killer non évidente. Cole Medin souligne un truc essentiel de la vidéo : utilisez un jeton d'abonnement Claude (le même que celui que votre navigateur utilise pour Claude Code) au lieu d'une clé API à facturation à l'utilisation. Si vous le reliez à une clé à usage payant et que vous le laissez fonctionner 24 heures, vous risquez de vous réveiller avec une facture de plusieurs centaines ou milliers d'euros.

Le lancement de tout le processus se résume à une seule commande depuis la racine du dépôt, quelque chose comme :

- `python main.py --app-spec=app_spec.txt`

Après avoir appuyé sur Entrée, rien d'excitant ne se passe pendant 10 à 20 minutes. C'est l'Agent Initialiseur qui génère tranquillement plus de 200 cas de test, prépare le projet, rédige le script d'initialisation et crée un dépôt git avant qu'une interface utilisateur visible n'apparaisse.

Tout repose sur votre fichier spécification de l'application. Le système d'Anthropic s'attend à un fichier texte au style PRD extrêmement détaillé décrivant les pages, les flux, les cas limites, les rôles et les exigences non fonctionnelles. Si vous lui fournissez un paragraphe vague de type « clone d'application de chat », vous obtiendrez un produit vague.

Une spécification solide pour un clone de Claude.ai ressemble à quelque chose que vous remettriez à une équipe humaine : structure d'URL, états de conversation, limites de téléchargement de fichiers, comportement des artefacts, raccourcis clavier, messages d'erreur et même designs pour états vides. L'Agent Initialisateur transforme cela en tests granulaires, de sorte que chaque phrase vague dans votre spécification se transforme en une fonctionnalité vague ou manquante 12 heures plus tard.

Minuit sonne, la commande s'exécute, et le harnais bascule silencieusement de la configuration à l'exécution. L'Agent Initialisateur lance sa première session, récupérant la spécification de l'application, générant ce vaste feature_list.json avec environ 200 cas de test granulaires, et connectant l'échafaudage initial de style Next.js ainsi qu'un nouveau dépôt git. Une fois ces artefacts écrits, le contrôle est transféré à la véritable machine de travail : la boucle de l'Agent de Codage.

Votre terminal cesse d'avoir l'apparence d'une console de développement normale et commence à ressembler à un journal système en direct d'un partenaire programmeur extraterrestre. Les appels d'outils défilent toutes les quelques secondes : `read_file`, `write_file`, `run_tests`, `git diff`, `git commit`. Vous regardez les répertoires comme `app/`, `components/` et `lib/` se remplir de TypeScript, de composants React et de gestionnaires de routes API, tous rédigés par Claude sans aucune invite de votre part après ce premier `npm start`.

Les lignes de sortie s'accumulent à un rythme qu'aucun humain ne pourrait soutenir. Un instant, l'agent prépare un panneau latéral pour les projets, l'instant d'après, il relie les fils de conversation, puis il corrige un test instable dans le panneau des artefacts. Le harnais maintient les sessions courtes, faisant tourner le contexte et lançant de nouvelles exécutions de l'Agent de Codage tout en préservant l'état à travers le système de fichiers, l'historique git et la liste des fonctionnalités en JSON.

Les mains restent éloignées du clavier par conception. Pas de boutons "approuver", pas de nouvelles tentatives manuelles, pas de modifications de prompts en cours de route. Une fois que vous lancez `node run_harness.mjs`, le système prend en charge les 24 heures suivantes : planification, codage, exécution des tests et engagement du code. La seule activité humaine consiste à regarder le défilement et à vérifier occasionnellement les métriques du système pour s'assurer que la machine elle-même ne surchauffe pas.

La sécurité et la validation imprègnent presque chaque action. Le harnais enveloppe les commandes shell pour bloquer toute chose dangereuse, limite les écritures de fichiers au répertoire du projet, et utilise Puppeteer via un serveur MCP pour vérifier visuellement le clone de Claude.ai dans un navigateur sans interface graphique. L'agent peut :

• 1Démarrez le serveur de développement
• 2Ouvrir localhost dans Chromium
• 3Cliquez à travers les projets, les conversations et les téléchargements de fichiers.
• 4Comparez l'interface utilisateur rendue à ses spécifications et testez les attentes.

Chaque passage de Puppeteer renvoie dans la boucle comme un autre signal : l'application s'est-elle réellement comportée comme prévu, ou le prochain commit doit-il déchirer et réécrire la moitié de l'interface utilisateur ?

Vingt-quatre heures et des centaines de cycles d'agent plus tard, Claude a créé quelque chose de concret : une application web fonctionnelle de type Claude.ai. Pas un jouet, pas une maquette statique, mais un front-end React, un backend API, et une suite de tests intégrée dans le même système qui a permis la construction. Cole Medin fait défiler le tout en vidéo comme n'importe quel produit SaaS normal, car fonctionnellement, c'est exactement cela.

Visuellement, le clone atterrit étonnamment près. La mise en page de la barre latérale, les fils de discussion, la liste des projets et l'esthétique générale de Claude sont tous présents : lumineux, épuré et familier. Vous pouvez commencer des conversations, les renommer et les voir s'afficher dans un panneau d'historique persistant.

L'interaction de base fonctionne aussi. L'application envoie des messages à Claude, diffuse des réponses et préserve le contexte à travers les échanges d'une conversation. Les téléchargements de fichiers fonctionnent pour des cas d'utilisation basiques, permettant d'attacher des documents à une discussion et de les faire apparaître dans l'interface utilisateur, bien que des cas particuliers concernant des fichiers volumineux ou inhabituels continuent à poser problème.

Les artefacts, la fonctionnalité distinctive des « applications intégrées » de Claude, arrivent sous une forme partielle. Le clone peut rendre des artefacts simples, les afficher dans un panneau dédié et les maintenir liés à une conversation. Les flux plus avancés - sessions multi-artefacts, outils d'état complexe ou édition d'artefacts sur place - échouent soit silencieusement, soit se comportent de manière incohérente.

La gestion de projet se situe quelque part entre les deux. L'agent piloté par harnais met en œuvre : - La création et la suppression de projets - L'attribution de conversations aux projets - Le filtrage de base des discussions par projet

Mais les opérations en masse, la recherche robuste et les vues interprojets restent instables ou manquantes, souvent signalées par des boutons non implémentés ou des états d'interface morte.

Sous le capot, la stratégie axée sur les tests porte ses fruits. Sur environ 200 cas de test générés, une grande majorité réussit d’ici la fin des 24 heures, les échecs se concentrant sur le perfectionnement de l’expérience utilisateur avancée et la gestion des erreurs obscures. Le système continue de faire circuler les tests jusqu’à ce que le progrès se stabilise, et non lorsque Claude devient "fatigué" ou décide que c'est terminé.

Medin qualifie le harnais de « légitime » devant la caméra, et cela ne semble pas être du battage médiatique. Il souligne que ce n'est pas encore une ingénierie de qualité production, mais en tant que preuve que le codage agentique peut assembler de manière autonome une application web complexe et dotée de multiples fonctionnalités en une journée, la démonstration est percutante. Associée aux avancées plus larges d'Anthropic en matière d'agents et de modèles à fonctionnement prolongé, comme Claude Opus 4.5 détaillé dans Introducing Claude Opus 4.5 - Anthropic, la conclusion est claire : ce flux de travail en est à ses débuts, mais il fonctionne déjà.

Votre actuel « programmeur pair IA » va bientôt sembler désuet. Des dispositifs durables comme le harnais d'agent open-source d'Anthropic transforment des modèles tels que Claude, passant d'assistants bavards à des travailleurs de fond qui traitent discrètement un arriéré pendant 24 heures ou plus, sans perdre le fil au milieu d'une refonte.

Au lieu de surveiller une fenêtre de saisie, vous pouvez remettre à un agent un PRD, un dépôt et une suite de tests, puis revenir à un prototype fonctionnel. L'expérience de Cole Medin avec Claude illustre cela de manière concrète : une instance Claude Code coordonnée par un harnais structure une interface de style Claude.ai, connecte les projets et les conversations, et effectue des itérations à travers des centaines de tests sur une journée complète de calcul.

Pour les développeurs, cela ressemble moins à une nouveauté qu'à un nouveau niveau d'infrastructure. Pensez aux agents comme : - Constructeurs de prototypes de nuit - Démons de refactorisation continue - Bots de génération de tests et de couverture - Assistants à la documentation et à la migration

Donnez à l'un de ces systèmes 24 heures et une liste de fonctionnalités JSON avec plus de 200 cas, et il poursuivra fidèlement les coches vertes pendant que vous dormez.

Rien de tout cela ne semble encore "prêt pour la production". Le harnais dans le repo de démarrage rapide d'Anthropic est expérimental, fragile en raison de tests peu fiables, et sujet aux mêmes hallucinations que tout LLM. Mais les stratégies qu'il encode—des invites basées sur les tests, des critères de réussite stricts, Git comme source de vérité, la coordination multi-agents—correspondent directement à la manière dont vous renforcez les systèmes d'IA dans le monde réel.

Vous pouvez déjà intégrer ces modèles dans votre pile. Utilisez un agent d'initialisation pour générer des spécifications, des structures et des tests ; contraignez un agent de codage à modifier uniquement certains répertoires ; configurez l'intégration continue pour exécuter les mêmes vérifications basées sur le harnais avant la fusion. Chaque étape rend vos assistants IA moins semblables à un remplissage automatique et plus à des travailleurs déterministes attachés à votre pipeline.

L'ingénierie agentique va changer ce que signifie « écrire des logiciels ». Les ingénieurs humains définissent les architectures, les contraintes et les étapes de validation, tandis que des flottes d'agents spécialisés s'attaquent à l'implémentation, aux tests et à l'intégration pendant des dizaines d'heures. L'expérience du clone Claude est un aperçu de cet avenir : des bases de code façonnées moins par des frappes sur le clavier et plus par l'orchestration de légions de collaborateurs infatigables, obsédés par les tests.

Qu'est-ce que le Harnais Anthropique pour les agents à long terme ?

C'est une couche de coordination open-source qui permet aux agents de codage IA de travailler sur des tâches complexes pendant de longues périodes (heures ou jours) en gérant les fenêtres de contexte et en décomposant le travail en morceaux plus petits et testables.

Ce harnais peut-il être utilisé avec d'autres modèles que Claude ?

Oui. Le harnais est indépendant du modèle. Étant un système de prompts et de fichiers d'artefacts, vous pouvez remplacer Claude Code par d'autres modèles comme ceux d'OpenAI ou des alternatives open source en adaptant le SDK client.

Ce système de codage autonome est-il prêt à être utilisé en production ?

Non, c'est encore très expérimental. C'est le plus adapté pour le prototypage rapide, la génération de preuves de concept et l'exploration de l'avenir de l'ingénierie agentique, plutôt que pour la création d'applications prêtes pour la production.

Comment le harnais évite-t-il les limitations de la fenêtre contextuelle ?

Il crée une nouvelle fenêtre de contexte fraîche pour chaque session d'agent de codage. L'agent se met à jour sur les progrès en consultant des fichiers d'artefacts essentiels tels qu'un résumé des progrès, une liste de fonctionnalités et le code existant, s'assurant qu'il n'a besoin que du contexte pertinent pour la prochaine tâche granulaire.