Retour d’expérience sur la création en neuf jours d’un jeu roguelite avec Claude Code, l’agent écrivant tout le code tandis que l’auteur pilote le produit, les revues et les tests. Le résultat compte 93 pull requests fusionnées et plus de 1 000 tests. La réussite repose surtout sur un cadre explicite : brief versionné, glossaire, règles ciblées, skills, hooks, TDD obligatoire et intégration continue. L’article souligne aussi les limites de l’automatisation et l’importance du contrôle humain pour préserver la cohérence du produit.

Jérémy Decool met en garde contre l’usage automatique de l’IA dans les équipes de développement, même pour des opérations simples que les outils classiques réalisent déjà efficacement. Il cite les rebases et cherry-picks Git sans conflit, pour lesquels un agent ajoute des coûts en tokens et du temps d’attente sans réelle valeur. Il propose de distinguer les tâches déterministes, mieux confiées à des commandes ou scripts fiables, de celles nécessitant du jugement, où l’IA apporte davantage. Le choix de l’outil doit rester guidé par le besoin, pas par l’habitude.

Camille Roux explique comment il utilise Claude Code comme manager d’artiste pour développer ses activités au-delà des ventes de NFT. Son dispositif repose sur de simples fichiers texte regroupant mémoire des projets, suivi des opportunités, objectifs et commandes récurrentes. L’agent prépare les candidatures, surveille les échéances, suggère des relances et facilite les bilans. L’artiste conserve toutefois la création, les décisions, les relations humaines et la validation des messages. Une approche légère et reproductible pour déléguer l’organisation sans abandonner le contrôle.

L’IA facilite la création rapide de logiciels sur mesure, au point que certaines équipes et certains utilisateurs préfèrent désormais développer leurs propres outils plutôt que s’adapter à des solutions génériques. Jérémy Decool y voit l’émergence d’une hyper-spécialisation logicielle, qui menace surtout les produits peu différenciés, tandis que les applications à forte complexité métier ou réglementaire conservent un avantage. Il s’interroge aussi sur les conséquences pour l’open source : moins de contributions communes, davantage de fragmentation et des coûts de maintenance durables, même lorsque la création initiale devient très simple.

L’équipe Claude Code d’Anthropic explique comment adapter la revue de code à la production massive de changements par des agents IA. La vérification commence avant la pull request, puis combine agents relecteurs, contrôle de sécurité, tests automatisés et validation humaine proportionnée au risque. Les alertes sont recoupées pour limiter les faux positifs, tandis que déploiement progressif, surveillance et retour arrière réduisent l’impact des erreurs. L’objectif est de préserver l’attention humaine sans augmenter les incidents : selon l’équipe, les PR fusionnées ont plus que doublé tandis que les annulations ont diminué de plus de 40 %.

Boris Cherny, créateur de Claude Code, recommande de structurer les demandes à une IA autour de trois éléments : définir clairement la tâche et le résultat attendu, préciser le niveau d'effort souhaité, puis fournir un moyen de vérifier la réponse. Son exemple de création d'un contenu interactif autour d'un épisode du podcast Acquired montre qu'un prompt conversationnel peut suffire, sans modèle rigide. Pour le développement logiciel, la vérification peut notamment passer par l'exécution de tests. Ces conseils restent pratiques plutôt que scientifiquement validés.

Nicolas Simond partage son usage quotidien de Claude Code pour l’administration systèmes : génération de documentation d’infrastructure, analyse d’incidents, durcissement de serveurs et création de petits outils. Il délègue le code à des modèles Ollama via Aider, puis fait relire les modifications par Claude dans des branches Git isolées. Les données clients restent locales : seuls des exemples anonymisés servent à concevoir les scripts. L’auteur insiste sur les règles de projet, les contrôles humains et les tests, tout en soulignant les gains de temps obtenus sur les tâches répétitives.

La documentation produite par IA peut paraître impeccable tout en étant inutilisable : commandes non expliquées, décisions absentes et procédures impossibles à vérifier. L’article propose une méthode de contrôle dans la CI : imposer quatre sections (objectif, synthèse accessible, commandes commentées et vérification), ajouter une checklist aux pull requests et combiner Vale pour la lisibilité avec un script Bash pour la structure. Un workflow GitHub Actions bloque les documents non conformes. La vérification humaine des procédures reste indispensable, et les scripts fournis doivent être adaptés avant production.

Esther Weidauer défend un refus de l’IA générative, qu’elle distingue des autres usages de l’apprentissage automatique. Elle conteste les arguments de son utilité et de sa prétendue neutralité, en soulignant la dépendance à des infrastructures et à du travail souvent invisibles. Elle pointe ses coûts énergétiques et économiques, les risques de dépendance cognitive et de désinformation, ainsi que la concentration du pouvoir sur l’accès au savoir. Sa critique s’étend aux biais politiques et à la culture des entreprises du secteur.

