Le mythe du développeur augmenté par l’IA - Partie 1

Le mythe du développeur augmenté par l’IA - Part 1

Le vieux monde se meurt, le nouveau monde tarde à apparaître et dans ce clair-obscur surgissent les monstres

Cahiers de prison (1983) de Antonio Gramsci

Aujourd’hui, dans le monde du développement logiciel, l’IA générative suscite de nombreux fantasmes.

Le plus répandu est sans doute l’idée que coder ne servirait bientôt plus à rien, puisque l’IA pourrait s’en charger à notre place.

Dans ce contexte, il n’est pas rare de voir circuler des billets annonçant la fin du TDD, du Clean Code ou encore des principes SOLID.

Pourtant, la véritable question n’est peut-être pas de savoir pourquoi ces pratiques disparaîtraient, mais plutôt de comprendre pourquoi elles demeurent — aujourd’hui plus que jamais — indispensables et voici pourquoi.

Le développement logiciel traverse aujourd’hui une transformation profonde. L’irruption de l’IA générative dans les outils du quotidien — assistants de code, génération automatique de tests, d'exploration de solutions — agit comme un véritable tsunami qui rebat les cartes de nos pratiques.

Dans ce contexte, une tension intéressante apparaît : la rencontre de deux formes d’expertise. D’un côté, l’expérience des développeurs qui ont construit leur savoir au fil des architectures, des frameworks et des cycles technologiques. De l’autre, la fraîcheur du développeur junior, qui avec un regard plus récent, moins attaché aux habitudes, qui explore ces nouveaux outils avec une grande fluidité.

Deux générations, deux ambiances… mais un même terrain d’expérimentation : l’usage de l’IA générative dans le développement logiciel.

Si vous avez manqué l’article Le développement logiciel à l’ère des agents IA, je vous invite à le lire avant de poursuivre.

De quoi parle-t-on ?

Dans un monde où l’IA générative s’invite de plus en plus dans le quotidien des équipes, il devient nécessaire de replacer l’humain au cœur de la réflexion.

Comme tout phénomène émergent, les premiers récits qui accompagnent l’IA sont souvent empreints de fantasmes. Certains imaginent déjà quelques développeurs pilotant une armée d’agents capables de livrer en quelques jours ce qu’une équipe entière mettrait plusieurs mois à produire, sans jamais toucher au code.

Pour le management IT, cette évolution soulève de nombreuses questions : comment adopter ces outils, et surtout comment en tirer réellement parti ?

Mais la question dépasse largement celle de l’outillage.

Elle interroge :

• l’organisation des équipes,
• la répartition des compétences,
• et la manière dont le logiciel est conçu, compris et maintenu dans le temps.
  

Les outils d’IA sont aujourd’hui capables de produire rapidement du code fonctionnel, de suggérer des implémentations ou encore de générer des tests. Cette capacité modifie profondément l’acte de programmer.

Pourtant, si ces outils facilitent la production de code, ils peuvent aussi court-circuiter une étape essentielle du développement : l’apprentissage par l’effort, l’exploration et la compréhension progressive des problèmes.

Apprendre à programmer ne consiste pas seulement à obtenir une solution fonctionnelle. C’est aussi développer des modèles mentaux, comprendre pourquoi certaines approches fonctionnent mieux que d’autres et acquérir progressivement une intuition technique.

Cette intuition se construit par la pratique :

• écrire du code,
• se tromper,
• corriger,
• refactoriser,
• expérimenter différentes solutions.
  

La formation académique d’un ingénieur informatique est exigeante. Les sciences informatiques couvrent un domaine vaste et complexe qui requiert des années d’apprentissage et de pratique.

Avec l’expérience, on comprend que cet apprentissage ne s’achève jamais réellement. Cet aspect est essentiel, car sans un engagement fort, cet apprentissage continu peut devenir éprouvant.

Le métier d’ingénieur logiciel demande donc une certaine forme de passion : elle permet de maintenir l’envie d’apprendre et d’accueillir les nouveautés non pas comme des contraintes, mais comme des évolutions nécessaires auxquelles il faut savoir s’adapter.

L’apprentissage se concrétise au travers des projets, là où la théorie se confronte aux réalités du terrain. C’est dans cette confrontation que les développeurs affinent leur jugement et apprennent à choisir des solutions non seulement pour leurs qualités techniques, mais surtout en fonction du problème métier qu’elles doivent résoudre.

Dans ce contexte, l’essor du développement assisté par l’IA introduit un nouveau défi. Il devient nécessaire d’organiser délibérément son rythme afin d’en exploiter les bénéfices tout en préservant un mode de travail soutenable.

