De junior à senior à l'ère de l'IA : la bonne manière de progresser

Une conversation sur LinkedIn a récemment attiré mon attention. Quelqu'un demandait à une développeuse quel était son setup de codage avec l'IA.

"Aucun", a-t-elle répondu. "Je ne pense pas encore être au niveau où je peux laisser un modèle générer 1 000 lignes de code par itération, les relire et être sûre de ne pas introduire un gros désordre à grande échelle. Je l'utiliserai quand j'aurai plus d'expérience en développement logiciel."

Cette réponse a parlé à beaucoup de monde. "Il nous faut plus de développeurs comme elle et moins de AI slop", disaient-ils.

Je comprends l'inquiétude. Mais je pense que cela place la barre au mauvais endroit.

Le vrai problème n'est pas l'IA, c'est la manière dont on l'utilise

Soyons clairs : vous ne devez pas faire confiance à l'IA pour vous jeter 1 000 lignes de code. Nous sommes d'accord. Mais vous ne devriez pas non plus faire confiance à 1 000 lignes produites par un humain sans les comprendre.

Le problème n'est pas la source du code. Le problème, c'est d'accepter du code que vous ne comprenez pas.

Attendre d'être "assez expérimenté" pour utiliser l'IA me semble inversé. Utilisée correctement, l'IA est un outil pour devenir expérimenté, pas pour éviter le travail.

Le pattern qui fonctionne réellement

Le pattern utile n'est pas "générer beaucoup, livrer vite". C'est :

• Générer de petits morceaux : une seule fonction. Un composant. Quelques lignes.
• Les interroger : que fait ce code ? Pourquoi cette approche ?
• Demander pourquoi : pourquoi un Map plutôt qu'un objet ? Pourquoi ce pattern de gestion d'erreur ?
• Demander des réécritures : "Montre-moi cela sans opérateur ternaire." "Quelle est la version impérative ?"
• Demander des versions plus simples : la complexité est facile. La simplicité est difficile. Faites travailler l'IA dans ce sens.

L'IA peut expliquer du code, y compris du code écrit par des humains, mieux que la plupart des humains n'ont le temps de le faire. Cette base legacy que personne ne veut toucher ? L'IA vous l'expliquera ligne par ligne, patiemment, à deux heures du matin, sans soupirer.

Ce que font réellement les seniors

Voici ce qui distingue un développeur senior d'un junior :

• Les juniors écrivent du code. Les seniors savent quand ne pas le faire.
• Les juniors résolvent le problème devant eux. Les seniors se demandent si c'est le bon problème.
• Les juniors font confiance au code qui fonctionne. Les seniors demandent pourquoi il fonctionne et ce qui se passe lorsqu'il ne fonctionne plus.

Aucune de ces compétences n'exige que vous tapiez chaque caractère vous-même. Elles demandent du jugement. Et le jugement vient du fait de voir de nombreuses approches, de comprendre les compromis et de prendre des décisions.

L'IA accélère la partie "voir beaucoup d'approches". Le jugement reste à vous de le construire.

Le danger d'attendre d'être prêt

Il existe une version de la prudence qui devient une excuse. "J'utiliserai l'IA quand je serai senior" devient souvent "j'apprendrai Kubernetes quand j'aurai le temps" ou "j'écrirai des tests quand la base de code sera plus propre".

La vérité, c'est qu'on apprend en faisant, pas en attendant.

Les développeurs qui vont prospérer ne sont pas ceux qui évitent l'IA. Ce sont ceux qui développent une relation rigoureuse avec elle :

• remettre en question tout ce qu'elle produit
• comprendre avant de livrer
• l'utiliser pour explorer, pas pour éviter d'apprendre
• la traiter comme un assistant pédagogique, pas comme un oracle

Notre approche chez vensas

Chez vensas, nous croyons à l'apprentissage par la pratique. Nos fondateurs écrivent encore du code chaque jour. Nos formateurs sont des développeurs en activité, pas des théoriciens. Quand nous travaillons avec des équipes, à travers des code reviews, des formations ou du développement embarqué, nous nous concentrons sur la construction de la compréhension, pas seulement sur la livraison de fonctionnalités.

