Les compétences des développeurs seniors à l’ère de l’IA : mettre l’expérience au service de meilleurs résultats

• Au cours des derniers mois, l’auteur a expérimenté des outils de codage basés sur l’IA à la fois sur des projets personnels et dans son travail
• Les résultats ont été très positifs, avec à la clé une réduction du temps de développement et une amélioration de la qualité des livrables
• À l’inverse, certains développeurs ont aussi partagé des retours négatifs indiquant que les outils d’IA ne fonctionnaient pas bien dans leur cas
• Cette expérience l’a amené à être convaincu que le développement logiciel avec l’IA offre un potentiel de saut de productivité vers un nouveau palier
• Cela dit, il ne s’agit pas de l’adopter sans recul, mais d’avoir la bonne perspective et une approche équilibrée
• À travers cet article, il partage des bonnes pratiques tirées de son expérience directe afin de
  contribuer, même modestement, à une adoption plus avisée des outils d’IA dans la communauté des développeurs

État actuel de l’usage des outils de codage IA

• D’après ce qui est observé sur Twitter, les outils de codage IA sont très populaires chez les développeurs non spécialistes
  • Ils s’en servent pour se lancer dans de nouveaux projets et apprendre à développer de façon ludique
• Cette tendance est positive et contribue à abaisser la barrière d’entrée de la technologie pour de nouveaux publics
• Cependant, ce n’est qu’une facette du potentiel de ces outils et,
  • dans un contexte professionnel aussi, l’IA peut apporter une grande valeur, notamment pour les développeurs seniors

Les points forts des développeurs seniors

• Même si nous en sommes encore aux débuts de cette évolution, la conclusion actuelle est la suivante :
  • les développeurs seniors sont les mieux placés pour tirer le meilleur parti des outils d’IA
  • il ne s’agit pas seulement d’obtenir de l’aide, mais bien d’en faire un usage optimisé
• L’idée centrale est la suivante :

  L’expérience de développement et le savoir-faire en conduite de projet, qui peuvent sembler un peu dépassés à l’ère de l’IA,
  constituent précisément la base qui permet de tirer le meilleur parti de ces outils

• Si l’on compare un agent de programmation basé sur un LLM,
  • il ressemble à un senior doté de vastes connaissances en programmation, mais à un junior qui manque de compréhension de la conception dans le contexte courant
• Pour leur confier un travail concret,
  • une préparation stratégique et un guidage sont indispensables
  • et la personne la plus à même d’assumer ce rôle est précisément le développeur senior
• En conclusion, même des outils d’IA de pointe ne sont véritablement exploités au mieux que lorsqu’ils s’appuient sur les pratiques et l’expérience traditionnelles du développement

Trois éléments clés pour réussir une session de codage avec l’IA

• Pour obtenir de bons résultats en collaborant avec l’IA, trois éléments sont essentiels :
  • une documentation des exigences rigoureuse (Well-structured Requirements)
  • des garde-fous de qualité basés sur les outils (Tool-based Guard Rails)
  • la technique des keyframes basés sur les fichiers (File-based Keyframing)
• Avant d’entrer dans les détails, l’auteur présente des cas concrets de projets réalisés avec l’IA
  • Projet greenfield : un projet créé entièrement à partir de zéro
  • Projet brownfield : un projet qui ajoute de nouvelles fonctionnalités à une base de code existante
• Dans les deux cas, l’accent est mis sur des exemples où l’IA a pris en charge presque toute l’implémentation
  • et non sur l’IA comme simple aide à l’autocomplétion ou assistant conversationnel,
    mais sur une exécution réelle du travail en mode agent
• L’outil utilisé est Cursor,
  • basé sur le modèle Claude Sonnet 3.7 d’Anthropic
  • avec la capacité de modifier directement les fichiers du projet et d’exécuter les commandes pertinentes

Exemple 1 : Platform Problem Monitoring (projet greenfield)

• À l’aide de Cursor et Claude, l’auteur a implémenté une nouvelle application appelée Platform Problem Monitoring
  • Code source : lien GitHub
• Cette application se connecte chaque heure au serveur Elasticsearch d’ELK pour collecter les messages d’erreur, puis envoie un rapport e-mail structuré résumant l’état actuel des problèmes de la plateforme web
• L’ensemble de l’implémentation a été réalisé par l’IA, et aucune ligne de code n’a été écrite manuellement
• L’auteur n’est pas particulièrement à l’aise avec Python, mais
  • sa compréhension large de l’architecture, de l’exploitation et des bonnes pratiques lui a permis d’avancer sans difficulté
  • ce projet a aussi servi d’expérience pour mesurer à quel point l’IA peut aider sur une stack technique peu familière

