L’auteur s’interroge sur l’impact de l’IA sur le logiciel propriétaire : en abaissant fortement le coût du reverse engineering, de la réimplémentation et du développement sur mesure, elle rend possible la création rapide d’alternatives à des outils existants. Le logiciel ne disparaîtra pas, notamment lorsque sa valeur repose sur un réseau, des données, des certifications ou un service, mais le code devient une commodité. Pour les développeurs, la valeur se déplace vers l’analyse des besoins, la conception et l’hyperpersonnalisation.

Ayman Nadeem revient sur l’échec de Nuanced, un outil conçu autour d’un « plan mode » pour le développement assisté par IA. Selon lui, les modèles devenant meilleurs pour explorer les dépôts et prendre des décisions raisonnables, les plans détaillés servent de moins en moins à guider l’agent. Le vrai problème reste toutefois entier : permettre aux développeurs de conserver une compréhension claire du système pendant que plusieurs agents modifient rapidement le code.

Le problème majeur du code généré par IA n’est pas nécessairement sa qualité moyenne, mais la perte progressive de compréhension du système par les équipes. Quand spécifications, code, tests et décisions passent presque entièrement par des LLM, l’architecture, l’intention et les choix techniques deviennent opaques. L’auteur insiste sur l’importance des fondamentaux, du jugement humain et surtout de la maintenabilité : générer vite est facile, mais maintenir un système que personne ne comprend devient le véritable risque.

WanadevDigital présente une méthode pour mutualiser les règles de développement de Claude Code entre plusieurs projets grâce à un plugin et un dépôt Git centralisé et versionné. La commande /wana-rules:sync permet d'adopter sélectivement les conventions selon les besoins du projet. La commande /wana-rules:audit vérifie leur respect. Les règles évoluent par merge requests et sont resynchronisées progressivement.

Claude Code, un outil d'IA, démontre ses capacités à résoudre des problèmes techniques complexes, illustrant ainsi son potentiel pour des applications pratiques. Son analyse approfondie permet de diagnostiquer des dysfonctionnements qui échapperaient à une investigation humaine traditionnelle.

Dans un exemple concret, l'IA a identifié la cause d'une requête DNS bloquée sur un réseau Wi-Fi, un problème complexe lié à des réglages de routeur apparemment sans rapport et à un bug du firmware. Claude Code a analysé des traces réseau pour pointer précisément la source du conflit, permettant une résolution rapide et efficace.

Ces capacités révèlent l'immense potentiel de l'IA comme outil d'assistance technique, capable de déchiffrer des logs complexes et de proposer des solutions basées sur une compréhension fine des interactions entre différents composants système.

Martin Dufresne, développeur, chercheur indépendant et formateur, partage ses réflexions sur les défis posés par l'intelligence artificielle dans le domaine du développement logiciel. Il aborde notamment la fatigue croissante des professionnels, souvent causée par la délégation des tâches simples aux IA, laissant les développeurs face à des charges cognitives plus lourdes et moins de temps de pause.

L'entretien explore également la perte du plaisir intrinsèque au développement et la difficulté d'apprendre lorsque les réponses sont immédiatement fournies par les machines. Dufresne met en avant des approches alternatives, comme l'écriture manuscrite pour stimuler la réflexion, et l'importance de se satisfaire du nécessaire plutôt que de chercher constamment la nouveauté.

Face à ces enjeux, il prône une approche réfléchie de l'IA, en distinguant celle que l'on choisit d'utiliser et celle que l'on subit. Il évoque également des pistes pour retrouver des moments de plaisir et de respiration dans le processus de développement, s'inspirant de méthodologies comme Shape Up pour aménager le rythme de travail.

Le projet "Symfony AI in Practice" présente le développement d'un assistant d'écriture destiné aux adultes dyslexiques, construit avec le composant AI de Symfony. L'application permet aux utilisateurs de coller leur texte, de recevoir une analyse des erreurs, des explications sur les règles grammaticales associées, et même une lecture audio de ces explications, complétée par un chatbot pour des questions supplémentaires. L'ensemble de la configuration, y compris les agents et leurs prompts spécifiques, est centralisé dans un fichier ai.yaml, simplifiant l'intégration et la gestion des fonctionnalités d'IA.

L'utilisation du composant Symfony AI a permis une mise en place rapide de l'assistant, ne nécessitant que quelques minutes pour configurer l'environnement et installer le bundle. Les agents AI sont rendus injectables en tant que services Symfony, facilitant leur utilisation directe dans le code applicatif. Le processus de développement a consisté à intégrer progressivement les différentes fonctionnalités du composant AI, telles que la revue de texte structurée, une option de synthèse vocale, et un coach conversationnel, le tout sans nécessiter de framework frontend comme React.