Cette philosophie s'étend à notre manière de penser l'IA :

Dans les code reviews, nous ne faisons pas qu'identifier des problèmes, nous expliquons le pourquoi. La même approche fonctionne avec le code généré par IA. Ne vous contentez pas de l'exécuter. Comprenez-le. Demandez-vous : est-ce que cela passerait une review ? Si non, pourquoi ?

Dans la formation, nous mettons l'accent sur le Clean Code, le refactoring et les tests. Ces compétences deviennent plus importantes avec l'IA, pas moins. Quand on peut générer du code rapidement, savoir reconnaître du bon code devient le facteur différenciant.

Dans le conseil en architecture, nous aidons les équipes à prendre des décisions technologiques qu'elles comprennent réellement. L'IA peut suggérer des patterns, mais savoir quel pattern convient à votre contexte exige un jugement qui ne vient que de la pratique et du mentorat.

Nous avons vu des développeurs juniors progresser plus vite lorsqu'ils utilisent l'IA comme accélérateur d'apprentissage, en lui demandant d'expliquer des concepts, de comparer des approches et de simplifier des solutions. Nous avons aussi vu des développeurs stagner lorsqu'ils l'utilisent comme une béquille, en générant du code qu'ils sont incapables de déboguer lorsqu'il casse.

L'outil n'est pas la variable. L'approche l'est.

Un défi pour les développeurs juniors

Si vous êtes au début de votre carrière, voici mon défi :

N'évitez pas l'IA. Ne lui faites pas aveuglément confiance non plus.

À la place :

• Générez 10 lignes, pas 1 000. Assez peu pour les comprendre vraiment.
• Demandez-lui d'expliquer. "Pourquoi as-tu utilisé de la récursion ici ?" "Quelle est la complexité temporelle ?"
• Demandez des alternatives. "Montre-moi une autre façon." "Quel est le compromis ?"
• Comparez avec du code de production. Qu'est-ce qui diffère de ce que votre équipe écrit ?
• Cassez le code. Donnez-lui des edge cases. Voyez où il échoue. C'est là que votre compréhension grandit.

Un défi pour les développeurs seniors

Si vous accompagnez d'autres développeurs, ne rejetez pas l'IA comme un raccourci pour paresseux. Aidez vos juniors à l'utiliser correctement :

• Relisez ensemble le code généré par IA. Faites-en un moment d'apprentissage.
• Demandez-leur d'expliquer ce que l'IA a produit. Comprendre vaut mieux qu'éviter.
• Montrez-leur comment interroger les suggestions. Donnez l'exemple du scepticisme.

Les juniors qui apprennent à travailler avec l'IA de manière réfléchie deviendront seniors plus vite. Ceux qui l'évitent complètement se retrouveront tôt ou tard face à une base de code remplie de code généré par IA, tout en étant moins préparés à la parcourir.

L'essentiel

Sa prudence n'est pas mauvaise. Faire confiance à l'IA pour des dumps de 1 000 lignes est une recette pour le désastre.

Mais la réponse n'est pas l'abstinence. C'est la discipline.

De petits morceaux. Des questions profondes. Une compréhension réelle.

C'est ainsi que les juniors deviennent seniors, avec ou sans IA. L'IA rend simplement les boucles d'itération plus rapides.

Chez vensas, nous aidons les développeurs à progresser à travers les code reviews, la formation et l'expérience sur de vrais projets. Que vous utilisiez l'IA ou non, les fondamentaux restent les mêmes : comprenez ce que vous construisez, remettez en question ce que vous livrez et n'arrêtez jamais d'apprendre.

L'ère de l'IA ne change pas ce qui fait un grand développeur. Elle augmente simplement l'importance d'y parvenir de manière délibérée.

Besoin d'aide ?

Vous voulez accélérer la montée en compétence de votre équipe tout en développant une vraie maîtrise de l'IA ? Nous proposons des programmes de formation centrés sur les fondamentaux, Clean Code, architecture, tests, qui deviennent encore plus critiques à l'ère de l'IA. Contactez-nous et discutons de la manière dont nous pouvons faire progresser vos développeurs.