Remarque : problèmes de qualité du code
Dans la discussion sur HackerNews, plusieurs problèmes de qualité ont été signalés, notamment la configuration du logging, le parsing de configuration personnalisé et des race conditions
Ce projet visait davantage un prototypage rapide qu’un code de production,
avec une priorité donnée à l’implémentation fonctionnelle plutôt qu’à la maintenabilité long terme ou aux conventions du langage

Exemple 2 : Process Management UI Integration (projet brownfield)

• Un cas d’intégration d’une UI à une fonctionnalité backend legacy existante en PHP/Symfony
• Le backend fonctionnait via des commandes CLI basées sur cron et ne disposait pas d’interface utilisateur
• L’objectif était d’intégrer cette fonctionnalité dans une application Symfony moderne
  • en s’appuyant sur une structure adaptée à l’UI, avec une base de code récente, un système de tests et un guide de style
• Principales tâches réalisées :
  • communication avec le système legacy via une API HTTP
  • implémentation du transfert de données entre systèmes
  • construction des écrans conformément au design system de l’UI
  • implémentation d’un client API dans un bundle Symfony partagé
• À l’exception des fichiers keyframes, l’ensemble de l’implémentation a été réalisé automatiquement par l’IA

Enseignements clés tirés de ces deux projets

1. Projet greenfield : même sur une stack peu familière, l’aide de l’IA permet de réaliser une application fonctionnelle
2. Projet brownfield : même lorsqu’il s’agit d’un travail peu familier comme l’implémentation d’une UI, l’IA a permis de finaliser rapidement la fonctionnalité

• Ces deux exemples montrent concrètement que les outils d’IA peuvent transformer de manière tangible la productivité individuelle et le workflow de toute une équipe
• Cependant, pour que l’IA fasse vraiment gagner beaucoup de temps, il faut un investissement initial de mise en place et une approche stratégique
  • au même titre qu’il faut bien encadrer un bon développeur junior pour obtenir le meilleur résultat

L’importance de rédiger des exigences précises

• Le cœur d’une session de codage IA réussie, c’est un document d’exigences structuré et complet
• Sur le projet réel Platform Problem Monitoring, l’auteur a rédigé le document REQUIREMENTS.md avant même de démarrer la session
• Ce document fait 371 lignes et suit la structure hiérarchique suivante
  • niveau le plus haut : résumé en une ligne des exigences essentielles
  • niveau supérieur : cas d’usage et motivations du développement
  • niveau intermédiaire : processus et mode de fonctionnement
  • niveau intermédiaire : architecture, stack technique et contraintes
  • niveau inférieur : description détaillée des étapes concrètes selon les critères d’entrées/sorties/effets de bord
• Un document ainsi structuré fournit aussi à l’IA un cadre clair qui favorise des résultats précis
• Sa rédaction demande du temps et des efforts, mais c’est un investissement indispensable pour une implémentation réussie
• Il existe un adage bien connu en développement logiciel :

  « Six semaines d’implémentation permettent d’économiser deux heures de planification »

  • c’est une formule ironique, mais elle contient une vérité : les inefficacités au stade de l’implémentation viennent souvent d’un manque de préparation
• C’est pourquoi un projet devrait toujours commencer au tableau blanc plutôt qu’au clavier, et ce principe reste exactement le même lorsqu’on collabore avec l’IA
• En pratique, l’auteur démarre une session Cursor en suivant ces étapes :
  1. demander à l’IA de résumer elle-même les exigences
  2. lui faire générer un plan d’exécution
  3. l’inciter à poser des questions sur les zones d’ambiguïté
• Ce n’est qu’après cette phase de validation qu’il bascule l’IA en mode « Agent » pour lancer l’implémentation

Mettre en place des garde-fous de qualité basés sur les outils

• Si le document d’exigences définit la destination, les garde-fous de qualité permettent de rester sur le chemin le plus direct pour y parvenir
• De la même manière que les systèmes de feedback en temps réel sont essentiels pendant le développement, les outils d’analyse statique sont aussi d’une grande aide pour l’IA
• Par exemple, il est bien plus efficace de détecter un oubli de vérification de null pendant le développement que de le découvrir après le lancement via une remontée client
• C’est pourquoi, avant de démarrer une session de codage IA, l’auteur met systématiquement en place les outils d’assurance qualité suivants
  • sur la base de cet exemple de Makefile :
    • black, isort : formatage du code
    • ruff : linting
    • mypy : vérification de types
    • bandit : analyse de sécurité
    • l’ensemble de la suite de tests
