L’intelligence artificielle ne se contente plus d’autocompléter quelques lignes dans les éditeurs de code. Selon une nouvelle étude de BairesDev, 42 % des développeurs utilisent désormais l’IA pour produire au moins la moitié de leur code, contre seulement 12 % un an auparavant.
Cette progression spectaculaire ne signifie pourtant pas que les développeurs travaillent moins. L’IA ferait économiser environ 13 heures de programmation par semaine, mais ce temps est presque immédiatement réinvesti dans la vérification, le débogage et la correction du code généré. Une transformation qui déplace progressivement le métier de la production vers la supervision.
De 12 à 42 % en seulement un an
L’étude de BairesDev repose sur les réponses de 705 développeurs et 41 directeurs techniques, offrant un aperçu de la place prise par les assistants de programmation dans les entreprises. Le chiffre le plus spectaculaire concerne la proportion de code générée avec leur aide. En un an, la part des développeurs déclarant utiliser l’IA pour produire au moins 50 % de leur code est passée de 12 à 42 %.
L’adoption est encore plus importante lorsqu’on abaisse ce seuil. Selon les données de l’étude, 72 % des développeurs utilisent désormais l’intelligence artificielle pour produire au moins un quart de leur code.
Les ingénieurs ayant moins de cinq années d’expérience afficheraient une adoption légèrement supérieure, mais le phénomène dépasse largement les profils juniors. Les développeurs expérimentés utilisent eux aussi ces outils pour une part significative de leur travail. Le changement se remarque directement dans l’organisation de leurs journées. Seulement 21 % des personnes interrogées consacrent encore plus de la moitié de leur semaine à écrire entièrement du nouveau code à partir de zéro.
Autrement dit, écrire du code reste évidemment au cœur du métier, mais ce n’est plus nécessairement là que se concentre la majorité du temps.
L’IA ferait gagner 13 heures de programmation par semaine
Sur le papier, les gains de productivité sont considérables. Les développeurs interrogés estiment économiser environ 13 heures par semaine sur l’écriture de nouveau code grâce aux outils d’intelligence artificielle. Les assistants peuvent générer rapidement du code répétitif, proposer des implémentations, créer des tests ou fournir une première solution à un problème.
Mais, ces 13 heures ne se transforment pas en temps libre. Elles sont réinvesties dans d’autres étapes du cycle de développement, en particulier dans le contrôle de ce que les modèles viennent de produire. 67 % des développeurs déclarent passer davantage de temps à vérifier du code généré par l’IA qu’il y a un an, tandis que 52 % disent consacrer davantage de temps à corriger des erreurs directement introduites par ces systèmes.
Le paradoxe devient alors évident : l’IA accélère considérablement la génération, mais augmente simultanément le volume de code qu’un humain doit comprendre et valider.
La productivité ne peut donc plus être mesurée uniquement à la vitesse avec laquelle les lignes apparaissent dans l’éditeur. Un modèle peut produire en quelques secondes une quantité de code qui aurait demandé plusieurs heures à écrire manuellement. Si l’ingénieur doit ensuite passer une partie importante de ce temps à vérifier la logique, les dépendances, les cas limites ou les conséquences sur la sécurité, le gain réel devient beaucoup plus difficile à mesurer.
Le développeur écrit moins, mais doit vérifier davantage
Cette transformation commence à redéfinir les compétences attendues des ingénieurs logiciels. La valeur d’un développeur ne repose plus uniquement sur sa capacité à produire rapidement une implémentation. Elle dépend également de sa faculté à déterminer si une proposition générée automatiquement est réellement adaptée au système dans lequel elle doit fonctionner.
Le travail se déplace alors vers l’architecture, la validation, les cas limites et la compréhension globale du produit. Cette évolution est bien résumée par un ingénieur cité dans les analyses de l’étude : les développeurs « écrivent moins, mais réfléchissent davantage ».
La formule traduit assez bien le nouveau partage des tâches. L’IA peut prendre en charge une partie de la syntaxe et des implémentations standards, mais elle ne porte pas la responsabilité du logiciel livré.
Lorsqu’une vulnérabilité apparaît en production, qu’une fonctionnalité se comporte mal ou qu’une architecture devient impossible à maintenir, l’entreprise ne peut pas transférer cette responsabilité au modèle qui a proposé le code.
L’humain reste donc la dernière couche de contrôle. C’est également ce qui explique l’émergence progressive d’un nouveau rôle informel : celui de relecteur de code IA. Il ne s’agit pas seulement de détecter une erreur syntaxique, mais d’évaluer la pertinence d’une solution générée, son intégration dans une architecture existante et ses conséquences à plus long terme.
Les entreprises investissent davantage dans le contrôle qualité
Les directions techniques semblent avoir compris ce déplacement. Selon BairesDev, 78 % des CTO interrogés ont augmenté leurs dépenses consacrées à la revue, à l’assurance qualité et aux processus de validation. L’arrivée massive des assistants IA ne provoque donc pas nécessairement une réduction des équipes ou des budgets : elle déplace une partie des investissements.
Les entreprises doivent former leurs développeurs à utiliser efficacement les nouveaux outils, mais également renforcer leurs compétences en qualité logicielle, sécurité et ingénierie des données.
Cette évolution remet aussi en question certaines métriques historiques du développement. Compter les lignes de code devient encore moins pertinent lorsqu’une grande partie peut être produite automatiquement. Même le nombre de fonctionnalités terminées pendant un sprint ne raconte pas nécessairement toute l’histoire si leur validation demande ensuite davantage de travail.
Les organisations pourraient progressivement s’intéresser davantage au taux de défauts du code généré, au temps nécessaire pour transformer une suggestion en code réellement exploitable ou encore à la quantité de corrections nécessaires avant un déploiement.
La question centrale devient alors moins « combien de code l’IA produit-elle ? » que « combien de code fiable permet-elle réellement de livrer ? ».
La sécurité reste l’un des principaux points de vigilance
L’accélération de la génération soulève également un problème de sécurité. D’après l’étude, 38 % des développeurs déclarent avoir découvert au cours des 6 derniers mois des failles de sécurité pouvant être reliées à des suggestions générées par l’IA. Ce chiffre doit être interprété avec précaution : il repose sur les déclarations des personnes interrogées et ne signifie pas que 38 % de tout le code produit par IA est vulnérable. Il montre néanmoins que le problème est suffisamment fréquent pour devenir une composante concrète du travail quotidien.
Les organisations renforcent en conséquence leurs mécanismes de contrôle. Certaines font passer systématiquement le code généré par des outils d’analyse statique avant son intégration et imposent une validation humaine avant toute fusion avec les branches principales.
D’autres expérimentent des modèles privés ou des environnements limités aux dépôts approuvés par l’entreprise. Ces approches peuvent réduire certains risques liés à la confidentialité et au contexte du code, mais elles augmentent également les coûts d’infrastructure et de gouvernance.
L’enjeu devient particulièrement sensible dans les secteurs réglementés. L’étude observe d’ailleurs une adoption légèrement moins rapide en Amérique du Nord que dans certaines équipes européennes et latino-américaines, une différence qui pourrait notamment être liée aux contraintes de conformité rencontrées dans la finance ou la santé.
L’IA devient une infrastructure du développement, pas un remplaçant
Malgré la vitesse de cette transformation, les développeurs interrogés ne semblent pas considérer leur disparition comme imminente. Seulement 9 % des répondants pensent que l’intelligence artificielle supprimera le besoin de développeurs humains au cours des cinq prochaines années. La vision dominante est davantage celle d’une augmentation des capacités que d’un remplacement complet.
Les CTO semblent partager cette perspective puisque 84 % prévoient d’accroître leurs investissements dans les outils de développement assistés par IA au cours des douze prochains mois.
Les financements devraient notamment se concentrer sur une meilleure intégration aux environnements de développement, des modèles davantage spécialisés et des outils permettant à plusieurs ingénieurs de collaborer autour des propositions générées.
L’époque où l’assistant IA était simplement une extension expérimentale de l’éditeur semble donc déjà dépassée. Pour beaucoup d’équipes, il devient progressivement une couche permanente de la chaîne de développement, au même titre que les systèmes de gestion de versions, les pipelines d’intégration continue ou les outils automatisés de test.
Cette normalisation ne signifie toutefois pas que les agents autonomes sont prêts à remplacer des équipes entières. Les chiffres de BairesDev racontent presque l’histoire inverse : plus les modèles produisent du code, plus les organisations investissent dans les humains et les processus chargés de vérifier ce qu’ils produisent.
Le vrai gain de l’IA ne se mesurera pas en lignes de code
Le développement logiciel entre ainsi dans une phase plus mature de son adoption de l’intelligence artificielle. La première promesse était simple : écrire davantage de code, beaucoup plus rapidement. La réalité qui apparaît désormais est plus complexe. La génération accélère effectivement, mais elle déplace une partie du travail vers la compréhension, la vérification, la sécurité et l’intégration.
Les fameux 13 heures économisées chaque semaine illustrent parfaitement ce paradoxe. Elles existent, mais ne disparaissent pas de la journée du développeur. Elles changent simplement de destination.
Cela pourrait malgré tout représenter un progrès considérable si les ingénieurs consacrent davantage de temps aux décisions architecturales, aux besoins métier et à la qualité générale des produits plutôt qu’au code répétitif. Mais ce bénéfice dépendra directement de la capacité des modèles à réduire progressivement la quantité de corrections qu’ils imposent.
Le changement le plus profond n’est donc peut-être pas que l’IA écrit désormais une partie importante du logiciel. C’est que le métier de développeur commence à se déplacer de la production du code vers la responsabilité de décider quel code mérite réellement d’être conservé.