En appliquant le principe de Peter au développement assisté par IA, Baldur Bjarnason estime que les développeurs sont devenus, sans formation, des gestionnaires d’agents imprévisibles. Au lieu de programmer, ils doivent coordonner, surveiller et corriger des processus difficiles à maîtriser. Cela favoriserait le travail inutile, les retards et le stress, sans garantir davantage de valeur. L’auteur souligne aussi le paradoxe de l’automatisation : moins on pratique le code, plus les compétences et les modèles mentaux nécessaires pour contrôler la qualité risquent de s’éroder.

À partir d’un témoignage publié sur Reddit, Matoo rassemble des réactions de développeurs face à la généralisation des agents de codage comme Claude. Certains décrivent une perte de sens, de plaisir et de maîtrise technique : ils ne codent presque plus et se limitent à superviser l’IA. D’autres y voient une libération des tâches répétitives, permettant de se concentrer sur la conception, l’architecture et les besoins utilisateurs. Ces échanges soulignent les différences de rapport au métier, ainsi que les inquiétudes sur la qualité du code, la dépendance aux fournisseurs et l’avenir professionnel.

À partir du concept de « merdification » popularisé par Cory Doctorow, l’auteur décrit la dégradation progressive des plateformes et services après avoir rendu leurs utilisateurs dépendants : publicité accrue, abonnements, restrictions et perte de contrôle. Il étend cette critique aux réseaux sociaux, aux logiciels, aux objets connectés et à l’IA, accusée d’appauvrir le Web et d’accentuer la captation des usages. Pour reprendre la main, il recommande de réduire les services superflus, de privilégier les alternatives libres et l’auto-hébergement, et de soutenir des modèles numériques plus durables.

L’accélération du développement par les agents d’IA permet de transformer un ticket en pull request testée puis déployée en quelques minutes. Mais cette vitesse crée une « dette de compréhension » : les équipes valident des changements sans assimiler les règles métier, les choix d’architecture ou le code produit. Les indicateurs de livraison restent au vert tandis que la maîtrise réelle du logiciel diminue. L’auteur rappelle que l’IA peut assister la production, mais que la responsabilité de comprendre et d’assumer chaque livraison doit rester humaine.

Alberto Denia compare le code à de l’argile : avec les agents IA, le coût des modifications chute, permettant d’expérimenter et de remodeler rapidement un logiciel. Il distingue deux approches complémentaires : l’artisan, qui intervient à chaque itération pour affiner le produit et son code, et l’usine, qui automatise les tâches répétitives grâce aux spécifications, tests et contrôles. Dans les deux cas, le jugement humain reste indispensable, mais il s’exerce à des moments différents : pendant la création ou lors de la conception du processus.

Retour détaillé sur les temps forts du Forum PHP 2026 : Symfony 8.2 et son accélération spectaculaire grâce aux agents IA, exposition des API aux agents via MCP et API Platform, pratiques de PHP défensif, sécurisation des coding agents avec des sandboxes, simplification d’architectures trop complexes, performances réseau avec HTTP/3 et QUIC, et nouveaux enjeux de sécurité liés aux rapports générés par IA. Un panorama très concret des tendances qui transforment l’écosystème PHP.

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.

L’IA rend désormais le code beaucoup moins coûteux à écrire et à réécrire, mais cela ne le rend pas moins important. Au contraire, les agents de codage s’appuient fortement sur les conventions et abstractions déjà présentes dans un projet : un code cohérent produit de meilleurs résultats, tandis que les défauts se propagent. Le rôle du développeur se déplace donc vers la recherche des bonnes abstractions, de la meilleure architecture et d’un modèle de domaine solide, que l’IA peut ensuite appliquer rapidement partout.

Retour d’expérience sur la modernisation en deux jours d’une application Node.js/Express vieille de dix ans avec Kiro et AWS Transform Custom. L’équipe automatise l’analyse du code, la montée de Node.js 14 à 22, la correction de failles, la migration MD5 vers bcrypt, le passage à async/await, la conteneurisation et l’infrastructure Terraform. Le bilan met en avant une forte réduction du coût et du délai, tout en conservant validation humaine, traçabilité et documentation.

Retour sur la deuxième journée de ParisWeb 2026 autour de l’accessibilité, du design et des pratiques de développement. Les conférences abordent le coût réel de l’accessibilité, les effets de standardisation des design systems, l’usage de la méthode scientifique pour diagnostiquer les bugs et les apports de l’IA pour compenser certains handicaps. Le fil conducteur : inscrire l’accessibilité dans la durée par la formation, la mesure des progrès et une responsabilité partagée.

L’auteur soutient que les mauvais résultats d’un agent de code ne viennent pas toujours du modèle : une architecture ambiguë lui fournit aussi de mauvais repères. À partir d’un exemple Symfony, il montre qu’une séparation claire entre domaine, application, infrastructure et interface, complétée par du DDD, des tests et des règles de dépendances vérifiables, réduit les choix implicites. L’objectif n’est pas de sur-architecturer, mais de rendre les responsabilités et contraintes suffisamment explicites pour les humains comme pour l’IA.