• Un agent d’IA basé sur Claude peut reconnaître et exploiter ces outils
  • par exemple, si la vérification de types échoue, l’IA peut corriger le code d’elle-même pour faire passer le contrôle
• Pour la validation fonctionnelle, l’auteur fournit aussi des requêtes de test d’API avec curl
  • il a été frappé de voir l’IA appeler directement les endpoints, vérifier les réponses et améliorer le code en conséquence
• Ces garde-fous outillés sont ainsi un composant indispensable pour aider l’IA à produire des résultats fiables

La technique des keyframes basés sur les fichiers

• L’IA est très forte pour l’implémentation créative, mais peut manquer d’orientation sur la structure du code ou l’organisation des fichiers
  • pour compenser cela, l’auteur utilise la stratégie du file-based keyframing
• Cette technique s’inspire de la méthode des keyframes en animation :
  • un animateur expérimenté crée d’abord les scènes clés (keyframes), puis le reste est complété par des intervenants de soutien
  • cela permet d’augmenter l’efficacité tout en préservant la qualité
• Dans un projet réel de codage assisté par l’IA, l’auteur crée à l’avance des fichiers squelettes vides (stub files) avant l’implémentation
  • par exemple : endpoints API, client API, classes de contrôleur, templates Twig, etc.
• Ces fichiers keyframes fournissent à l’IA des informations de contexte importantes, notamment
  • la manière dont les fichiers sont organisés dans le projet
  • la structure des namespaces
  • les conventions de nommage
  • des patterns de code cohérents
• Plutôt que d’expliquer toute la structure dans un prompt, on améliore la précision du raisonnement de l’IA en lui donnant des indices directement dans la base de code
• Cette approche rappelle qu’à l’ère de l’IA aussi, le principe du « bien nommer » reste fondamental
  • puisque l’IA fonctionne à partir du langage, un texte porteur d’intention et de sens conduit à de meilleurs résultats

Mise en œuvre intégrée sur un cas réel : réalisation de l’UI d’un tableau de bord des contrats d’abonnement

• L’auteur présente ensuite un exemple concret où les trois principes clés expliqués plus haut sont appliqués ensemble dans un même projet :
  • documentation rigoureuse des exigences
  • garde-fous de qualité basés sur les outils
  • technique des keyframes basés sur les fichiers

• Vue d’ensemble du projet

  • objectif : implémenter un tableau de bord web UI en lecture seule qui visualise sous forme de tableau les informations sur les contrats d’abonnement dans la plateforme
  • environnement : un contexte multi-codebase (monorepo)
    • backend-app : application Symfony 5, détentrice des données
    • janus-christophorus : application Symfony 7, qui fournit l’UI
    • janus-shared-bundle : inclut l’implémentation du client API
    • janus-webui-bundle : inclut le guide de style, la configuration Tailwind et les templates Twig

• Structure des exigences

  • lire les données backend via une API et les afficher dans l’UI frontend
  • prise en charge d’un mode démo en plus des vrais endpoints API (avec de fausses données pour les tests)
  • implémenter l’UI de manière cohérente avec le guide de style
  • chaque couche comprend les composants suivants :
    • endpoint API
    • client API
    • classe de service de la couche de présentation
    • contrôleur et template Twig

• Préparation de la session IA

  • création à l’avance de fichiers vides dans toutes les codebases selon l’approche des keyframes basés sur les fichiers
  • mise à disposition à l’IA du guide de style existant, du service de navigation et de fonctionnalités similaires comme matériel de référence
  • possibilité d’exécuter les outils qualité (comme PHPStan) dans chaque codebase
    • par exemple via le script .dxcli/dxcli.sh quality

• Manière d’utiliser les principes intégrés

  • formalisation des exigences : décrire en détail les besoins et la structure du système dans le prompt
  • mise en place des garde-fous : inclure des indications sur l’utilisation des outils de vérification du code
  • mise à disposition des keyframes : créer à l’avance les fichiers à implémenter pour permettre à l’IA d’écrire le code au bon endroit et avec le bon contexte