Ce projet met en avant la capacité de Symfony AI à gérer la configuration des modèles d'IA, à permettre le changement de modèle sans modification du code PHP grâce à un routeur, et à fournir des outils de débogage puissants comme le profiler, qui enregistre chaque interaction avec l'IA. L'auteur souligne la facilité de test de ce composant et exprime sa volonté de l'utiliser à nouveau pour de futurs projets, notamment grâce à son intégration transparente dans l'écosystème Symfony.

Après avoir décidé de refuser les contributions basées sur l'IA pour son projet open source LibreWeddingPlanner, l'auteur a continué à utiliser l'IA dans son travail professionnel. Il décrit cette utilisation comme une addiction potentielle, notant que les tâches autrefois longues pouvaient être accomplies en quelques heures grâce à des outils comme l'autocomplétion améliorée et les modèles de génération de code.

L'utilisation croissante de l'IA pour implémenter des fonctions ou générer des tests a conduit à une perte de compréhension du code produit. L'auteur a constaté qu'il déléguait des tâches entières à l'IA, y compris la décomposition de problèmes complexes, ce qui entraînait la soumission de changements qu'il ne comprenait pas entièrement, s'inquiétant de la responsabilité lors des revues de code et de sa propre compétence en tant que développeur.

Cette dépendance a évolué vers la gestion simultanée de plusieurs tâches par plusieurs agents d'IA, délestant l'auteur de son rôle actif dans le développement. Il a ressenti une perte de contrôle, ne sachant plus exactement ce que le code qu'il soumettait faisait réellement, et a envisagé de se présenter comme un simple "berger d'IA".

L'article décrit la construction de PABLO, un orchestrateur développé en Symfony, visant à automatiser les tâches répétitives et à réduire les changements de contexte pour les développeurs. PABLO s'appuie sur une machine à états pour gérer le cycle de vie des tâches, allant de la compréhension initiale à la mise en production.

Avant PABLO, l'auteur utilisait un environnement de développement basé sur des agents capables de comprendre les tickets et le code associé. Cependant, la phase post-développement, impliquant les revues, les tests QA et la surveillance de la CI/CD, restait un processus manuel coûteux en changements de contexte et en temps.

PABLO a été créé pour combler ce fossé, en centralisant la gestion de ces différentes étapes. Son objectif est de décharger le développeur des corvées d'attente et de vérification, lui permettant de se concentrer sur l'écriture de code et l'innovation, tout en maintenant une vision claire de l'état d'avancement des projets.

TinyJS permet de créer des applications de bureau pour macOS, Windows et Linux avec une taille de fichier minimale d'environ 6 Mo. Il utilise un backend JavaScript exécuté sur txiki.js pour un accès complet au système et une fenêtre native (WebView) déjà présente sur le système d'exploitation, évitant ainsi l'embarquement de navigateurs lourds comme Electron.

La plateforme offre un accès système complet via RPC sur un socket Unix, des mises à jour à chaud sans étape de compilation pour le développement, et l'intégration d'éléments d'interface natifs comme les menus ou les boîtes de dialogue. TinyJS se distingue par sa légèreté et son approche minimaliste par rapport à des solutions comme Electron ou Tauri, tout en offrant la possibilité d'intégrer facilement du HTML, CSS et JavaScript existant.

L'article explore le rôle de l'intelligence artificielle dans le développement logiciel, en s'opposant à son utilisation systématique pour "automatiser les parties ennuyeuses" du codage. L'auteur met en avant l'importance de conserver le processus de résolution de problèmes comme un "artisanat" personnel, une pratique qui permet un apprentissage et une croissance profonds.

Face à l'essor de l'IA, l'auteur préconise un retour aux fondamentaux du codage, comparant ce processus à l'entraînement dans un "vieux gymnase" à la Rocky Balboa. L'idée principale est que la lutte directe avec les défis de programmation, même frustrante, est essentielle au développement des compétences et à la maîtrise, un aspect que l'IA ne peut remplacer.

L'IA est reconnue pour son utilité dans des tâches répétitives comme la génération de code boilerplate ou la résumé de documentation. Cependant, le cœur du métier de développeur, impliquant la pensée critique, la conception architecturale et la prise de décisions nuancées, doit être préservé comme un espace de développement personnel, par analogie, à travers le "vieux gymnase" cognitif.

Le texte explore deux approches pour gérer les dépendances lors de tests locaux de services communiquant avec S3 dans une application Symfony. La première question technique concerne l'utilisation de class: versus alias: pour redéfinir un service. L'auteur illustre qu'un alias peut être préférable car il permet de pointer vers une autre définition de service sans pour autant le réinstancier directement, évitant ainsi des erreurs de construction comme le manque d'arguments.

