Claude Code active le mode auto par défaut : le cap des agents

Claude Code franchit un seuil d’autonomie par défaut

Anthropic prévoit d’activer par défaut le mode « auto » dans Claude Code, son outil de programmation assistée par intelligence artificielle. L’information a été rapportée par TechCrunch dans un article titré “Anthropic is turning Claude Code’s auto mode on by default”. À première vue, il s’agit d’un changement de configuration. Dans les faits, cette évolution touche à une question beaucoup plus large : la place que les éditeurs entendent donner aux agents logiciels dans le travail quotidien des développeurs.

Mise à jour du 07/09/2026 — Anthropic a activé le mode auto par défaut dans Claude Code pour les offres Pro, Max et Team : les nouvelles sessions peuvent exécuter des actions sans demandes d’autorisation répétées, sous contrôle d’un classificateur de sécurité. Les clients Enterprise et les utilisateurs via API restent, pour l’instant, en opt-in. (claude.com)

Le point important n’est pas seulement que Claude Code puisse proposer du code, expliquer une erreur ou aider à naviguer dans un dépôt. Ces usages sont désormais largement familiers aux équipes techniques. Le changement porte sur le degré d’initiative que l’outil est autorisé à prendre pendant l’exécution d’une tâche. En activant le mode auto par défaut, Anthropic entend réduire le nombre d’interventions manuelles nécessaires entre la demande initiale et l’avancement du travail de développement.

TechCrunch présente cette décision comme une orientation vers davantage d’autonomie. Claude Code doit pouvoir choisir plus directement les actions nécessaires et poursuivre un objectif de programmation avec moins de validations intermédiaires de la part de l’utilisateur. La nuance est essentielle. Une IA qui suggère une ligne de code reste un assistant ponctuel ; une IA qui enchaîne des actions pour faire progresser une tâche se rapproche davantage d’un agent de code.

Le mot « agent » est devenu omniprésent dans l’industrie de l’IA, parfois au prix d’une certaine imprécision. Dans le contexte du développement logiciel, il renvoie généralement à un système capable de décomposer une intention en sous-tâches, de consulter un environnement de travail, de produire ou modifier des fichiers, de vérifier certains résultats, puis d’ajuster sa trajectoire. Le niveau réel d’autonomie dépend toujours des permissions, de l’environnement technique et des garde-fous définis par l’organisation. Mais la logique est différente de celle d’une simple conversation dans une fenêtre de chat.

Le choix d’un réglage par défaut compte précisément parce qu’il détermine l’expérience de la majorité des utilisateurs. Une fonctionnalité optionnelle peut rester marginale, réservée aux expérimentateurs ou aux personnes ayant pris le temps d’en comprendre les implications. Une option activée dès l’usage initial devient, à l’inverse, la trajectoire normale du produit. Anthropic envoie ainsi le signal que l’autonomie n’est plus un mode expert ajouté à Claude Code : elle est appelée à devenir une partie ordinaire de son fonctionnement.

Cette décision intervient dans un marché où les outils d’IA pour développeurs évoluent rapidement. Depuis l’arrivée de GitHub Copilot en 2021, l’assistance à la programmation est passée de la complétion de code à des interfaces conversationnelles, puis à des outils capables de traiter des demandes plus étendues. OpenAI avait également présenté Codex en 2021 comme un système capable de traduire des instructions en langage naturel vers du code. L’ambition industrielle s’est ensuite déplacée : il ne s’agit plus seulement de générer un fragment à insérer, mais d’aider à accomplir des tâches de développement complètes.

Anthropic s’inscrit explicitement dans cette trajectoire avec Claude Code. L’entreprise, fondée en 2021 par d’anciens membres d’OpenAI, s’est fait connaître par sa famille de modèles Claude et par son positionnement très visible sur la sûreté des systèmes d’IA. Claude Code a été présenté par Anthropic en février 2025, à l’occasion du lancement de Claude 3.7 Sonnet. L’outil est conçu pour assister les développeurs dans leur environnement de travail, notamment pour comprendre une base de code, effectuer des modifications et répondre à des problèmes de programmation.

Le passage du mode auto au statut de réglage par défaut constitue donc une évolution cohérente avec la promesse initiale de ce type de produit : diminuer la friction entre une demande et son exécution. Il ne faut toutefois pas confondre cette promesse avec une délégation sans limites. Dans le logiciel, chaque action peut avoir des conséquences techniques, opérationnelles, financières ou juridiques. Un fichier modifié, une dépendance ajoutée, une configuration changée ou une commande exécutée peuvent produire des effets qui dépassent largement le périmètre de la tâche formulée au départ.

