Salut à tous,
Avec la montée en puissance des agents IA, on entend souvent la même affirmation : « L'IA va remplacer les développeurs ».
De mon côté, je pense que cette affirmation mélange deux réalités assez différentes :
Produire du code à partir d'une instruction.
Concevoir, construire et maintenir un produit fiable, sécurisé et aligné avec un objectif métier.
Les agents IA ont considérablement progressé sur le premier point. Ils sont désormais capables d'explorer un dépôt, de modifier plusieurs fichiers, d'exécuter des commandes, de lancer des tests et même de préparer des pull requests avec relativement peu d'intervention humaine. Mais sur le second point, le métier ne disparaît pas. Il évolue.
La valeur du développeur se déplace progressivement de la production de code vers la compréhension, la conception et la maîtrise du produit dans son ensemble.
Des outils comme Claude Code, Codex, Cursor ou Goose permettent désormais d'automatiser une bonne partie du travail technique.
Concrètement, un agent peut :
Explorer une base de code et identifier les relations entre ses composants.
Analyser une architecture et repérer des incohérences.
Développer des fonctionnalités, des API, des composants et des scripts.
Effectuer des refactorisations sur plusieurs fichiers.
Générer des tests unitaires, d'intégration et fonctionnels.
Exécuter des commandes, analyser les erreurs et tenter de les corriger.
Interagir avec Git, préparer des commits et créer des pull requests.
Consulter de la documentation et utiliser des outils externes via des connecteurs ou MCP.
La différence avec les assistants de génération de code classiques est importante : on ne demande plus uniquement une fonction ou un morceau de code, on délègue une tâche comprenant plusieurs opérations successives.
L'agent peut planifier, exécuter, observer le résultat et ajuster son approche. C'est une évolution majeure du workflow de développement. Mais il ne faut pas confondre autonomie d'exécution et maîtrise technique.
La génération de code n'a jamais représenté l'intégralité du travail d'un développeur expérimenté.
Dans un projet réel, les difficultés apparaissent souvent bien avant ou bien après l'écriture du code :
Cadrage fonctionnel : comprendre ce que l'utilisateur cherche réellement à résoudre, même lorsque son besoin initial est mal formulé.
Architecture : sélectionner une solution adaptée aux contraintes actuelles et à l'évolution du produit.
Cohérence technique : respecter les conventions, les dépendances et les mécanismes déjà présents.
Sécurité : anticiper les problèmes d'autorisation, les injections et les fuites de données.
Performance : identifier les véritables goulots d'étranglement plutôt que d'optimiser arbitrairement.
Maintenance : éviter d'introduire une complexité supplémentaire pour résoudre un problème ponctuel.
Responsabilité : déterminer si une modification est suffisamment fiable pour être déployée.
Il faut néanmoins nuancer : les agents peuvent aujourd'hui proposer des architectures, comparer des solutions, identifier des risques et prendre certaines décisions techniques.
Le problème n'est donc pas leur incapacité à décider. C'est plutôt qu'ils ne disposent pas nécessairement de tout le contexte, ne maîtrisent pas toujours les conséquences de leurs choix et ne portent pas la responsabilité du produit livré.
Un agent peut proposer une solution techniquement élégante qui répond parfaitement à une mauvaise interprétation du besoin.
Dans un projet réel, cela peut entraîner des semaines de travail inutiles, une dette technique supplémentaire ou des problèmes difficiles à corriger.
À mon sens, la valeur du développeur expérimenté repose désormais sur cinq compétences complémentaires :
Cadrer : transformer un besoin imprécis en objectifs, contraintes et critères d'acceptation vérifiables.
Concevoir : définir une architecture cohérente, adaptée à l'existant et aux besoins futurs.
Arbitrer : choisir entre rapidité, coût, sécurité, performance et maintenabilité.
Superviser : orienter les agents, vérifier leurs résultats et détecter les erreurs.
Assumer : valider les modifications, organiser leur livraison et garantir la continuité du produit.
Cela ne signifie pas que le développeur doit systématiquement écrire chaque ligne lui-même.
Au contraire, il peut déléguer une quantité croissante de travail technique, à condition de conserver la maîtrise des décisions importantes.
L'IA accélère l'exécution et élargit les possibilités. Le développeur reste le garant de la cohérence et de la fiabilité du produit.
Voici une approche que je trouve beaucoup plus saine que de demander à un agent de développer une application entière en une seule instruction.
Évitez de commencer directement par :
L'agent risque de partir sur des hypothèses qui ne correspondent pas à vos besoins.
Donnez-lui plutôt un contexte exploitable :
Contraintes :
- RGPD et protection des données personnelles.
- Intégration Stripe.
- Emails transactionnels.
- Interface mobile-first.
- Gestion des disponibilités en temps réel.
Livrable attendu :
- Analyse fonctionnelle.
- Modèle de données.
- Architecture proposée.
- Parcours utilisateurs.
- Risques techniques et métier.
- Hypothèses à valider.
Ne commence pas à coder avant d'avoir présenté ton analyse.
Le contexte permet à l'agent de raisonner sur le véritable problème au lieu de simplement produire une implémentation plausible.
Avant de lui laisser modifier le dépôt, demandez-lui de comparer les différentes possibilités.
Présente :
1. Les hypothèses qui nécessitent une validation.
2. Les solutions techniques envisageables.
3. Les avantages et inconvénients de chaque solution.
4. Les impacts sur l'architecture existante.
5. Les risques de sécurité, de performance et de maintenance.
6. Les dépendances éventuellement nécessaires.
7. Un plan d'implémentation découpé en étapes.
Ne modifie aucun fichier pour le moment.
Cette étape est particulièrement intéressante sur un projet existant.
Un agent qui comprend mal l'architecture peut facilement multiplier les abstractions, ajouter des dépendances inutiles ou réimplémenter des fonctionnalités déjà présentes.
Évitez les demandes gigantesques du type :
Préférez une progression contrôlée :
Modèle de données, migrations et contraintes.
API, validation et logique métier.
Interface et parcours utilisateur.
Tests unitaires, intégration et cas limites.
Documentation et revue technique.
Validation globale et préparation du déploiement.
À chaque étape, demandez un compte rendu des fichiers modifiés, des choix effectués, des tests exécutés et des éventuels problèmes rencontrés.
L'intérêt est double : limiter les effets de bord et pouvoir revenir sur une décision sans devoir reprendre toute l'application.
Un test qui vérifie simplement qu'une page s'affiche ou qu'une API retourne un code HTTP 200 ne suffit pas.
Les tests doivent couvrir les scénarios qui représentent un véritable risque métier.
Par exemple, pour notre plateforme de réservation :
Un paiement ne doit pas pouvoir être traité deux fois à la suite d'un retry.
Deux utilisateurs ne doivent pas pouvoir réserver simultanément le même créneau.
Un utilisateur ne doit jamais accéder aux données d'un autre compte.
Un échec de paiement ne doit pas créer une réservation confirmée.
Un webhook reçu plusieurs fois doit être traité de manière idempotente.
Une réservation annulée doit correctement libérer son créneau.
Une entrée invalide ne doit pas pouvoir corrompre les données.
Il faut également distinguer les tests écrits par l'agent de leur validation.
Un agent peut générer un test qui reproduit exactement son erreur de raisonnement et qui passe malgré un comportement incorrect.
Il est donc important de vérifier les assertions et de confronter les résultats à des scénarios définis indépendamment de l'implémentation.
C'est un point souvent oublié lorsqu'on parle des agents de développement.
Un agent capable d'exécuter des commandes et de modifier un dépôt dispose potentiellement d'un accès important à l'environnement de travail.
Selon sa configuration, il peut également accéder à des fichiers sensibles, à des variables d'environnement, à des services externes ou à des outils de déploiement.
Quelques précautions :
Limiter les permissions au strict nécessaire.
Éviter de rendre accessibles les secrets et les clés API.
Utiliser un environnement isolé ou un sandbox lorsque c'est possible.
Contrôler les commandes exécutées et les dépendances ajoutées.
Ne pas autoriser automatiquement les déploiements en production.
Se méfier des instructions malveillantes présentes dans les fichiers, issues ou documentations externes consultés par l'agent (prompt injection).
L'autonomie doit être proportionnelle au niveau de risque.
On peut laisser un agent explorer un dépôt et lancer des tests avec relativement peu de contraintes. Lui donner un accès direct à la production ou aux données sensibles est une tout autre décision.
Une pull request générée par un agent ne doit pas être fusionnée simplement parce que les tests passent.
Il faut au minimum examiner :
La logique métier et le respect du besoin initial.
Les permissions, les contrôles d'accès et la sécurité.
Les cas limites et les scénarios d'erreur.
Les performances et les requêtes SQL.
La gestion des transactions et de la concurrence.
Les dépendances et leur maintenance.
La compatibilité avec l'existant.
La documentation et les éventuelles migrations.
La complexité et la dette technique introduites.
Il est également important de vérifier que les tests ont réellement été exécutés dans un environnement représentatif, et pas seulement générés ou déclarés comme réussis par l'agent.
Enfin, les modifications sensibles doivent être accompagnées de mécanismes de surveillance, de sauvegarde et de retour arrière adaptés.
Une PR peut être techniquement correcte tout en étant inadaptée au contexte du projet.
Il est intéressant de dépasser les impressions personnelles et de regarder ce qui se passe réellement dans les dépôts open source.
Une étude intitulée « On the Use of Agentic Coding: An Empirical Study of Pull Requests on GitHub », publiée dans ACM Transactions on Software Engineering and Methodology en 2025, a analysé 567 pull requests générées avec Claude Code sur 157 projets open source.
Quelques résultats :
83,8 % des PR générées par Claude Code ont finalement été fusionnées.
Le taux de fusion des PR humaines comparées dans l'étude atteignait 91 %.
Parmi les PR des agents fusionnées, 54,9 % l'ont été sans modification supplémentaire.
Les 45,1 % restantes ont nécessité des modifications humaines.
Ces corrections concernaient notamment les bugs, la documentation, le refactoring et le respect des conventions propres aux projets.
Il faut toutefois préciser que cette étude porte sur un échantillon de projets open source et de contributions explicitement identifiées comme générées avec Claude Code. Elle ne permet donc pas de généraliser directement ces résultats à tous les agents, toutes les entreprises ou tous les types de développement.
Mais elle donne une indication intéressante : les agents produisent déjà des contributions largement exploitables, sans pour autant supprimer le travail de validation et d'intégration.
Étude : On the Use of Agentic Coding: An Empirical Study of Pull Requests on GitHub
Une autre étude publiée en octobre 2026 dans les actes du symposium ESEM 2026, intitulée « Does Working with AI Agents Change How Developers Code, Test, and Review? », s'est intéressée à 669 développeurs répartis sur 103 dépôts.
Les chercheurs ont notamment observé :
Une augmentation de 76,8 % de la longueur des descriptions de pull requests après l'adoption des agents.
Une amélioration de plusieurs indicateurs liés aux pratiques de test.
Aucune diminution observée de l'effort de programmation.
L'étude précise également que certains changements dans les pratiques de revue de code étaient observés dans les groupes témoins et ne pouvaient donc pas être attribués directement à l'adoption des agents.
C'est intéressant, car cela nuance l'idée selon laquelle l'utilisation des agents conduirait nécessairement les développeurs à moins travailler ou à moins tester.
Elle suggère plutôt que les pratiques évoluent : davantage de documentation et une attention accrue aux tests, sans disparition du travail d'ingénierie.
Étude : Does Working with AI Agents Change How Developers Code, Test, and Review?
Erreur 1 : demander du code avant de définir le problème. Résultat : une solution techniquement cohérente, mais qui ne répond pas nécessairement au besoin.
Erreur 2 : laisser l'agent décider seul de toute l'architecture. Résultat : une application qui fonctionne en démonstration, mais dont les choix techniques peuvent devenir difficiles à maintenir.
Erreur 3 : accepter une PR sans comprendre les modifications. Résultat : une dépendance excessive à l'agent et une perte progressive de maîtrise du produit.
Erreur 4 : confondre tests réussis et absence de bugs. Résultat : une confiance injustifiée dans une couverture de tests parfois superficielle ou incomplète.
Erreur 5 : donner trop de permissions à l'agent. Résultat : une surface d'attaque supplémentaire et des conséquences potentiellement importantes en cas de mauvaise instruction ou d'action involontaire.
Erreur 6 : ne pas documenter les décisions. Résultat : quelques mois plus tard, les développeurs et les futurs agents ne savent plus pourquoi telle architecture, telle dépendance ou telle contrainte a été choisie.
Je ne pense pas que les développeurs vont disparaître.
En revanche, je pense que certains profils vont être beaucoup plus exposés que d'autres.
Le développeur qui se limite à exécuter des tâches très découpées, sans comprendre le produit, sans vision d'ensemble et sans capacité à évaluer la qualité de son travail, risque de voir une partie importante de sa valeur automatisée.
À l'inverse, les compétences qui permettent de transformer un besoin en produit fiable deviennent particulièrement importantes :
Comprendre les besoins métier et les utilisateurs.
Maîtriser les architectures et les systèmes existants.
Identifier les risques et anticiper les problèmes.
Concevoir des solutions cohérentes et évolutives.
Savoir utiliser et superviser plusieurs agents.
Vérifier les résultats avec des méthodes indépendantes.
Assurer la sécurité, la maintenance et la fiabilité du produit.
Il faut aussi accepter que les frontières entre les métiers évoluent. Un développeur expérimenté peut désormais consacrer davantage de temps à l'analyse, à l'audit, à l'automatisation, à la conception et à la supervision de systèmes complexes. La production de code devient progressivement une partie moins différenciante du métier.
La capacité à savoir quoi construire, comment le construire et comment garantir que cela fonctionne réellement devient d'autant plus importante.
L'IA ne supprime pas le besoin d'ingénierie. Elle change profondément la manière de l'exercer.
Comment intégrez-vous les agents IA dans vos projets ?
Je serais particulièrement intéressé par vos retours d'expérience concrets avec Claude Code, Codex, Cursor, Goose et les autres workflows agentiques.
En ligne
De très bon conseils effectivement, merci
Sur la partie sécurité "les injections et les fuites de données", je trouve qu'on obtient de très bon résultats à condition d'avoir un agent dédié pour ca.
Je ne pense pas non plus que les développeurs vont disparaitre, par contre les débutants et les mauvais dev ca va être plus dur pour eux. L'IA est puissante dans les mains de personnes expérimentés et qui connaissent le métier et c'est eux qui l'exploitent le mieux aujourd'hui, pour les autres c'est une très bonne source d'apprentissage donc ca va dépendre des efforts de chacun. Le métier mute c'est sur ... et c'est pas fini je pense
Hors ligne
Pages : 1
Accueil › Développement › Les agents IA codent très vite mais qui fait les choix décisifs ?
Haut