La deuxième question aborde une décision d'architecture : privilégier un "double maison jetable" (un faux service temporaire redirigeant vers le système de fichiers local) plutôt qu'une solution comme MinIO (un conteneur S3-compatible). Cette approche est motivée par la simplicité et la réversibilité, rendant la modification facilement identifiable et supprimable après les tests, notamment grâce au bloc when@dev de Symfony qui permet de scoper la configuration à un environnement spécifique.

En résumé, le choix entre une configuration via class: ou alias: pour substituer un service en environnement de développement, et le type de fausse dépendance utilisé, sont des décisions d'ingénierie qui doivent être adaptées au contexte et aux besoins de réversibilité du processus de développement. L'utilisation de blocs de configuration conditionnels comme when@dev facilite l'intégration et la suppression temporaire de ces adaptations pour les besoins de recettes et de tests.

L'article soutient que la tendance actuelle à diviser les systèmes d'IA en de multiples agents spécialisés, à l'instar des microservices, peut être prématurée et coûteuse. Il souligne que de nombreux agents médiocres ne surpassent pas un seul agent performant, et que la complexité croissante d'un agent unique conduit à une dégradation progressive. Les problèmes majeurs incluent la difficulté de sélectionner le bon outil parmi une liste étendue, la contradiction des instructions dans un unique prompt, et la difficulté de modifier le système sans affecter l'ensemble.

Le moment idéal pour opérer une scission en agents multiples est lorsque ces difficultés deviennent mesurables et nuisibles, et non sur la base d'une esthétique ou d'une tendance. La solution proposée est le schéma "supervisor pattern", où un agent superviseur centralise la classification et le routage des requêtes vers des agents spécialisés. Chaque agent spécialiste est confiné à un domaine unique, disposant de son propre prompt clair, d'un ensemble d'outils limité et distinct, et gérant son propre état de conversation.

Ce modèle permet de retrouver la précision dans le choix des outils et d'éviter les conflits d'instructions, offrant ainsi une meilleure maintenabilité et évolutivité. L'idée principale est de ne pas commencer avec une architecture multi-agents avant que la nécessité ne soit clairement établie par des problèmes concrets liés à la complexité d'un agent unique, puis d'adopter une approche structurée avec un superviseur et des spécialistes.

L'article explore le concept de "Agentic Coding" en comparant le développement de composants graphiques personnalisés à l'aide de primitives D3 et de la librairie Recharts. L'auteur a découvert que l'approche basée sur les primitives D3 a permis de satisfaire pleinement les exigences de conception complexes, y compris les animations et les comportements spécifiques, sans nécessiter de contournements coûteux.

En contraste, la librairie Recharts, bien que plus rapide pour les cas courants, a rapidement montré ses limites pour atteindre les 20% de personnalisation restants, obligeant à coder du SVG personnalisé et à désactiver des fonctionnalités comme les animations pour contourner des problèmes de compatibilité avec la pile React du projet.

L'auteur redéfinit l'abstraction non pas comme un coût nul, mais comme un travail d'implémentation pré-payé qui offre de la flexibilité en échange. L'histoire du développement web est vue comme une ascension progressive de cette échelle d'abstraction, où chaque étape convertit du travail humain coûteux en dépendances moins chères, mais où les besoins spécifiques finissent par révéler les contraintes de ces abstractions de haut niveau.

L'auteur décrit une expérimentation où il délègue la génération de code à des agents basés sur l'IA. Initialement, il agissait comme un intermédiaire, copiant-collant des tickets dans des sessions d'agents pour déclencher leur travail. Cette tâche répétitive l'a conduit à réaliser que la partie réellement créative et intéressante du processus de développement se situait en amont, lors de la spécification des tickets.

Cette évolution s'inscrit dans une progression sur plusieurs années, passant de la complétion de code (Copilot) au dialogue avec les modèles (chat), puis à l'agentique où les IA peuvent modifier des fichiers et exécuter des commandes sous supervision. L'étape actuelle consiste à retirer l'humain de la boucle de déclenchement des agents, transformant son rôle.

Le changement majeur est passé de l'écriture directe de code à la spécification détaillée de ce qui doit être codé. L'expérimentation actuelle vise à pousser cette idée plus loin en retirant l'humain de la seule action de lancer les agents, le rôle du développeur se concentrant désormais sur la définition précise des tâches à accomplir par l'IA.

Graft est un outil open-source conçu pour améliorer les performances des agents de codage tels que Claude Code, Cursor, Codex et Gemini. Il vise à les rendre plus rapides, moins coûteux et à améliorer leur compréhension contextuelle de votre base de code, permettant ainsi des économies significatives en temps et en coût, tout en améliorant parfois la précision des résultats.