Pour les développeurs français et européens, le sujet n’est pas abstrait. Les équipes utilisent déjà des assistants de code dans des contextes très variés : produit numérique, services financiers, industrie, secteur public, santé, commerce, logiciels internes ou projets open source. À mesure que les outils deviennent plus autonomes, la question centrale n’est plus simplement de savoir si l’IA peut écrire du code utile. Elle devient : dans quelles conditions une équipe peut-elle accepter qu’un système prenne des initiatives dans son environnement de développement, et comment conserve-t-elle une capacité effective de vérification ?

Un changement de paramètre qui modifie le rythme du développement

Selon les éléments rapportés par TechCrunch, l’activation par défaut du mode auto doit diminuer les interventions manuelles nécessaires pendant les tâches de programmation. C’est l’objectif opérationnel immédiat du changement. Au lieu d’obliger l’utilisateur à confirmer fréquemment la poursuite d’une démarche, l’outil peut continuer davantage par lui-même vers l’objectif demandé.

Cette réduction des interruptions peut sembler modeste sur le papier. Elle est pourtant déterminante dans le travail réel des développeurs. Une tâche de programmation comporte souvent une succession d’étapes : identifier les composants pertinents, comprendre les conventions du projet, localiser une erreur, modifier plusieurs fichiers, rechercher des usages existants, puis vérifier que la modification est cohérente avec le reste du code. Si l’assistant s’arrête à chaque embranchement pour demander une autorisation, le développeur demeure le pilote direct de chaque mouvement. Si l’assistant poursuit de manière plus autonome, le rôle humain tend à se déplacer vers la formulation de l’objectif, la surveillance du processus et la validation du résultat.

Le bénéfice recherché est donc moins une simple accélération de la frappe que la réduction du coût de coordination. Les développeurs ne passent pas leur temps uniquement à écrire du code. Ils alternent entre lecture, recherche, compilation, tests, documentation, revue et échanges avec leurs collègues. Un agent capable de conserver le fil d’une tâche et de franchir plusieurs étapes sans sollicitation constante peut rendre cette séquence plus fluide. C’est particulièrement pertinent pour les travaux répétitifs, les corrections ciblées, les explorations de code ou les opérations de maintenance dont le périmètre est suffisamment clair.

Le réglage par défaut est aussi une décision de conception comportementale. Les utilisateurs adoptent plus volontiers les parcours qui leur sont proposés sans configuration préalable. En faisant du mode auto la norme, Anthropic ne se contente pas de mettre une capacité à disposition : l’entreprise encourage une manière de travailler dans laquelle Claude Code exerce davantage d’initiative. Les utilisateurs conservent naturellement une responsabilité dans les conditions d’usage de l’outil, mais le produit abaisse la barrière psychologique et pratique qui séparait l’assistance de l’autonomie.

Il convient de rester précis sur ce que l’annonce établit. TechCrunch rapporte un changement de comportement par défaut destiné à rendre Claude Code plus autonome dans la poursuite des objectifs de développement. Cela ne signifie pas qu’Anthropic affirme avoir créé un système infaillible, ni qu’un agent peut remplacer le jugement d’une équipe d’ingénierie. L’enjeu est au contraire de savoir comment cette autonomie s’insère dans des flux de travail qui comportent déjà des règles de sécurité, des validations et des responsabilités humaines.

Dans une organisation mature, le code n’est presque jamais directement assimilé à un produit final prêt à être mis en production. Il circule entre plusieurs contrôles : tests automatisés, intégration continue, revue par les pairs, validation fonctionnelle, audit de sécurité, suivi des changements et déploiement progressif selon les pratiques internes. Claude Code, même plus autonome, s’inscrit dans cette chaîne. Sa capacité à faire avancer une tâche peut alléger certaines opérations, mais elle ne dispense pas l’entreprise de savoir ce qui a été modifié, pourquoi cela l’a été et qui a validé le changement.

Cette distinction est encore plus importante lorsque l’outil est utilisé sur des dépôts complexes. Une application moderne repose souvent sur de nombreuses bibliothèques, des services externes, des fichiers de configuration et des règles métier accumulées au fil des années. Le code généré ou modifié peut sembler correct localement tout en introduisant une incompatibilité, une régression ou une dette de maintenance visible seulement plus tard. L’autonomie permet d’aller plus vite dans l’action ; elle ne garantit pas, par elle-même, que l’action soit conforme à l’intention de l’équipe.