• Objectifs principaux

  • fournir rapidement une UI permettant d’avoir une vue d’ensemble des informations contractuelles
  • donner à l’IA une structure claire et des indices explicites afin qu’elle puisse poser des questions et élaborer un plan dans l’implémentation réelle
• Cet exemple montre bien à quel point la synergie entre les outils d’IA et l’expérience humaine peut être puissante

Conclusion : outils d’IA + expérience humaine = la meilleure combinaison

• En fournissant des exigences précises, des garde-fous basés sur les outils et des keyframes basés sur les fichiers,
  il est possible d’exploiter la puissance de l’IA tout en maintenant la qualité du code et la cohérence architecturale
• Ces pratiques de développement traditionnelles restent pleinement valables à l’ère de l’IA et
  gagnent même en efficacité grâce à l’expérience et à la capacité d’analyse des développeurs seniors
• En définitive, l’IA n’est qu’un outil, et nous vivons à une époque où
  l’expérience humaine et les compétences nécessaires pour l’utiliser correctement sont plus importantes que jamais

[GN⁺]

Avis Hacker News

• Un développeur Python expérimenté, après avoir examiné un fichier précis, souligne qu’il est truffé d’erreurs de débutant en ingénierie logicielle

  • En commençant par la configuration du logger racine au niveau du module, ainsi que le fait d’avoir écrit soi-même un parseur de fichier de configuration au lieu d’utiliser celui de la bibliothèque standard
  • Il relève aussi un problème dans load_json, qui vérifie d’abord l’existence du fichier puis continue comme si le fichier existait forcément
  • Plus globalement, il mentionne la faible qualité du code

• Un codeur amateur avec 25 ans d’expérience estime que les LLM et le vibecoding nuisent à la créativité

  • Il aime apprendre et utiliser de nouveaux outils, et souhaite créer des solutions commercialisables
  • Les LLM lui permettent de concrétiser rapidement ce qu’il imagine, mais réduisent la satisfaction de construire lui-même
  • Il confie ne pas avoir réussi à créer de grand projet au cours de l’année passée, et que cela a réduit son plaisir

• Un développeur de moins de 40 ans estime que l’IA est utile comme outil pour alléger la charge de travail

  • Il souffre d’une forte tendinite et a constaté une amélioration après avoir utilisé l’autocomplétion de code
  • Il s’inquiète de voir le "vibe coding" devenir dominant et craint que seuls les développeurs expérimentés soient capables de comprendre réellement les situations

• Un utilisateur juge inefficace la génération de code avec l’IA

  • Rédiger les prompts et traquer les erreurs dans le code prend beaucoup de temps
  • Il mentionne que coder directement lui apporte une certaine tranquillité d’esprit

• Un utilisateur estime que l’IA est utile sur les nouveaux projets (greenfield), mais inefficace sur les projets existants (brownfield)

  • Il souligne que l’IA a du mal à s’intégrer à du code existant

• Un développeur planifie ses projets au démarrage à l’aide de fichiers Markdown

  • Il utilise Rust pour garantir la justesse du code via des vérifications à la compilation
  • Il se dit satisfait de pouvoir repérer davantage d’erreurs dans le code Rust généré par l’IA

• Un utilisateur pense que l’expérience en ingénierie logicielle est importante à l’ère de l’IA

  • Il craint qu’une dépendance aux LLM n’entraîne une dégradation de l’expérience acquise

• Un utilisateur cherche à appliquer le concept de "surprise" issu de la théorie de l’information aux LLM

  • Si le code généré par un LLM est inattendu, il peut être difficile d’identifier les erreurs
  • Il essaie de reformuler cela comme une "exploration" afin d’en faire une occasion d’apprendre de nouveaux sujets

• Un utilisateur veut guider le code généré par l’IA via le développement piloté par les tests (TDD)

  • Il considère le TDD comme une forme de contrat qui permet ensuite de choisir entre IA et codage manuel

• Un utilisateur craint que la forme actuelle de l’IA n’aille pas dans la bonne direction pour l’avenir du logiciel

  • Il rappelle que le succès de Java tient au code source fourni avec le JDK
  • Il souligne que l’IA n’améliore ni la clarté du code ni sa découvrabilité

• Un utilisateur se sent dépassé par la rapidité des progrès de l’IA

  • Un développeur expérimenté peut tirer parti de l’IA pour planifier de nouvelles applications
  • Il pense qu’il est important de construire une marque personnelle et de créer ses propres applications