Cela implique également de réajuster certaines attentes managériales, notamment en matière de délais et de productivité.

C’est donc avec discernement et lucidité qu’il faut aborder l’illusion du développeur augmenté.

Un développeur augmenté n’est pas celui qui écrit moins de code, mais celui qui comprend mieux celui que l’IA produit.

Les développeurs seniors

Pour les profils seniors, qui ont passé de nombreuses années à développer sans l’assistance d’agents d’IA, la relation directe avec le code est généralement bien ancrée. Par ailleurs, leur engagement dans le métier nourrit une curiosité intellectuelle qui facilite l’appropriation des nouveautés, souvent sans effort excessif.

Un développeur ou une développeuse sénior ne doit pas perdre ses compétences de développement

L’impacte du Test-Driven Development sur les développeurs

Les plus professionnels, les plus performants ont également exploré les pratiques issues du Software Craftsmanship : Test-Driven Development, refactoring continu, travail sur du code legacy comme sur des projets greenfield. Cette pratique régulière leur confère progressivement une véritable dextérité. Une base de code ne se présente plus comme un ensemble figé de contraintes, mais comme un espace où l’expressivité d’un design propre peut émerger naturellement.

Emergent Design

On parle ici de design émergent : grâce aux cycles de TDD, le développeur identifie progressivement des liens entre les éléments du code, ce qui fait apparaître des patterns techniques. Ces derniers permettent de faire évoluer une base de code spécifique, sans design au départ, vers une base plus générique, avec un design explicite qui met en lumière l’intention métier.

Vers un code qui révèle le métier

Avec le temps, le code devient une matière malléable. Les réflexes acquis permettent de penser au métier tout en façonnant le code pour le rendre clair, lisible et expressif. L’attention ne se porte plus uniquement sur la mécanique technique, mais sur la manière dont le code peut révéler l’intention du système.

Pour les praticiens du Domain-Driven Design, cette valeur métier se révèle pleinement lorsque les patterns du Supple Design sont maîtrisés. Le code devient alors une forme de narration du domaine : il raconte l’histoire du métier et peut être compris bien au-delà du cercle des développeurs.

Contraste avec les attentes de l’IA

Dans ce contexte, l’arrivée de l’IA générative est souvent abordée avec une certaine distance critique.

Le code généré peut être comparé aux représentations mentales construites au fil des années d’expérience. Les développeurs seniors disposent d’un vécu suffisant pour conserver une vision d’ensemble du système et piloter l’IA avec discernement.

De nombreux seniors constatent d’ailleurs que les agents ont tendance à produire beaucoup plus de code que nécessaire au regard du contexte initial (je reviendrai sur ce point dans une seconde partie).

Ils peuvent alors ajuster leurs prompts, retravailler les propositions générées et les rapprocher de l’intention de conception qu’ils ont en tête.

Dans cette configuration, ce sont les développeurs qui pilotent les agents, et non l’inverse.

L’art de formuler son contexte, ancré dans le métier et illustré par des exemples concrets, permet de cadrer le besoin, à la manière d’une user story, tout en orientant le design et les choix d’architecture.

Mais cette compétence ne se limite pas à savoir écrire de bons prompts. Elle implique un ensemble plus large de pratiques permettant d’interagir efficacement avec les LLM. Il s’agit donc d’un véritable apprentissage, une nouvelle compétence qui se développe et s’affine avec le temps.

Passer les tests au vert n’est qu’un moyen, pas une finalité. L’objectif principal reste la production d’un code juste, compréhensible et de qualité. La maîtrise applicative ne se limite pas à produire rapidement des fonctionnalités : elle repose aussi sur la capacité à les maintenir et à les faire évoluer, indépendamment des outils utilisés, y compris l’IA.

Ainsi, évaluer une pull request suppose d’aller au-delà du simple fonctionnement : il faut aussi examiner la qualité intrinsèque du code, sa lisibilité, sa concision et la clarté de son design.

Coder proprement reste une discipline exigeante.

Comme toute pratique technique, elle demande un entraînement régulier. Rester au contact du code est indispensable pour entretenir les réflexes et continuer à développer de nouveaux automatismes.

À défaut, les développeurs seniors courent un risque paradoxal : commenter des pratiques qu’ils ne seraient plus réellement en mesure de mettre en œuvre.

À force d’en parler, certaines pratiques finissent par ne plus être pratiquées.

Sans regard critique, l’IA n’augmente pas les développeurs : elle amplifie leurs faiblesses.