Le mode auto soulève ainsi une tension structurelle. D’un côté, les utilisateurs veulent éviter de cliquer sur une série de confirmations prévisibles. De l’autre, chaque confirmation retirée peut correspondre à un moment où une personne aurait pu détecter une mauvaise hypothèse, une ambiguïté dans la demande ou une action trop large. La valeur du mode dépendra de la capacité du produit à réserver les interruptions humaines aux décisions qui le justifient réellement, plutôt que de les éliminer indistinctement.

Pour Anthropic, le bénéfice potentiel est également stratégique. Les outils de code sont un terrain où la qualité d’un modèle ne suffit pas à déterminer l’expérience. La vitesse, l’intégration dans les pratiques existantes, la compréhension du contexte et le nombre de gestes nécessaires jouent un rôle tout aussi important. Un outil qui produit des résultats techniquement utiles mais demande une supervision à chaque étape peut être jugé moins efficace qu’un concurrent légèrement moins performant sur une tâche isolée, mais mieux intégré au flux quotidien.

De l’assistant conversationnel à l’agent de code : une transformation du rôle humain

Le changement annoncé par Anthropic illustre une évolution plus générale du marché : le passage progressif d’outils qui répondent à des questions vers des outils qui entreprennent des actions. Les assistants conversationnels ont familiarisé les développeurs avec l’idée de décrire un problème en langage naturel. Les agents de code cherchent désormais à convertir cette description en séquences de travail plus longues, avec une continuité entre l’intention et les opérations effectuées dans un projet.

Ce déplacement ne se mesure pas seulement au nombre de lignes de code produites. Il modifie la nature de l’interaction. Avec un assistant classique, un développeur peut demander une explication, une fonction ou une correction, puis intégrer manuellement la réponse. Avec un système plus agentique, il formule davantage un objectif : corriger un défaut, adapter un composant, investiguer une anomalie, préparer une modification. L’outil devient alors un exécutant partiel, tandis que le développeur devient plus explicitement prescripteur, évaluateur et responsable de la décision finale.

Cette nouvelle répartition peut améliorer l’efficacité, mais elle exige une formulation plus rigoureuse des demandes. Une instruction vague peut être tolérable quand elle sert à obtenir une suggestion parmi d’autres. Elle devient plus risquée quand elle déclenche une série d’actions. Dire « simplifie ce module », « corrige ce comportement » ou « modernise cette partie du projet » laisse place à des interprétations. Un agent peut choisir une stratégie différente de celle attendue par l’équipe, même si son raisonnement paraît cohérent à partir du contexte qu’il a reçu.

La qualité de la supervision dépend donc en partie de la qualité du cadrage initial. Il faut décrire le périmètre, les contraintes, les éléments à ne pas toucher, les conventions à respecter et les critères de succès. Cette discipline n’est pas nouvelle dans l’ingénierie logicielle. Elle se rapproche de la rédaction d’un ticket clair, d’un cahier de recette ou d’une demande adressée à un collègue. L’IA rend toutefois cette exigence plus visible, car elle peut agir rapidement sur la base d’une demande incomplète.

Le cas des développeurs expérimentés mérite une attention particulière. Ils peuvent trouver dans un mode auto un moyen de déléguer les tâches de faible valeur cognitive, comme certaines recherches répétitives ou modifications mécaniques. Mais leur expertise reste indispensable pour identifier les zones où l’autonomie est inappropriée : logique métier sensible, calculs financiers, sécurité, architecture, migrations complexes ou composants soumis à des contraintes réglementaires. La rapidité d’exécution d’un agent n’élimine pas la nécessité de comprendre un système ; elle peut même augmenter le coût d’une erreur si un changement se propage plus vite.

Pour les développeurs débutants, l’effet est plus ambivalent. Un outil qui poursuit une tâche de bout en bout peut aider à visualiser les étapes nécessaires pour résoudre un problème. Mais il peut aussi réduire l’exposition aux raisonnements intermédiaires qui construisent l’apprentissage : lire une trace d’erreur, comparer plusieurs approches, comprendre les compromis d’une architecture ou mesurer les conséquences d’une modification. L’enjeu pédagogique n’est pas d’interdire les agents, mais d’éviter que leur efficacité apparente ne masque une perte de compréhension du code livré.