L'outil fonctionne en créant un graphe de votre base de code. Ce graphe permet aux agents d'accéder à des informations contextuelles pertinentes, réduisant ainsi le besoin de traiter l'intégralité du code à chaque requête. Graft s'intègre en douceur, notamment avec Claude Code, en ajoutant automatiquement des hooks et en gérant la génération du graphe en arrière-plan, rendant ainsi l'amélioration transparente pour l'utilisateur.

Une fonctionnalité notable de Graft est son application GitHub qui analyse automatiquement les pull requests, offrant des revues de code plus efficaces. Il supporte également une variété de langages de programmation et offre des outils en ligne de commande pour la recherche, la cartographie et la visualisation du graphe de code.

Pi est un "agent harness" minimal conçu pour s'adapter aux flux de travail de l'utilisateur plutôt que l'inverse. Il permet la personnalisation via des extensions, des compétences, des modèles de prompts et des thèmes, qui peuvent être packagés et partagés via npm ou git. Pi se distingue par sa flexibilité et sa légèreté, offrant quatre modes d'utilisation : interactif, impression/JSON, RPC et SDK, tout en évitant des fonctionnalités complexes comme les sous-agents ou le mode plan par défaut.

L'auteur a profité de deux semaines de congé pour moderniser son projet personnel Gifty Weddings, un registre de cadeaux de mariage devenu un constructeur de sites web, tout en apprenant à coder avec des outils d'IA. Il a utilisé principalement Claude Code avec le modèle Opus 5 pour le développement, complété par Pi pour les tâches mineures, tout en conservant un rôle actif dans la revue et l'orientation du code.

Malgré ses réticences initiales envers l'IA, nourries par des expériences décevantes en 2024, l'auteur a constaté des progrès significatifs dans l'efficacité des outils, notamment pour générer du CSS ou corriger des bugs complexes. Son approche itérative, combinant des bases existantes (code Go, schéma SQL) et une supervision humaine constante, a permis d'équilibrer automatisation et qualité, bien que certains compromis aient été nécessaires sur le style ou les tests.

L'expérience a révélé des limites, comme la verbosité des commentaires générés par l'IA ou la nécessité de guider activement le processus pour éviter des résultats médiocres. L'auteur souligne l'importance de l'expérience humaine pour distinguer un travail de qualité d'une production superficielle, tout en reconnaissant le gain de temps et d'inspiration apporté par ces outils.

L’article de Romain Lanz explore une méthode pour utiliser efficacement l’IA dans le développement logiciel sans déléguer la réflexion stratégique. Il souligne que, contrairement à une idée reçue, déléguer l’écriture du code à l’IA ne signifie pas renoncer à la maîtrise du processus, à condition d’adopter une approche structurée.

L’auteur détaille trois concepts clés : le modèle (le LLM utilisé), le contexte (les informations fournies pour guider la réponse) et le harness (l’environnement technique qui encadre l’IA). Il insiste sur l’importance de limiter le contexte, car un excès d’informations dégrade la qualité des réponses, et sur le rôle du harness, qui agit comme un intermédiaire entre le modèle et les outils concrets (lecture/écriture de fichiers, exécution de commandes).

Enfin, Lanz rappelle que l’IA reste un outil prédictif, incapable d’agir sans ces extensions techniques. Sa méthode vise à optimiser l’interaction avec ces outils pour en tirer le meilleur parti tout en conservant le contrôle sur les décisions techniques.

L’article présente la création d’un assistant de code review basé sur l’IA, spécialisé dans le projet Symfony, en combinant PHP, Ollama et Qdrant. L’idée centrale est d’exploiter les milliers de retours historiques de la communauté Symfony pour générer des critiques de code plus pertinentes et adaptées, plutôt que des conseils génériques. L’auteur a développé un système utilisant une recherche sémantique (RAG) pour analyser les pull requests et les commentaires des contributeurs expérimentés, comme stof ou Nicolas Grekas, afin d’offrir des retours ciblés.

L’outil, nommé Symfony Reviewer MCP, repose sur une architecture en deux parties : un pipeline de génération de données vectorielles (à partir des archives GitHub) et un serveur MCP exposant ces données via une interface standardisée. L’indexation a été réalisée localement avec Ollama (modèle embeddinggemma-300m) et Qdrant, sans recourir à un GPU, au prix d’un temps de traitement long mais économiquement acceptable. L’application est développée en PHP 8.5 et Symfony 8.1, démontrant une approche pragmatique pour intégrer l’IA dans des workflows de développement existants.