Les développeurs juniors

Pour les développeurs juniors, dont les connaissances sont encore en construction, l’arrivée de l’IA générative peut profondément bouleverser les conditions d’apprentissage. Des notions à peine acquises risquent d’être rapidement contournées par l’assistance d’un ou plusieurs agents.

Les nouvelles générations ne conçoivent plus le travail comme un engagement linéaire, mais comme un espace d’exploration.

Elles recherchent avant tout un équilibre entre vie professionnelle et personnelle, en plaçant le plaisir, la diversité et l’épanouissement au cœur de leurs choix.

Fini les parcours tracés d’avance : elles privilégient des missions variées, refusent la monotonie et remettent en question l’idée même de s’enfermer durablement dans un seul domaine pour monter en expertise.

Dans ce contexte, l’IA générative n’est pas une rupture, mais une évidence. Elle s’inscrit parfaitement dans ces nouveaux usages : apprendre vite, produire rapidement, changer de sujet sans friction. Elle incarne une nouvelle manière de travailler, plus agile, plus immédiate, en phase avec les attentes d’une génération qui valorise la polyvalence autant que la liberté.

Cependant, ce vernis de simplicité dissimule une complexité bien réelle. Derrière la facilité apparente, les exigences fondamentales demeurent : sur une application professionnelle destinée à durer, apprendre à coder proprement n’est pas une option, mais une nécessité.

Le ou la développeuse junior face l’adversité de la sphère du développement

Apprendre à programmer ne consiste pas seulement à produire du code fonctionnel. C’est aussi :

• expérimenter,
• tâtonner,
• se confronter longuement à un problème,
• comprendre pourquoi une solution finit par émerger.
  

Cette confrontation directe avec le code constitue une composante essentielle de l’apprentissage.

Spectateurs du code généré

Si tout est médié par l’IA, une partie importante de cette expérience risque de disparaître. Dans de nombreux cas, les développeurs juniors deviennent alors spectateurs du code généré. Ils observent des solutions qu’ils n’auraient pas encore imaginées ni implémentées eux-mêmes. L’admiration face à cette puissance peut rapidement se transformer en dépendance.

Le phénomène n’est d’ailleurs pas entièrement nouveau. Bien avant l’IA, on dénonçait déjà le syndrome du « copier-coller Stack Overflow » : reprendre une solution trouvée en ligne sans en comprendre réellement les mécanismes. L’IA générative peut amplifier ce travers si elle est utilisée sans recul.

Produire du code via l’IA sans validation ni revue

Dans ces conditions, comment s’assurer qu’un développeur junior ne valide pas trop rapidement du code, ou pire, adapte une solution inadaptée au problème métier ? C’est bien là tout le nœud du problème. Recourir à l’IA sans intention précise ni regard critique sur le résultat relève souvent d’une forme de paresse intellectuelle.

Sans exigence dans la formulation du problème ni dans l’évaluation de la solution produite, l’IA ne fera qu’amplifier des raisonnements fragiles plutôt que produire de bons logiciels.

Si l’IA écrit tout le code, le risque est simple : transformer les développeurs en spectateurs de leur propre métier.

La curiosité est la clef d’une meilleure compréhension

Pour devenir un développeur passionné, il ne suffit pas d’apprendre à programmer.

La curiosité est essentielle : c’est elle qui pousse à comprendre comment les choses fonctionnent et à découvrir comment en tirer le meilleur parti.

La vague de l’IA générative ne constitue pas simplement une nouvelle technologie. Elle transforme les organisations à tous les niveaux. Il devient donc important que chacun comprenne les enjeux et la manière dont il peut en tirer parti dans son propre travail.

C’est précisément cette curiosité qui permettra aux développeurs juniors de ne pas subir l’IA générative, mais au contraire d’apprendre à la diriger et à l’utiliser de manière éclairée.

Au fond, la compétence d’un développeur ne se télécharge pas : elle se construit au contact du code.

Conclusion

L’IA ne supprime pas les exigences du développement logiciel ; elle les rend plus visibles encore. Ni les développeurs seniors ni les juniors ne peuvent se contenter de produire plus vite : ils doivent surtout comprendre, questionner et maîtriser le code généré.

L’enjeu n’est donc pas de déléguer le développement à l’IA, mais d’apprendre à l’utiliser sans renoncer à ce qui fait la qualité d’un logiciel : la clarté, la maintenabilité et l’intelligence du design.

Au fond, un développeur augmenté n’est pas celui qui laisse l’IA coder à sa place, mais celui qui reste capable de donner du sens au code, avec ou sans elle.