Le parallèle avec les pratiques de revue de code est instructif. La revue ne sert pas uniquement à trouver des erreurs. Elle permet de diffuser les connaissances sur un projet, d’aligner les pratiques, de documenter implicitement des décisions et d’installer une responsabilité collective. Si un agent de code accélère la production de modifications, les équipes peuvent être confrontées à davantage de changements à examiner dans un temps donné. La revue devra alors évoluer : moins centrée sur la vérification ligne par ligne de détails générés, davantage concentrée sur l’intention, les interfaces, les risques et les tests.

Cette évolution peut aussi accentuer une difficulté déjà connue : la confiance excessive dans des sorties plausibles. Les modèles de langage sont capables de produire du code qui semble convaincant, bien formaté et documenté, sans que cela constitue une preuve de justesse. Le risque n’est pas propre à Claude Code ni au mode auto. Il est inhérent à l’usage de systèmes génératifs dans un domaine où une erreur de détail peut avoir un impact important. L’autonomie par défaut rend cette question plus pressante, car elle réduit les occasions de réexaminer le chemin emprunté avant d’atteindre un résultat.

La réponse ne consiste pas nécessairement à multiplier les validations jusqu’à annuler le gain recherché. Elle consiste plutôt à adapter le niveau de contrôle au niveau de risque. Une modification cosmétique sur une documentation interne n’appelle pas les mêmes précautions qu’un changement dans un système de paiement, une application de santé ou un logiciel traitant des données personnelles. L’agent de code devient alors un élément d’un dispositif de contrôle gradué, et non un raccourci universel applicable de façon identique à tous les projets.

Les exigences de contrôle, de sécurité et de responsabilité pour les équipes

Le principal effet de l’autonomie accrue n’est pas de faire disparaître le contrôle humain, mais de le déplacer. Quand les interventions manuelles sont moins fréquentes pendant l’exécution, la préparation et la vérification prennent davantage de valeur. Avant d’utiliser un agent, une équipe doit savoir sur quels projets il intervient, quels accès lui sont accordés, quels environnements sont concernés et quelles actions exigent une validation explicite.

La première question est celle du périmètre. Un dépôt de code n’est pas toujours un espace isolé. Il peut contenir des configurations, des références à des services tiers, des scripts, des fichiers d’infrastructure ou, dans le pire des cas, des informations qui ne devraient pas être exposées. Même lorsque le travail concerne uniquement le logiciel, le contexte fourni à l’outil peut avoir une sensibilité particulière. La gouvernance doit donc couvrir à la fois le code produit par l’IA et les données ou fichiers auxquels elle peut être confrontée.

La deuxième question concerne la traçabilité. Lorsqu’un agent accomplit une partie d’une tâche, l’organisation doit pouvoir comprendre le changement apporté et le relier à une demande identifiable. Cette exigence existe déjà dans les processus professionnels de développement. Elle devient cependant plus importante si le volume de modifications augmente ou si leur origine est moins directement attribuable à une action manuelle précise. La bonne pratique consiste à conserver des mécanismes de revue, d’historique et de validation adaptés aux règles internes de chaque organisation.

La troisième question est celle de la responsabilité. Un agent ne porte pas la responsabilité juridique ou opérationnelle d’un déploiement. Cette responsabilité demeure du côté des personnes et des organisations qui décident de l’utiliser, de valider son résultat et de le mettre en production. Le mode auto ne change pas ce principe. Il oblige plutôt les équipes à éviter une confusion dangereuse entre autonomie d’exécution et autonomie de décision.

Dans le contexte français, cette distinction résonne avec les obligations et pratiques déjà ancrées autour de la protection des données et de la cybersécurité. Le règlement général sur la protection des données, ou RGPD, structure depuis 2018 une partie du cadre européen applicable au traitement des données personnelles. L’AI Act européen est entré en vigueur le 1er août 2024, avec une application progressive de ses dispositions. Sans préjuger de l’application de tel ou tel régime juridique à un usage donné de Claude Code, ces textes rappellent que les entreprises ne peuvent pas traiter l’adoption d’outils d’IA comme une simple décision individuelle de confort.

Pour une direction technique, une direction de la sécurité des systèmes d’information ou un responsable de la protection des données, l’arrivée d’un mode agentique par défaut peut donc justifier une réévaluation des politiques existantes. Les questions à examiner ne sont pas nécessairement propres à Anthropic : quels outils sont autorisés ? Quels projets peuvent y être exposés ? Quelles données ne doivent pas être soumises à un service externe ? Quels contrôles sont indispensables avant l’intégration d’un changement ? Qui décide de l’extension des usages ?

