L’intelligence artificielle générationnelle dans le domaine du génie logiciel a largement dépassé le simple autocomplétion. La nouvelle frontière est le codage agentique : des systèmes d’IA capables de planifier des changements, de les exécuter en plusieurs étapes et d’itérer en fonction des retours. Cependant, malgré l’excitation autour des « agents d’IA qui codent », la plupart des déploiements en entreprise sous-performent. Le facteur limitant n’est plus le modèle, mais le contexte : la structure, l’historique et l’intention entourant le code en cours de modification. En d’autres termes, les entreprises sont confrontées à un problème de conception de systèmes : elles n’ont pas encore conçu l’environnement dans lequel ces agents opèrent.
Le passage de l’assistance à l’agence
L’année écoulée a vu une évolution rapide des outils de codage assisté vers des flux de travail agentiques. La recherche a commencé à formaliser ce que signifie le comportement agentique en pratique : la capacité à raisonner à travers la conception, les tests, l’exécution et la validation plutôt que de générer des extraits isolés. Des travaux tels que le rééchantillonnage dynamique des actions montrent que permettre aux agents de bifurquer, de reconsidérer et de réviser leurs propres décisions améliore significativement les résultats dans de grands codebases interdépendants. Au niveau de la plateforme, des fournisseurs comme GitHub construisent désormais des environnements d’orchestration d’agents dédiés, tels que Copilot Agent et Agent HQ, pour soutenir la collaboration multi-agent à l’intérieur de véritables pipelines d’entreprise.
Cependant, les premiers résultats sur le terrain racontent une histoire de mise en garde. Lorsque les organisations introduisent des outils agentiques sans aborder les flux de travail et l’environnement, la productivité peut diminuer. Une étude de contrôle randomisée cette année a montré que les développeurs qui utilisaient une assistance IA dans des flux de travail inchangés accomplissaient les tâches plus lentement, en grande partie en raison de la vérification, de la refonte et de la confusion autour de l’intention. La leçon est simple : l’autonomie sans orchestration donne rarement lieu à l’efficacité.
Pourquoi l’ingénierie du contexte est la vraie clé
Dans chaque déploiement infructueux que j’ai observé, l’échec provenait du contexte. Lorsque les agents manquent d’une compréhension structurée d’une base de code, en particulier de ses modules pertinents, de son graphe de dépendance, de son harnais de test, de ses conventions architecturales et de son historique de changement. Ils génèrent souvent une sortie qui semble correcte mais qui est déconnectée de la réalité. Trop d’informations submergent l’agent ; trop peu le force à deviner. L’objectif n’est pas de nourrir le modèle avec plus de jetons. L’objectif est de déterminer ce qui devrait être visible pour l’agent, quand et sous quelle forme.
Les équipes qui voient des gains significatifs considèrent le contexte comme une surface d’ingénierie. Elles créent des outils pour prendre un instantané, compacter et versionner la mémoire de travail de l’agent : ce qui est persistant à travers les tours, ce qui est jeté, ce qui est résumé et ce qui est lié plutôt qu’inclus. Elles conçoivent des étapes de délibération plutôt que des sessions de rappel. Elles font de la spécification un artefact de première classe, quelque chose de revisible, de testable et de propriétaire, et non pas un historique de chat transitoire. Ce changement s’aligne sur une tendance plus large que certains chercheurs décrivent comme « les spécifications devenant la nouvelle source de vérité ».
Les workflows doivent évoluer avec les outils
Cependant, le contexte seul ne suffit pas. Les entreprises doivent réarchitecturer les workflows autour de ces agents. Comme l’a noté le rapport McKinsey 2025 « Une année d’IA agentique », les gains de productivité ne découlent pas de la superposition de l’IA sur des processus existants, mais de la refonte du processus lui-même. Lorsque les équipes se contentent de déposer un agent dans un flux de travail inchangé, elles invitent les frictions : les ingénieurs passent plus de temps à vérifier le code écrit par l’IA qu’ils n’en auraient mis à l’écrire eux-mêmes. Les agents ne peuvent qu’amplifier ce qui est déjà structuré : des bases de code bien testées, modulaires avec une propriété claire et une documentation. Sans ces fondations, l’autonomie devient chaos.
La sécurité et la gouvernance exigent également un changement de mentalité. Le code généré par l’IA introduit de nouvelles formes de risques : des dépendances non vérifiées, des violations de licence subtiles et des modules non documentés qui échappent à la revue par les pairs. Les équipes matures commencent à intégrer l’activité agentique directement dans leurs pipelines CI/CD, traitant les agents comme des contributeurs autonomes dont le travail doit passer par les mêmes portes d’analyse statique, de journalisation d’audit et d’approbation que tout développeur humain. La documentation de GitHub met en avant cette trajectoire, positionnant les agents Copilot non pas comme des remplaçants des ingénieurs, mais comme des participants orchestrés dans des flux de travail sécurisés et révisables. L’objectif n’est pas de laisser une IA « écrire tout », mais de s’assurer que lorsqu’elle agit, elle le fait à l’intérieur de balises définies.
Ce sur quoi les décideurs d’entreprise devraient se concentrer maintenant
Pour les leaders techniques, le chemin à suivre commence par la préparation plutôt que par l’enthousiasme. Les monolithes avec des tests sporadiques donnent rarement des gains nets ; les agents s’épanouissent là où les tests sont autoritaires et peuvent conduire à un affinement itératif. C’est exactement la boucle qu’Anthropic souligne pour les agents de codage. Les pilotes dans des domaines strictement définis (génération de tests, modernisation de l’héritage, refontes isolées) ; traiter chaque déploiement comme une expérience avec des métriques explicites (taux d’échec des défauts, temps de cycle des PR, taux d’échec des changements, réduction des résultats de sécurité). À mesure que votre utilisation augmente, traitez les agents comme une infrastructure de données : chaque plan, instantané de contexte, journal d’actions et exécution de test est une donnée qui se compose en une mémoire de recherche de l’intention d’ingénierie, et un avantage concurrentiel durable.
Sous le capot, le codage agentique est moins un problème d’outillage qu’un problème de données. Chaque instantané de contexte, itération de test et révision de code devient une forme de données structurées qui doivent être stockées, indexées et réutilisées. À mesure que ces agents prolifèrent, les entreprises se retrouveront à gérer une toute nouvelle couche de données : celle qui capture non seulement ce qui a été construit, mais comment cela a été réfléchi. Ce changement transforme les journaux d’ingénierie en un graphe de connaissance de l’intention, de la prise de décision et de la validation. Avec le temps, les organisations capables de rechercher et de rejouer cette mémoire contextuelle surpasseront celles qui considèrent encore le code comme un texte statique.
L’année à venir déterminera probablement si le codage agentique devient un pilier du développement en entreprise ou une autre promesse surfaite. La différence reposera sur l’ingénierie du contexte : comment les équipes conçoivent intelligemment le substrat informationnel sur lequel leurs agents s’appuient. Les gagnants seront ceux qui verront l’autonomie non comme de la magie, mais comme une extension de la conception disciplinée des systèmes : des flux de travail clairs, des retours mesurables et une gouvernance rigoureuse.
En conclusion, les plateformes convergent vers l’orchestration et les balises, et la recherche continue d’améliorer le contrôle du contexte au moment de l’inférence. Les gagnants au cours des 12 à 24 prochains mois ne seront pas les équipes avec le modèle le plus flashy ; ce seront celles qui conçoivent le contexte comme un atout et traitent le flux de travail comme le produit. Faites cela, et l’autonomie se multiplie. Sauter cette étape, et la file d’attente de révision s’ensuit.
Contexte + agent = levier. Sautez la première moitié, et le reste s’effondre.