La sécurité du code généré ou modifié est un autre point central. Un agent peut accélérer la correction d’un défaut, mais il peut aussi introduire une faiblesse si ses changements ne sont pas revus avec la même rigueur que ceux d’un humain. Les tests automatisés restent utiles, mais ils ne couvrent pas tous les scénarios. Une suite de tests peut confirmer qu’un comportement attendu demeure intact tout en laissant passer un problème de conception, de confidentialité, de performance ou de sécurité. L’autonomie de l’outil renforce l’intérêt d’une défense en profondeur : tests, revue, contrôle des dépendances, règles de déploiement et suivi après mise en production.

Il serait néanmoins erroné d’associer automatiquement agent de code et hausse du risque. Une IA peut également aider à détecter des incohérences, à documenter un module mal compris, à rechercher des occurrences dans un grand dépôt ou à préparer des correctifs. Le risque dépend des capacités effectives de l’outil, du contexte fourni, des permissions accordées et, surtout, des contrôles qui entourent son utilisation. Le changement d’Anthropic pousse les organisations à traiter ces paramètres comme des choix de gouvernance, plutôt que comme de simples préférences individuelles dans une interface.

La question de la responsabilité se pose aussi dans la relation entre fournisseurs, clients et sous-traitants. De nombreuses entreprises françaises font développer ou maintenir leurs applications par des prestataires. Si des agents de code sont employés dans cette chaîne, les conditions d’utilisation, de validation et de confidentialité peuvent devenir un sujet contractuel ou de pilotage. Là encore, le fait qu’un mode soit activé par défaut ne dispense pas les acteurs impliqués d’expliciter les règles du jeu.

Un marché concurrentiel où l’autonomie devient un critère de produit

L’orientation prise par Anthropic doit être lue à l’aune d’un marché très concurrentiel. GitHub Copilot a contribué à installer l’IA dans les outils quotidiens des développeurs, d’abord à travers la complétion et les suggestions. OpenAI, Google, Anthropic et de nombreux éditeurs spécialisés ont depuis multiplié les initiatives autour de la programmation assistée. La compétition ne porte plus seulement sur la qualité d’un extrait de code généré à partir d’une instruction ; elle porte sur la capacité d’un outil à comprendre un projet, à s’intégrer dans un environnement de travail et à faire gagner du temps sur des tâches réelles.

Dans cette course, l’autonomie est une promesse différenciante. Une entreprise peut toujours comparer des modèles sur des exercices standardisés ou des démonstrations ponctuelles. Mais, pour les utilisateurs, l’expérience dépend aussi du nombre de fois où ils doivent reprendre la main. Un agent qui demande sans cesse une confirmation peut être perçu comme prudent mais laborieux. Un agent qui agit facilement peut être perçu comme fluide mais susciter davantage de réserves. L’équilibre entre ces deux perceptions devient une caractéristique de produit aussi importante que la qualité des réponses.

La décision d’activer le mode auto par défaut montre qu’Anthropic choisit clairement de privilégier la fluidité. Cette stratégie est cohérente avec l’idée qu’un assistant de développement doit pouvoir poursuivre un objectif plutôt que de se limiter à répondre à une succession de micro-instructions. Elle implique aussi qu’Anthropic devra convaincre les utilisateurs que la simplification de l’expérience ne se fait pas au détriment de leur capacité à garder la maîtrise des actions importantes.

Le débat dépasse Claude Code. Les environnements de développement évoluent vers des systèmes dans lesquels plusieurs formes d’IA peuvent coexister : complétion, chat contextualisé, recherche dans un dépôt, génération de tests, assistance à la documentation et exécution de tâches. Dans cet ensemble, l’agent est la couche qui concentre le plus de promesses économiques, parce qu’il cherche à réduire le temps nécessaire pour passer de l’intention à une modification exploitable. C’est aussi la couche qui concentre le plus de questions de confiance.

Pour les entreprises, le calcul ne se résume pas à la productivité immédiate. Un gain de vitesse n’a de valeur durable que s’il ne crée pas un coût équivalent en relectures, incidents, dette technique ou difficultés de maintenance. Les outils les plus attractifs seront probablement ceux qui donnent une autonomie utile tout en permettant aux équipes de définir leurs propres limites. Un groupe bancaire, une jeune pousse, une administration et un éditeur de logiciel n’ont ni les mêmes environnements ni le même niveau de tolérance au risque.

La France et l’Europe disposent d’un écosystème logiciel dense, composé à la fois de grandes entreprises, d’éditeurs, de sociétés de services numériques, de laboratoires, de start-up et de communautés open source. Pour ces acteurs, l’arrivée de capacités agentiques plus banalisées peut accélérer l’expérimentation, notamment dans les équipes qui doivent maintenir des bases de code anciennes ou faire face à une forte demande de livraison. Mais elle peut aussi renforcer la dépendance à des plateformes d’IA conçues et opérées hors d’Europe, ce qui rend les questions de souveraineté, de localisation des données et de maîtrise des usages particulièrement sensibles.

Le marché francophone n’est pas homogène. Certaines équipes travaillent principalement en anglais et dans des écosystèmes techniques mondialisés ; d’autres ont besoin d’outils adaptés à des documentations, règles métier et échanges internes en français. La programmation elle-même repose majoritairement sur des langages et bibliothèques internationaux, mais les demandes adressées aux agents peuvent contenir des spécifications métiers locales. Plus les outils reçoivent du contexte, plus la politique de traitement de ce contexte devient importante pour les organisations.

La montée des agents pourrait également modifier les critères de recrutement et de formation. La capacité à écrire du code reste essentielle, mais savoir évaluer une proposition automatisée, décomposer une tâche, rédiger des contraintes et organiser une revue peut devenir encore plus déterminant. Les équipes ne chercheront pas uniquement des personnes capables d’utiliser un agent, car cette compétence peut rapidement devenir commune. Elles auront besoin de personnes capables de décider quand l’agent doit être utilisé, ce qu’il doit faire et comment démontrer que son travail est fiable.

Vers une normalisation de l’agent, sous condition de supervision

Le passage au mode auto par défaut dans Claude Code constitue un indicateur de maturité pour le segment des agents de programmation. Anthropic considère manifestement que l’autonomie doit être suffisamment centrale pour ne plus rester cachée derrière une option. Cette évolution ne signifie pas que la phase d’expérimentation est terminée. Elle montre plutôt que les éditeurs cherchent désormais à installer les comportements agentiques dans les usages ordinaires, avant même que toutes les organisations aient stabilisé leurs propres règles de supervision.

À long terme, l’enjeu sera moins de déterminer si les développeurs utilisent une IA que de savoir quelle part du cycle logiciel peut lui être confiée de manière vérifiable. Les tâches les plus faciles à déléguer seront vraisemblablement celles dont le périmètre est clair, les résultats testables et les conséquences limitées. À l’inverse, les décisions architecturales, les changements touchant à la sécurité, les règles métier ou les systèmes critiques resteront des zones où le jugement humain doit conserver une place explicite.

Les organisations qui tireront le meilleur parti de cette évolution ne seront pas nécessairement celles qui activent le plus vite toutes les fonctions d’autonomie. Ce seront celles qui articulent l’usage des agents avec des processus de développement solides : exigences claires, droits d’accès maîtrisés, tests pertinents, revues proportionnées au risque et capacité à retracer les changements. L’agent peut réduire la charge d’exécution ; il ne peut pas absorber à lui seul la responsabilité de gouverner un système logiciel.

Pour Anthropic, le défi sera de démontrer que Claude Code peut conserver l’utilité qui justifie le mode auto tout en restant compatible avec les attentes d’équipes très différentes. Un développeur indépendant peut privilégier la rapidité d’itération. Une entreprise réglementée ou une administration peut demander davantage de visibilité et de contrôle. Le succès d’un réglage par défaut ne se mesurera donc pas seulement à son adoption, mais à la confiance qu’il permet de construire dans des environnements où chaque changement de code compte.

Le mouvement engagé par Claude Code reflète enfin une transformation plus profonde de la relation entre humains et logiciels. Pendant des décennies, les outils de développement ont surtout rendu les programmeurs plus rapides dans l’écriture d’instructions. Les agents ambitionnent de participer à l’exécution même du travail intellectuel de programmation, en reliant une demande, un contexte et une suite d’actions. En choisissant de banaliser ce fonctionnement par défaut, Anthropic place la supervision, la revue et la responsabilité au cœur de la prochaine étape de l’industrialisation de l’IA dans le logiciel.