<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Jean-Christophe Bodin on Medium]]></title>
        <description><![CDATA[Stories by Jean-Christophe Bodin on Medium]]></description>
        <link>https://medium.com/@jchristophe.bodin_7853?source=rss-1409633c937e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Gej7kPZNqXix2uhWJ-KDAQ.jpeg</url>
            <title>Stories by Jean-Christophe Bodin on Medium</title>
            <link>https://medium.com/@jchristophe.bodin_7853?source=rss-1409633c937e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 02:06:55 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jchristophe.bodin_7853/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[La Foi ou les foies : quatre années à regarder l’IA grandir]]></title>
            <link>https://medium.com/@jchristophe.bodin_7853/la-foi-ou-les-foies-quatre-ann%C3%A9es-%C3%A0-regarder-lia-grandir-bb4b566bbea7?source=rss-1409633c937e------2</link>
            <guid isPermaLink="false">https://medium.com/p/bb4b566bbea7</guid>
            <category><![CDATA[digitale-transformation]]></category>
            <category><![CDATA[intelligence-artificielle]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[roi]]></category>
            <category><![CDATA[ia-générative]]></category>
            <dc:creator><![CDATA[Jean-Christophe Bodin]]></dc:creator>
            <pubDate>Mon, 08 Jun 2026 17:53:30 GMT</pubDate>
            <atom:updated>2026-06-08T18:10:12.428Z</atom:updated>
            <content:encoded><![CDATA[<h3>La licorne et la tortue numérique : quatre années à regarder l’IA grandir</h3><p>Le 1er juin 2026, GitHub Copilot a basculé sa facturation à la consommation. Du jour au lendemain, chaque token compte — entrée, sortie, cache. Certains développeurs ont vu leur facture passer de quelques dizaines à plusieurs centaines, parfois milliers de dollars par mois. La grogne a été immédiate, sur Reddit, sur X, jusque dans les forums de GitHub.</p><p>Depuis l’annonce officielle de GitHub, courant avril, j’avais pensé à la fable du Lièvre et de la Tortue, mais avec une issue tout autre. Je vais vous expliquer pourquoi.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QjDooZVS9beVxQF_PO2WCA.png" /></figure><h3>Ce que j’ai vu venir</h3><p>En 2022, quand la vague DALL·E a déferlé, j’ai compris qu’il se passait quelque chose. On parlait surtout d’images, de visuels surréalistes générés en quelques mots. Beaucoup y voyaient un gadget. Moi, j’ai commencé à suivre le sujet de près. Pas par hype — par intuition que la mécanique sous-jacente allait dépasser de loin la génération d’images.</p><p>Puis fin 2022, ChatGPT est arrivé, et comme tout le monde je l’ai essayé. La première version était bluffante et frustrante à la fois. J’ai tout de suite vu les gains qui allaient arriver pour le développement logiciel. Mais soyons honnêtes : c’était encore trop tôt. L’outil hallucinait, perdait le fil, produisait du code approximatif. Le potentiel était là, la maturité non.</p><p>C’est avec les modèles suivants que ça a basculé pour moi. Quand la qualité a franchi un cap, j’ai eu une conviction nette : dans quelques années, une IA serait capable de développer un logiciel entier — pas un système complet, mais un logiciel — sur la base d’une spécification rigoureuse, pilotée par la gestion d’exigences. J’ai d’abord cru au fine-tuning. J’ai essayé d’entraîner le modèle à respecter mes règles de développement et mes architectures. Les résultats étaient insuffisants. J’ai donc fait machine arrière et construit, fin 2024, ma propre petite bibliothèque de prompts en one-shot. Moins élégant sur le papier, infiniment plus efficace en pratique.</p><p>Début 2025, j’ai lu la documentation de Claude Code. Entre les commandes et le MCP, j’ai su que c’était l’outil d’avenir. Trois petites semaines d’essais et j’avais obtenu ce que je voulais de l’IA : du code respectant mon architecture, l’exécution du travail depuis un ticket Jira, la génération des tests — Postman inclus (<a href="https://medium.com/@jchristophe.bodin_7853/le-bilan-dun-mois-avec-claude-code-0d4d8e8c13eb">voir l’article s’y rapportant</a>). Je ne me suis pas trompé : aujourd’hui, un développeur expérimenté équipé de Claude Code et d’OpenSpec produit un logiciel — back ou front — à une vitesse qui aurait paru irréelle il y a deux ans, sans rien céder sur la qualité. Avec une meilleure qualité, même, je le dis sans hésiter.</p><p>Et la suite ? Elle est déjà en train d’arriver, peut-être même là, sous nos yeux : laisser une IA développer en autonomie un logiciel entier à partir d’une expression de besoin — à condition que celle-ci soit vraiment sèche. Exigences fonctionnelles. Exigences d’architecture. Exigences de sécurité. Le métier ne disparaît pas : il se déplace vers l’amont, vers la rigueur de la spécification.</p><p>Ça, c’est mon histoire. Et ma vision. Mais elle ne vaut rien sans le décor dans lequel elle se joue.</p><h3>Le marché, en trois actes</h3><p><strong>Acte I — La promesse (2022–2024).</strong> L’IA arrive avec ses promesses, et les géants s’emparent du sujet. Microsoft sort son carnet d’adresses en France et vend l’IA miraculeuse, celle qui va générer un ROI énorme, comme ça, sans effort. Sauf que l’IA n’est pas miraculeuse. Il faut comprendre comment elle fonctionne. Ce n’est pas magique. Et le vrai problème, le plus grave, c’est qu’il n’y a personne pour former. Les gens qui comprennent vraiment sont dans les laboratoires des universités et des grandes entreprises techniques américaines. Sur le terrain, le vide.</p><p><strong>Acte II — L’eldorado et ses mirages (2024–2026).</strong> Soudain, le marché se couvre d’« experts IA ». L’effet Dunning-Kruger tourne à plein régime : des débutants bricolent deux ou trois prompts et se croient rois. Ils ne le sont pas. Résultat ? Les entreprises qui ont acheté « le ChatGPT de l’entreprise » et paient au token ne voient pas le ROI. Les mauvais usages sont légion — j’en avais déjà fait l’inventaire dans <a href="https://medium.com/@jchristophe.bodin_7853/agent-conversationnels-nouveau-sujet-nouveau-chat-3d99fc8f930e">un autre article</a> de l’an dernier (<a href="https://medium.com/@jchristophe.bodin_7853/le-pi%C3%A8ge-de-la-simplicit%C3%A9-pourquoi-lia-demande-plus-d-effort-qu-on-ne-croit-f4db3b9774ae">ou encore</a>). D’autres prennent les abonnements à quelques dizaines d’euros (ChatGPT, Claude, Copilot à 20 $). Mais comme personne ne comprend vraiment, deux scénarios se déroulent en parallèle : ou bien les gens n’obtiennent pas ce qu’ils veulent et concluent que « la techno n’est pas mûre », ou bien ils surconsomment. Les entreprises doutent du ROI, veulent l’analyser, le mesurer — mais personne n’a jamais été formé. L’offre de formation est insuffisante, ou mal conçue. Alors on attend avant de déployer, ou bien on impose l’usage de l’IA par le haut. Et en bas, faute de formation, on ne sait pas s’en servir. Les abonnements dorment. Et quand l’usage au token décolle, il coûte trop cher.</p><p><strong>Acte III — La facture (2026).</strong> Malgré tout, l’usage progresse. Les freelances, les startups, les communautés s’en emparent massivement. Si massivement que les offres d’abonnement bon marché deviennent intenables pour ceux qui les éditent. Le modèle de licence change : de plus en plus d’entreprises basculent vers une facturation au token, de façon directe ou indirecte. La question du ROI devient brûlante. L’IA est remise en cause, y compris par de grandes structures. Le doute n’est plus marginal — il s’installe au sommet.</p><h3>Le vrai problème n’est pas technologique. Il est humain.</h3><p>Voilà ce que quatre années d’observation m’ont appris : le frein à l’adoption de l’IA n’est pas la technologie. C’est nous.</p><p>Les technologies avancent vite. Nos capacités d’adaptation, elles, sont terriblement limitées. Les plus de 50 ans peinent souvent à changer leurs pratiques. Les 25–35 ans sont presque trop jeunes : ils manquent parfois de l’expérience projet qui les rendrait audibles. Les 35–50 ans sont déjà installés dans leurs habitudes. À chaque génération sa résistance.</p><p>Et la vraie question, celle qu’on évite, est celle-ci : quelles sont réellement les capacités de formation sur ce marché ? Comment la montée en compétences est-elle assumée par les entreprises ? Les promesses sont énormes, mais les investissements en formation sont-ils à la hauteur des objectifs de ROI affichés ? Le piège se referme ici : si l’on ne croit pas au ROI, comment justifier l’investissement qui, précisément, le rendrait possible ? On attend la preuve avant de financer ce qui produirait la preuve.</p><h3>Le précédent qu’on connaît déjà : le cloud</h3><p>Si ce film vous semble familier, c’est normal. Nous l’avons déjà vu avec le cloud.</p><p>On a vendu une nouveauté très prometteuse. On n’avait personne pour former les gens, pour les faire monter en compétence. On a promis que le cloud coûterait moins cher. Puis on a fini par entendre qu’il coûtait plus cher. Et enfin, la vérité a émergé : on optimisait mal les solutions, on suivait mal les coûts, on multipliait les plateformes. Il a fallu inventer un métier entier pour reprendre le contrôle — le FinOps.</p><p>L’IA suit exactement la même courbe. La technologie n’a jamais été le problème. Le problème, c’est l’écart entre la vitesse de la promesse et la lenteur de notre apprentissage collectif. Et comme pour le cloud, ceux qui s’en sortiront ne seront pas ceux qui auront le mieux deviné l’avenir, mais ceux qui auront investi dans les compétences quand les autres attendaient.</p><h3>Pourquoi, cette fois, la Tortue perd</h3><p>C’est là que La Fontaine se retourne. Dans la fable d’origine, la lenteur réfléchie l’emporte sur la précipitation. Mais l’IA a changé la règle du jeu, parce qu’elle ne facture pas le résultat — elle facture le chemin. Le token. La seconde. Le mot. L’attention.</p><p>L’entreprise qui attend « que ce soit mûr » paie deux fois sa dette : d’abord le retard accumulé, ensuite l’inefficacité de ses équipes non formées quand elle se décide enfin. Pendant qu’elle reformule maladroitement des prompts romanesques pour des tâches simples, la concurrence, déjà aguerrie, cadre en trois lignes nettes. L’une économise ses tokens comme un boulanger sa farine. L’autre les brûle sous la pleine lune.</p><p>La vitesse, ici, n’est pas le contraire de la sagesse. Elle en est la condition — à une réserve près, décisive : il faut partir tôt, mais surtout partir bien formé. C’est exactement ce que dit cette fable, que je vous laisse en guise de conclusion (ps la vrai morale est en toute fin).</p><h3>La Licorne et la Tortue Numérique</h3><p><em>Librement inspiré de La Fontaine, dans le contexte de l’IA générative</em></p><p>La Licorne, vive et téméraire,</p><p>Avait, dès les premiers souffles du vent de l’IA,</p><p>Lancé ses équipes dans l’affaire :</p><p>Prompts, modèles, agents — tout y passa.</p><p>On la moquait parfois dans les salons feutrés :</p><p>« Brûler ainsi de l’argent pour des expériences !</p><p>Ces chatbots, ces gadgets bien surestimés —</p><p>Laissez passer la mode, gardez votre patience. »</p><p>La Tortue, elle, attendait. Prudente. Sérieuse.</p><p>« Nous irons quand ce sera mature,</p><p>Quand les standards seront clairs, la route bien tracée. »</p><p>Ainsi parlait-elle, grave et majestueuse,</p><p>Le front plissé sur sa belle procédure.</p><p>Les années passèrent. L’IA tint ses promesses.</p><p>Et voilà qu’un matin changea la donne :</p><p>Les éditeurs, lassés des licences en masse,</p><p>Basculèrent vers la facturation à la consommation.</p><p>À chaque token consommé — une pièce.</p><p>À chaque prompt approximatif — une fortune.</p><p>À chaque utilisateur mal formé — une faiblesse</p><p>Qui saigne le budget sous la pleine lune.</p><p>La Licorne sourit. Ses équipes, aguerries,</p><p>Savaient cadrer un prompt en trois lignes nettes,</p><p>Éviter les redites, les contextes qui s’étendent,</p><p>Les requêtes floues que le modèle réitère et perpète.</p><p>Ses utilisateurs, formés depuis longtemps,</p><p>Économisaient les tokens comme un bon boulanger</p><p>Économise sa farine — pas un gramme en trop,</p><p>Pas un mot inutile dans l’échange.</p><p>La Tortue, elle, arrivait enfin sur la piste.</p><p>« Nous y voilà ! Déployons sans tarder ! »</p><p>Mais ses équipes ignoraient la discipline du texte,</p><p>Et ses coûts, dès le premier mois, firent trembler.</p><p>Trop de contexte. Trop de reformulations.</p><p>Des prompts en prose romanesque pour des tâches simples.</p><p>L’IA répondait bien — mais à quel prix ?</p><p>Quelle addition ! Et pendant ce temps, la concurrence, leste et nimble…</p><p><strong>Morale</strong></p><p>Rien ne sert d’attendre : il faut partir à temps.</p><p>La lenteur, qu’on croyait sagesse, est ici perdition.</p><p>Car l’IA ne récompense pas les patients —</p><p>Elle facture à la seconde, au mot, à l’attention.</p><p>L’entreprise lente paie deux fois sa dette :</p><p>D’abord le retard, puis l’inefficacité.</p><p>Quand la Licorne court légère et nette,</p><p>La Tortue court vite… mais trop chère pour gagner.</p><p><em>« Il faut partir tôt, et partir bien formé. »</em></p><p>Au fond, la course actuelle départagera deux camps. Ceux qui auront <strong>la Foi</strong> — la conviction d’investir tôt, et d’investir dans les compétences. Et ceux qui auront <strong>les foies</strong> — qui, par peur du ROI introuvable, attendront le bon moment jusqu’à ce qu’il soit, justement, trop tard.</p><p>La technologie, elle, sera prête. La seule question qui reste : et nous ?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb4b566bbea7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kiro: A Prequel to AWS Lambda Spec?]]></title>
            <link>https://medium.com/@jchristophe.bodin_7853/kiro-a-prequel-to-aws-lambda-spec-85f0574a5289?source=rss-1409633c937e------2</link>
            <guid isPermaLink="false">https://medium.com/p/85f0574a5289</guid>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[code-generation]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[ai-development]]></category>
            <dc:creator><![CDATA[Jean-Christophe Bodin]]></dc:creator>
            <pubDate>Sat, 26 Jul 2025 22:49:23 GMT</pubDate>
            <atom:updated>2025-07-26T22:49:23.949Z</atom:updated>
            <content:encoded><![CDATA[<p>🇫🇷 *Cet article est également disponible en français <a href="https://medium.com/@jchristophe.bodin_7853/kiro-un-prequel-%C3%A0-aws-lambda-spec-643c52327ff2">ici</a>.</p><p>📝 *This article is an English adaptation of my original post in French, translated with the help of ChatGPT.*</p><p>Amazon recently launched <strong>Kiro</strong>, a development environment based on specifications. Behind its clean interface and a narrative focused on “developer efficiency” lies, in my opinion, a much broader strategy: using a <strong>spec-first IDE to feed an AI trained to generate code</strong>.</p><p>To me, this “free” release has a very clear purpose: <strong>prepare the ground for a future AWS service</strong> that will generate AWS Lambda functions <strong>without writing a single line of code</strong> — just from specs. This is where the industry is headed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yNK_3asR3VCJHZzv1zuO7w.png" /></figure><h3>Kiro, a spec-based interface for app generation</h3><p>Kiro, which you can explore at <a href="https://kiro.dev/">kiro.dev</a>, is presented as an AI-powered IDE where you design applications from <strong>structured specifications</strong>: endpoints, types, business logic, constraints — the AI can even help you write the specs.</p><p>In practice, you describe:</p><ul><li>the <strong>input/output interfaces</strong>,</li><li>the <strong>business rules</strong>,</li><li>the <strong>data entities</strong>,</li><li>and the <strong>expected behavior</strong>.</li></ul><p>And the AI generates the corresponding code: <strong>handlers, schemas, unit tests</strong>, etc. Kiro promises a smooth experience, where the <strong>specification becomes the development center</strong>, and the code becomes a commodity.</p><p>It appears to rely on <strong>Claude (Anthropic)</strong> under the hood, with support for the <strong>MCP protocol</strong> (which I now consider essential) and <strong>hooks</strong>. From their examples, I believe that <strong>redefining Claude Code’s system prompt</strong> could produce the same results.</p><p>So why would Amazon release this new tool — for free — when similar AI-based dev tools already exist?</p><h3>If it’s free, you are the product</h3><p>Let’s be honest: Kiro’s free tier isn’t a gift. Its true purpose seems obvious — to <strong>collect a massive database of real-world specifications</strong> tied to working implementations.</p><p>This dataset could train a future <strong>AWS-specialized AI model</strong>, optimized for generating Lambda functions from business specs. And Amazon already has <strong>all the building blocks</strong> to roll out a service I’d call “<strong>AWS Lambda Spec</strong>” in the next 12–18 months:</p><ul><li>✅ <strong>AWS Lambda</strong> for the runtime,</li><li>✅ <strong>Amazon Q</strong> for conversational assistance,</li><li>✅ <strong>CodeCommit</strong>, <strong>CodeBuild</strong>, <strong>CodePipeline</strong> for version control and CI/CD,</li><li>✅ <strong>Bedrock / Claude</strong> for generative AI.</li></ul><p>Kiro might just be <strong>a Trojan horse</strong> for a full <strong>spec-to-code ecosystem</strong> centered around Lambda.</p><p>And it’s worth noting: according to Kiro’s data usage policy, <strong>only Amazon Q Pro customers are exempt from their data being used</strong> to improve the tool.</p><h3>“AWS Lambda Spec” — A future (almost) free service?</h3><p>Imagine a service layered on top of AWS Lambda.</p><p>You’d pick a <strong>function template</strong>: CRUD, data processing, stream handler, etc.</p><p>Then you’d specify:</p><ul><li>the <strong>input/output interfaces</strong> (e.g., JSON Schema),</li><li>the <strong>business logic</strong>,</li><li>the <strong>logging strategy</strong>,</li><li>the <strong>error handling policies</strong> (retry, DLQ…),</li><li>the <strong>test rules</strong> and <strong>key test cases</strong> to validate behavior.</li></ul><p>Two specialized AI agents would then take over:</p><ul><li>One generates the Lambda <strong>source code</strong>.</li><li>The other builds the <strong>test suite</strong>, with test data — basically, a full test harness.</li></ul><p>Everything gets wired into a <strong>CI/CD pipeline</strong>, no human intervention needed. All that’s left is an <strong>“ArchiDevOps”</strong> to orchestrate generation, validation, and deployment.</p><p>As for pricing? Think <strong>Elastic Beanstalk-style</strong>: you only pay for the underlying services — including AI usage through Bedrock.</p><h3>But isn’t this already possible, in some way?</h3><p>Honestly? Yes — to a certain extent.</p><p>With <strong>Claude Code</strong>, I’ve already experimented with a similar approach:</p><ul><li>Creating a <strong>prepared Git repository</strong> with a claude.md spec file,</li><li>Using prompts to <strong>incrementally generate code files</strong> based on functional specs,</li><li>Even syncing with tools like <strong>Jira or Confluence</strong> to drive iterations,</li><li>Doing the same for the <strong>test suite</strong>.</li></ul><p>And the most powerful idea? You could dynamically change <strong>the cloud provider</strong> or even <strong>the programming language</strong> by adjusting a spec:</p><blockquote><em>Ex-001: Target environment is AWS / GCP / Azure</em></blockquote><blockquote><em>Ex-002: Language must be JS, Java, Go, .NET…</em></blockquote><blockquote><em>Ex-003: Input JSON must follow structure: { … }</em></blockquote><blockquote><em>Ex-004: Business rule validation: must enforce condition X</em></blockquote><p>I love these kinds of challenges — but will I have time to push it further?</p><h3>The end of artisanal code is near</h3><p>Since the release of <strong>ChatGPT 3.5</strong>, I’ve been convinced that the future of development lies in <strong>specifications, not code</strong>.</p><p>That’s how I’ve structured my work with Claude Code:</p><ul><li>A <strong>predefined software architecture</strong>,</li><li>Prompts to <strong>describe behavior</strong>,</li><li>Code <strong>incrementally generated</strong> as specs evolve.</li></ul><p>Amazon’s launch of Kiro only reinforces this view: <strong>some Lambda functions will soon be created without a single line of human-written code</strong>. We may even see <strong>large microservice architectures generated this way</strong>.</p><p>But let’s be realistic:</p><p><strong>No AI today can take a complete requirements document and generate an entire system in one go.</strong></p><p>What does work:</p><ul><li>Start with a <strong>technical skeleton</strong> (e.g., Lambda template),</li><li><strong>Add features incrementally</strong> via prompts or commands,</li><li>Let a <strong>test-specialized AI</strong> develop and validate the tests.</li></ul><h3>But wait… isn’t this just the V-model again?</h3><p>Let’s think about it.</p><p>You define the requirements, validate the spec, generate the code, and then build the test plan.</p><p>Sounds familiar?</p><p>Yes — <strong>this is just the V-Model</strong>, powered by AI.</p><p>Except this time, it’s <strong>not developers</strong> moving through the phases —</p><p>It’s a team of <strong>orchestrated AI agents</strong>, led by an ArchiDevOps.</p><p>And maybe… that’s the future of software engineering.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=85f0574a5289" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kiro : un prequel à AWS Lambda Spec ?]]></title>
            <link>https://medium.com/@jchristophe.bodin_7853/kiro-un-prequel-%C3%A0-aws-lambda-spec-643c52327ff2?source=rss-1409633c937e------2</link>
            <guid isPermaLink="false">https://medium.com/p/643c52327ff2</guid>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[ai-development]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[code-generation]]></category>
            <dc:creator><![CDATA[Jean-Christophe Bodin]]></dc:creator>
            <pubDate>Sat, 26 Jul 2025 22:36:02 GMT</pubDate>
            <atom:updated>2025-07-26T22:50:32.778Z</atom:updated>
            <content:encoded><![CDATA[<h3>Kiro : un prequel à AWS Lambda Spec ?</h3><p>🇬🇧 *This article is also available in <a href="https://medium.com/@jchristophe.bodin_7853/kiro-a-prequel-to-aws-lambda-spec-85f0574a5289">English here</a>.</p><p>Amazon vient de lancer <strong>Kiro</strong>, un environnement de développement basé sur les spécifications. Derrière une interface épurée et un discours d’accompagnement orienté “efficacité pour les développeurs”, <strong>se cache une stratégie bien plus large</strong> : utiliser un IDE orienté <strong>spec-first</strong> pour nourrir une IA de génération de code.</p><p>À mes yeux, ce lancement gratuit n’a qu’un seul objectif : <strong>préparer le terrain pour un futur service AWS</strong>, qui permettra de générer des <strong>AWS Lambda functions</strong> sans écrire une seule ligne de code. Juste en <strong>écrivant des specs</strong>. Une tendance inévitable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yNK_3asR3VCJHZzv1zuO7w.png" /></figure><h3>Kiro, une interface de specs pour la génération d’applications</h3><p>Kiro, que vous pouvez retrouver sur <a href="https://kiro.dev/">kiro.dev</a>, est présenté comme un IDE intelligent piloté par l’IA, où l’on conçoit des applications à partir de <strong>spécifications structurées</strong> : endpoints, types, logiques métier, contraintes — l’ia peut même vous générer les specs.</p><p>En pratique, vous décrivez :</p><ul><li>les <strong>interfaces d’entrée/sortie</strong>,</li><li>les règles métier,</li><li>les entités,</li><li>et les comportements attendus.</li></ul><p>Et l’IA <strong>génère le code correspondant</strong> : handlers, schemas, tests unitaires, etc. Kiro promet une <strong>expérience fluide</strong>, où la spécification devient le cœur de la programmation, et le code, une commodité.</p><p>Le modèle sous-jacent semble être <strong>Claude</strong> (Anthropic) et on retrouve notamment le support du protocole MCP (indispensable aujourd’hui à mon avis) et les hooks. Lorsque je regarde leurs exemples, je me dis qu’en redéfinissant le System Prompt de Claude Code, on doit obtenir le même résultat. Il y a aujourd&#39;hui beaucoup de solutions pour développer avec l’IA. Quel intérêt a Amazon, de proposer ce nouveau produit, qui plus est gratuitement?</p><h3>Si c’est gratuit, c’est que vous êtes le produit</h3><p>La gratuité de Kiro ne doit tromper personne. Le véritable objectif, à mon avis, est clair : <strong>constituer une base de données de spécifications réelles</strong> couplées à leurs implémentations.</p><p>Cette base nourrira <strong>le futur modèle IA d’AWS</strong>, spécialisé dans la <strong>génération de fonctions Lambda</strong> à partir de specs métier. Et Amazon a déjà toutes les briques en place pour proposer <strong>“AWS Lambda Spec”</strong> d’ici 12/18 mois:</p><ul><li>✅ <strong>AWS Lambda</strong> pour le runtime serverless,</li><li>✅ <strong>Amazon Q</strong> pour l’agent conversationnel intégré,</li><li>✅ <strong>CodeCommit</strong>, <strong>CodeBuild</strong>, <strong>CodePipeline</strong> pour le versioning, build et CI/CD,</li><li>✅ <strong>Bedrock / Claude</strong> comme LLM génératif.</li></ul><p>Kiro pourrait n’être que le <strong>cheval de Troie</strong> d’un écosystème complet orienté “spec-to-code” particulièrement au dessus d’AWS Lambda.</p><p>D’ailleurs les informations sur l’utilisation des données sont indiquées <a href="https://kiro.dev/docs/reference/privacy-and-security/#kiro-content-used-for-service-improvement">ici</a>. Seuls les clients Amazon Q Pro ne verront pas leurs données utilisées pour améliorer Kiro.</p><h3>“AWS Lambda Spec” — un futur service gratuit, ou presque?</h3><p>Imaginez ce service comme une <strong>surcouche de Lambda</strong>.</p><ul><li>Vous choisissez le <strong>type de Lambda</strong> à générer : CRUD, traitement, etc.</li></ul><p>Vous spécifiez :</p><ul><li>les <strong>interfaces d’entrée/sortie</strong> (ex. JSON schema),</li><li>les règles de <strong>traitement</strong> métier,</li><li>les <strong>stratégies de logging</strong>,</li><li>les <strong>politiques d’erreur</strong> (retry, DLQ…),</li><li>les <strong>règles de tests</strong> à appliquer</li><li>et les <strong>tests clés</strong> pour valider le comportement attendu.</li><li>…..</li></ul><p>Ensuite, <strong>deux agents IA</strong> se partagent le travail :</p><ul><li>L’un génère <strong>le code source de la Lambda</strong>.</li><li>L’autre génère <strong>les tests unitaires et d’intégration</strong>, avec jeux de données — un banc de test quoi!</li></ul><p>Le tout s’intègre dans une <strong>chaîne CI/CD</strong>, sans intervention humaine. Il ne reste plus qu’un <strong>“ArchiDevOps”</strong> pour orchestrer la génération, les validations et le déploiement.</p><p>Côté tarification ? Un modèle à la Elastic Beanstalk : vous ne payez que les services sous-jacents — notament l’IA via Bedrock.</p><h3>Est-ce que ce n’est pas déjà possible, en fait ?</h3><p>La vérité ? <strong>Ce modèle me semble déjà à portée de main.</strong> Avec un outil comme Claude Code, j’ai pu expérimenter une approche similaire.</p><p>Pour aller plus loin il faudrait:</p><ul><li>Créer un dépôt git préparé Claude Code avec le claude.md et les commandes idoines,</li><li>une logique d’itérations par exigence métier, voire synchronisée avec Jira ou Confluence,</li><li>Faire la même chose pour les tests</li></ul><p>L’aboutissement serait que la solution permette de changer de Cloud Provider ou même de langage de développement sur la base du changement d’une exigence:</p><ul><li>Ex-001 : l’environnement cible est <strong>AWS</strong> — GCP — AZURE</li><li>Ex-002 : le traitement doit être réalisé en js, <strong>Java</strong>, Go, Ruby,. NET</li><li>Ex-003 : le traitement doit prendre en entrée un json au format suivant: { ……..}</li><li>Ex-004 : le traitement doit vérifier telle condition…….</li><li>…..</li></ul><p>Bref, la promesse est là. Reste à savoir si j’aurai le temps de pousser l’expérimentation à fond…</p><h3>La fin du code artisanal approche</h3><p>Depuis l’arrivée de ChatGPT 3.5, je suis convaincu que l’avenir du développement passera par les spécifications. J’imaginais déjà un futur <strong>“Requirement-Based Development”</strong>, où l’on écrit les besoins métier plutôt que le code lui-même.</p><p>C’est dans cet esprit que j’ai structuré mon usage de Claude Code :</p><ul><li>une <strong>architecture logicielle prédéfinie</strong>,</li><li>des <strong>commandes spécifiques</strong> pour exprimer les intentions,</li><li>des <strong>ajouts incrémentaux</strong> de logique métier.</li></ul><p>La sortie de <strong>Kiro</strong> par Amazon est une <strong>confirmation</strong>: nous allons vers un monde où certaines <strong>fonctions Lambda</strong> seront générées <strong>sans jamais taper de code — au point de pouvoir créer des architectures importantes à base de micro services non codée par l’homme????</strong></p><p>Mais soyons clairs : <strong>demander à une IA de tout générer d’un bloc à partir d’un document d’exigence complet ne fonctionnera pas</strong>. Ni aujourd’hui, ni dans un futur proche.</p><p>Ce qui fonctionne :</p><ul><li>Partir d’un <strong>squelette technique</strong> (cf. type de Lambda),</li><li>Construire <strong>incrémentalement les fonctionnalités</strong>,</li><li>Et confier les tests à une IA <strong>spécialisée sur ce type de fonction</strong>.</li></ul><p>C’est ça, la vraie promesse d’une approche basée sur les specs.</p><h3>Mais au fond… ce n’est pas le grand retour du cycle en V ?</h3><p>Et si l’on y réfléchit : écrire d’abord les specs, faire valider les exigences, générer le code et les test, dérouler les tests…</p><p>C’est exactement la logique du <strong>cycle en V</strong>, version augmentée par l’IA.</p><p>Sauf que cette fois, ce ne sont <strong>plus des développeurs</strong> qui passent d’une étape à l’autre…</p><p>Mais des <strong>agents IA</strong> coordonnés par des ArchiDevOps.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=643c52327ff2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Faut-il tester les logs ? Une question d’exigence logicielle]]></title>
            <link>https://medium.com/@jchristophe.bodin_7853/faut-il-tester-les-logs-une-question-dexigence-logicielle-f0256970df4c?source=rss-1409633c937e------2</link>
            <guid isPermaLink="false">https://medium.com/p/f0256970df4c</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[observability]]></category>
            <dc:creator><![CDATA[Jean-Christophe Bodin]]></dc:creator>
            <pubDate>Thu, 10 Jul 2025 08:22:37 GMT</pubDate>
            <atom:updated>2025-07-10T08:23:09.342Z</atom:updated>
            <content:encoded><![CDATA[<h3>Faut-il tester les logs ? Une question d’exigence logicielle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j1fO_lbpy-Drf_oJm8uhvg.png" /></figure><p>Dans une précédente mission, j’ai été amené à développer les tests d’un BFF. Comme j’avais l’IA sous le coude, j’en ai profité pour également tester certains logs. Cela a suscité différents débats au sein de l’équipe, pour ne pas dire quelques railleries. Ce souvenir m’amène aujourd’hui à écrire sur le sujet afin d’alimenter la réflexion et, pourquoi pas, bousculer certaines habitudes.</p><h3>Mon passé de responsable de développement dans l’industrie</h3><p>J’ai passé près de 20 ans dans l’industrie, et je cherche aujourd’hui à trouver ma place dans le monde des DSI. C’est une démarche enrichissante, mais pas sans difficultés : on change de culture, de vocabulaire, parfois de rythme.</p><p>Dans l’industrie, on utilise depuis très longtemps l’ingénierie des exigences. C’est un élément central de la gestion d’un projet et les exigences ne servent pas qu’à définir le produit. Dès l’établissement du contrat, le client exprime ses besoins sous la forme d’exigences de différents types :</p><ul><li><strong>management</strong> : documentation, livrables, jalons,</li><li><strong>qualité</strong> : performance, disponibilité, fiabilité</li><li><strong>fonctionnelles</strong> : ce que doit faire le produit,</li><li><strong>maintenance</strong> : capacité à diagnostiquer et corriger rapidement un problème,</li><li>et d’autres encore (sécurité, réglementation, etc.).</li></ul><p>Cette approche est au cœur de référentiels reconnus comme IEEE 12207, qui structure le cycle de vie logiciel, ou encore CMMI, où la gestion des exigences fait l’objet d’un domaine de processus dédié (REQM — Requirements Management).</p><p>Elle est également défendue dans des cadres méthodologiques comme <strong>TOGAF</strong>, où la <strong>gestion des exigences</strong>(<em>Requirements Management</em>) est considérée comme un <strong>processus transversal</strong> essentiel. Elle permet de s’assurer que chaque décision prise, à chaque étape de la transformation d’un SI, répond à un besoin formellement identifié, traçable, et surtout vérifiable. Constater la place centrale du Requirements Management dans TOGAF m’a conforté dans une conviction : lorsque l’on parle de développement et de maintenance d’un système d’information, qu’il s’agisse d’un SI industriel, d’un système de contrôle commande ou d’un SI d’entreprise on revient toujours aux mêmes fondamentaux.<br>Quel que soit le domaine, un SI doit être compris, maîtrisé, maintenu. Et pour cela, il faut que les exigences soient clairement formulées, tracées, testées.</p><p>Ayant pratiqué l’exercice de la gestion et la planification d’exigences pendant 15 ans, je suis un peu “formaté” par cette approche, ce qui m’amène au sujet de l’observabilité dans les systèmes d’information modernes.</p><h3>Origine des exigences et pertinence d’avoir des exigences d’observabilité</h3><p>Lorsqu’on conçoit un Système d’Information, on commence par identifier les utilisateurs et leurs usages. Cela mène à la définition des exigences et/ou des use cases. Dans l’industrie de la défense, j’ai eu l’habitude de voir chaque exigence déclinée en un ou plusieurs use cases, eux-mêmes vérifiés par des tests.</p><p>Je simplifie bien sûr, car il faut décomposer le SI en sous-systèmes, puis en éléments logiciels, qui eux vont implémenter les use cases et les tester.</p><p>Quand on identifie les use cases, on pense spontanément aux utilisateurs finaux : clients, agents, gestionnaires. Dans une banque ou une assurance, ce sont ceux qui consultent ou gèrent les contrats. Dans l’industrie ce sont généralement les utilisateurs finaux des produits.</p><p>Mais on oublie souvent les acteurs de la maintenance : les <strong>développeurs</strong> et <strong>DevOps, agents de maintenances</strong>. J’utilise d’ailleurs volontairement le mot <em>acteur</em>, car en UML, c’est ainsi qu’on appelle tout ce qui interagit avec le système. On peut faire le rapprochement avec les User story que l’on retrouve en agilité. L’objectif est similaire, définir un besoin répondant à une exigence produit puis l’implémenter et la vérifier.</p><p>Ces acteurs ont des besoins clairs : logs, traces, métriques. Sans une bonne observabilité, impossible de diagnostiquer un incident, de suivre les performances, ou de comprendre un comportement anormal. <strong>L’observabilité est donc une exigence à part entière qui permet de répondre aux besoin de maintenance du SI.</strong></p><h3>Quels types d’exigences d’observabilité, et comment les tester ?</h3><p>Je ne suis pas un spécialiste DevOps à proprement parler, mais plutôt un ingénieur issu du monde du cycle de vie logiciel, avec une culture des exigences et de leur traçabilité. Pourtant, dès qu’on discute avec des équipes d’exploitation ou de supervision, on tombe vite d’accord sur un socle commun d’exigences d’observabilité — simples, mais fondamentales et indépendantes des technologies employées.</p><p>Voici quelques pistes de déclinaisons testables :</p><p><strong>Logs</strong> :</p><ul><li>Format structuré (JSON, niveaux standardisés)</li><li>Niveaux standardisés : INFO, WARN, ERROR, sans abus ni confusion.</li><li>Présence obligatoire de traceId, userId, etc.</li><li>Aucun log d’erreur silencieux</li><li>Log d’erreur toujours accompagné de la cause racine (si possible)</li><li>Pas de donnée sensibles: adresses e-mail, tokens, mots de passe doivent être masqués ou absents.</li></ul><p><strong>Métriques</strong> :</p><ul><li>Exposition de compteurs/clocks (temps de réponse, taux d’erreur)</li><li>Métriques business clés (nombre de documents produits, etc.)</li></ul><p><strong>Traces</strong> :</p><ul><li>Propagation correcte des contextes</li><li>Existence d’un span pour chaque use case majeur</li></ul><p>Ces exigences peuvent faire l’objet de tests automatisés :</p><ul><li>Tests unitaires sur les logs produits</li><li>Tests d’intégration qui capturent et analysent les logs ou les métriques exposées</li><li>Linters pour vérifier les appels au logger</li><li>interdiction d’appels consoles directes comme System.out.println en java, concaténations ou niveaux inadaptés</li></ul><h3>Quel coûts de mise en œuvre ?</h3><p><strong>Impact faible</strong> si la couverture de tests unitaires est déjà bonne et qu’une stratégie de test d’intégration automatisée est aussi mise en oeuvre:</p><ul><li>Les logs d’erreur peuvent être testés dans les tests existants</li><li>Les warnings sont souvent liés à des branches de code particulières, donc testables</li><li>Les logs d’info s’insèrent dans les cas nominaux</li></ul><p><strong>Coût supplémentaire</strong> : instrumentation des tests pour capturer/analyser les logs, mock des loggers</p><p><strong>Tests de métriques</strong> : un peu plus complexes, mais faisables en intégration avec Prometheus ou un endpoint custom</p><h3>Quel ROI ?</h3><p>Le <strong>retour sur investissement </strong>de tests liés à l’observabilité est toujours difficile à quantifier précisément. Ce ne sont pas des métriques de productivité immédiate comme on en cherche principalement lorsque l’on parle de ROI.</p><p>Voici quelques bénéfices concrets attendus :</p><ul><li><strong>Fiabilité accrue</strong> : des logs cohérents, structurés et testés rendent le système beaucoup plus « <em>debuggable</em> ». On identifie plus vite les causes réelles des incidents, sans tâtonner.</li><li><strong>Gain de temps</strong> : les diagnostics sont plus rapides et plus fiables. Moins de temps perdu à croiser des logs ambigus ou à chercher un traceId inexistant.</li><li><strong>Conformité RGPD</strong> : en validant les règles sur la présence ou l’anonymisation des données sensibles (emails, IP, tokens…), on réduit le risque de fuite, et on est capable de fournir des preuves concrètes en cas d’audit de part la politique de gestion des log dés la conception du SI.</li><li><strong>Crédibilité renforcée</strong> : un SI avec des <strong>exigences d’observabilité clairement définies et testées</strong> inspire confiance — pour les équipes internes, pour les partenaires, et pour les auditeurs sécurité ou conformité.</li></ul><h3><strong>Conclusion</strong></h3><p>Il est temps de mettre les Dev et les DevOps à contribution pour définir des exigences d’observabilité claires et vérifiables, au même titre que celles qu’on applique déjà pour la performance, la sécurité ou la conformité.</p><p>Ce n’est pas un luxe, ni une surcouche. C’est une évolution naturelle de la qualité logicielle dans un monde où les systèmes sont de plus en plus distribués, critiques et réglementés.</p><p>Oui, c’est un changement culturel.<br>Mais c’est surtout une opportunité d’amélioration continue : mieux tester, mieux diagnostiquer, mieux opérer.<br>Et, au final, mieux servir tous les utilisateurs du système… y compris ceux qui le maintiennent.</p><p>⸻</p><p>🎯 Ma position est claire : il faut tester les logs important.<br>Pas seulement les erreurs critiques, mais aussi les logs d’information, les warnings, et tout ce qui contribue à la compréhension du comportement du système.<br>Parce qu’un log, c’est une interface interne. Et une interface, ça se teste.</p><p>Je sais que ce point de vue ne fera pas l’unanimité.<br>Mais justement, c’est une discussion qui mérite d’avoir lieu.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f0256970df4c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Agents IA pour le code: l’approche diviser pour régner plus que jamais d’actualité]]></title>
            <link>https://medium.com/@jchristophe.bodin_7853/agents-ia-pour-le-code-lapproche-diviser-pour-r%C3%A9gner-plus-que-jamais-d-actualit%C3%A9-a0473086ed09?source=rss-1409633c937e------2</link>
            <guid isPermaLink="false">https://medium.com/p/a0473086ed09</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Jean-Christophe Bodin]]></dc:creator>
            <pubDate>Mon, 30 Jun 2025 20:52:26 GMT</pubDate>
            <atom:updated>2025-07-07T20:09:34.841Z</atom:updated>
            <content:encoded><![CDATA[<p>Cela fait maintenant trois mois que j’utilise Claude Code pour développer un SaaS. Ces trois mois m’ont permis de bien appréhender ce qui fonctionne et ce qu’il faut éviter. La conclusion la plus claire que j’ai à partager sur l’utilisation des agents IA pour le code, c’est que l’approche <em>diviser pour régner</em> est plus que jamais d’actualité.</p><h3>Pourquoi de petites tâches sont plus efficaces avec l’IA</h3><p>Afin d’expliquer cela, une image me vient en tête:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/923/1*ykyEmwEf8_oMRvT1XNzXqg.png" /><figcaption>Réalisation d’un développement par décooupage en sous tâche</figcaption></figure><p>L’idée est que si l’on cherche à réaliser une tâche par l’IA, celle-ci va évoluer selon les consignes qu’on lui donne, tout en étant bornée (plus ou moins) par le contexte de la commande.</p><p>Dans les schémas ci-dessus, le cône (projeté) définit les limites et contraintes imposées par le contexte (les commandes Claude Code + les données qu’il a pour consigne de prendre en compte).</p><p>La ligne horizontale, en bleu, peut être vue comme le chemin idéal qui serait suivi par un humain. En rouge, on peut voir le chemin suivi par le modèle, qui est inévitablement différent de celui de l’humain.</p><p>Si cette image est suffisamment représentative, alors on comprend vite que plus la tâche est longue et moins le contexte est contraignant, plus le résultat risque de s’écarter de l’attendu.</p><p>Mais alors, ne faut-il pas simplement renforcer le contexte avec plus de contraintes ? En fait, je ne le pense pas : cela pourrait être très difficile d’identifier tout ce qui influence la génération des différentes parties, et certaines contraintes pourraient même entrer en contradiction.</p><p>Maintenant, si l’on découpe cette tâche en plusieurs tâches plus petites, à chaque étape, on comprend rapidement qu’on peut définir des contextes plus restreints et plus proches du besoin, et ainsi obtenir plusieurs bons résultats.</p><p>Ces petites tâches cumulées permettent alors d’obtenir facilement le résultat attendu.</p><h3>Première illustration: ma méthode de développement back-end</h3><p>Dans mon premier article sur Claude Code, j’ai expliqué comment j’avais industrialisé les développements back-end de ma solution technique.</p><p>Depuis plusieurs mois, j’essayais de faire générer par l’IA le code que je n’avais plus envie d’écrire moi-même.</p><p>Dans un premier temps, j’avais tenté d’améliorer le modèle via du fine-tuning, en m’appuyant sur mon propre code. Les résultats obtenus étaient corrects, mais largement en dessous de ce que je cherchais à atteindre.</p><p>Par la suite, j’ai obtenu de bien meilleurs résultats en fournissant à ChatGPT un prompt contenant les classes modèles, afin qu’il reproduise le pattern avec ma spécification pour de nouvelles entités.</p><p>J’utilisais alors trois prompts différents, qui me permettaient de faire générer par l’IA les classes de mes trois couches. Il ne me restait plus qu’à faire les copier-coller depuis ChatGPT vers IntelliJ.</p><p>Naturellement, lorsque j’ai commencé à utiliser Claude Code, je me suis basé sur ce même fonctionnement. J’ai donc créé trois commandes Claude, chacune chargée de générer un type de classe.</p><p>L’amélioration majeure a été de pouvoir identifier, dans ces commandes, les fichiers à prendre comme modèles (ce que j’ai appelé les <em>Golden Classes</em>).</p><p>Le contexte de génération n’était donc plus alimenté par une seule classe de référence, mais par trois classes de référence pour chaque type, renforçant ainsi l’influence de ces exemples.</p><p>Cette approche ne faisait finalement que reproduire ce que tout développeur expérimenté fait instinctivement dans ce genre de situation : coder les différentes parties de la stack les unes après les autres en suivant un modèle connu.</p><p>Grâce à cela, j’ai obtenu très rapidement de bons résultats. Chaque commande ne générait qu’un nombre limité de classes ou de fichiers, ce qui réduisait les risques de dérive.</p><p>L’IA ne pouvait pas vraiment “s’égarer” dans le développement, et le résultat était très proche de ce que j’aurais codé moi-même.</p><h3><strong>Seconde illustration: création de 2 AWS Lambda fonctions</strong></h3><p>Durant ce mois de juin, j’ai été amené à créer deux fonctions AWS Lambda. C’était la toute première fois que je développais une application de ce type, et cela s’est fait très facilement en passant à l’IA les demandes suivantes :</p><ul><li>Initialise le projet pour générer une Lambda</li><li>Mets à jour la Lambda pour qu’elle prenne ses entrées au format JSON (fichiers de référence présents dans le répertoire)</li><li>Ajoute un premier traitement pour éviter les <em>prompt injections</em> dans le champ context des inputs</li><li>Ajoute l’appel au modèle d’IA pour obtenir le résultat du traitement</li><li>Ajoute l’appel au modèle d’IA pour la modération du résultat</li><li>Appelle le back-end pour mettre à jour les compteurs de crédits et l’état d’avancement de la génération</li><li>Appelle la création du PDF à envoyer au demandeur</li><li>Appelle l’émission de l’email avec SNS, en pièce jointe le PDF</li><li>Ajoute les traces nécessaires pour alimenter correctement CloudWatch</li><li>Génère la documentation complète du fonctionnement de cette Lambda (notamment ses interfaces)</li><li>Génère la documentation pour l’intégration sur AWS</li></ul><p>Et voilà : en approximativement trois heures, j’ai obtenu une Lambda qui réalise le cœur du service de mon SaaS.</p><p>J’ai ensuite procédé de la même manière pour une seconde Lambda, dont l’objectif est d’utiliser l’IA pour générer les données servant d’input à la première Lambda. Là encore, le temps de travail a été d’environ trois heures.</p><p>Notez au passage que, durant ces heures, c’était surtout Claude qui travaillait. Moi, je surveillais… pour ne pas dire que je procrastinais entre deux baignades.</p><p>Maintenant, un point qu’il ne faut jamais oublier : le <strong>coût</strong>.</p><p>Eh bien, je trouve cela tout à fait concurrentiel, puisque j’ai dépensé environ <strong>22 €</strong> pour ces deux Lambdas.</p><h3>Conclusion — Divide and Conquer</h3><p>L’approche <em>diviser pour régner</em> reste bel et bien d’actualité.</p><p>Demandez des tâches trop vastes et trop peu contraintes à une IA, et vous n’obtiendrez qu’un résultat médiocre — au regard de vos attentes. Cela ne veut pas dire que le code généré ne fonctionnera pas. Mais si vous n’êtes pas précis, vous risquez d’avoir un résultat techniquement correct, mais conceptuellement à côté de la plaque.</p><p>D’un autre point de vue, c’est exactement la même problématique avec un développeur humain. Si vous lui demandez de réaliser une tâche longue sans être précis sur ce dont vous avez besoin, il aura beaucoup de latitude… et vous avez toutes les chances d’obtenir quelque chose de fonctionnel mais éloigné de ce que vous attendiez.</p><p>Cela me conforte dans l’idée suivante : pour obtenir de <strong>bons résultats avec l’IA</strong>, et donc de <strong>bonnes performances économiques</strong>, les recettes classiques restent valables :</p><ul><li>prendre le temps de formaliser un <strong>besoin clair</strong>,</li><li>aller vers une <strong>conception précise</strong>,</li><li><strong>découper</strong> la réalisation en <strong>tâches courtes</strong> avec des <strong>spécifications précises</strong>.</li></ul><p>Dans ce cadre, <strong>JIRA</strong> (ou un autre gestionnaire de tâches) devient un outil idéal pour <strong>spécifier les tâches</strong> et les <strong>faire exécuter par l’IA</strong>.</p><p>Le développeur humain reste bien sûr <strong>dans la boucle</strong> — au moins encore un ou deux ans.</p><h3>La prochaine question que je me pose est la suivante:</h3><blockquote><strong><em>Serait-il possible de réaliser ce type de tâche (comme la création d’une Lambda, décrite plus haut) uniquement à l’aide d’un agent autonome, exécuté en CI ?</em></strong></blockquote><p>Et si je parviens à le faire, <strong>puis-je reproduire strictement le même comportement in/out</strong> en exécutant cette CI plusieurs fois de suite ?</p><p>Et enfin :</p><blockquote><strong><em>Comment standardiser cette approche ?</em></strong></blockquote><p><em>Ces questions ouvrent la voie à de nouvelles expérimentations.</em></p><p><em>Peut-être les réponses… dans un prochain article.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a0473086ed09" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Claude Code: Mois 2 et … les nouveautés Anthropic]]></title>
            <link>https://medium.com/@jchristophe.bodin_7853/claude-code-mois-2-et-les-nouveaut%C3%A9s-anthropic-5f3b43c1a6f0?source=rss-1409633c937e------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f3b43c1a6f0</guid>
            <dc:creator><![CDATA[Jean-Christophe Bodin]]></dc:creator>
            <pubDate>Tue, 10 Jun 2025 21:18:36 GMT</pubDate>
            <atom:updated>2025-06-10T21:23:02.945Z</atom:updated>
            <content:encoded><![CDATA[<h3>Claude Code: Mois 2 et … les nouveautés Anthropic</h3><p>J’ai commencé à utiliser Claude Code le 20 mars. Entre cette date et fin avril, j’ai appris à maîtriser ce nouvel outil et j’ai optimisé mon processus de développement, et la création automatique de tests postman (voir l’article précédent <a href="https://medium.com/@jchristophe.bodin_7853/le-bilan-dun-mois-avec-claude-code-0d4d8e8c13eb">https://medium.com/@jchristophe.bodin_7853/le-bilan-dun-mois-avec-claude-code-0d4d8e8c13eb</a>).</p><p>En mai, j’ai utilisé l’IA d’une toute autre façon: l’IA est devenu mentor pour l’apprentissage de Kubernetes et d’AWS — jusqu&#39;à l’arrivée du nouveau modèle Claude Sonnet 4.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WJzZsSowGcG_QIPz.png" /></figure><h3>Claude Code comme mentor</h3><p>Sur le plan DevOps, j’ai quelques bases sans plus. Donc, par pragmatisme, j’ai d’abord commencé par des formations sur Coursera; cela permet de poser les concepts avant d’aller <em>se salir les mains</em>.</p><p>Une fois les concepts posés, j’ai l’habitude de me confronter directement à ce qui correspond à mon besoin, c’est exigent, mais je me confronte aux difficultés et j’apprends plus vite.</p><p>Cependant, ayant Claude Code sous la main, un petit lien symbolique vers le dépôt git qui contient l’ensemble du projet en mode <em>docker-compose </em>permet à Claude d’avoir une référence de l’intégration système. Une petite demande à Claude me permet ainsi de créer les de créer les manifests pour les volumes, les secrets, les pods … pour l’un des services. Et cela marche plutôt pas mal, un petit déploiement sur mon Minikube et je peux commencer à jouer avec mon “cluster”. Tester pour comprendre, puis re-tester pour approfondir, mais toujours Claude pour challenger et comprendre en profondeur.</p><p>Soyons réaliste: la montée en compétence k8s et AWS me demandera encore au moins 6 mois. Un projet ambitieux est enthousiasmant, mais il est souvent plus judicieux de finaliser d’abord une version plus modeste qui prouve la valeur de l’idée … Mais cela j’y reviendrai en fin d’article.</p><h3>Le 22 mai, Anthropic sort un nouveau Claude de sa manche</h3><p>Anthropic a annoncé la sortie de Claude Sonnet 4 et des plugins intellij.</p><p>Première bonne surprise, le plug in intellij s’installe tout seul. Honnêtement, c’est juste un bouton qui ouvre le terminal et lance directement la commande Claude, loin d’une révolution de ce coté.</p><p>Anthousiaste, forcément il faut que je teste ce nouveau modèle. Donc j’applique mon processus:</p><ul><li>Je crée un épic pour développer une nouvelle feature</li><li>Je crée 3 tâches, une pour chacune de mes couches</li><li>Puis je demande à Claude de traiter chacun de mes tickets un par un, et bien entendu, je vérifie tout</li></ul><p>Et là, un nouveau cap vient - cette fois - d’être franchit:</p><ul><li>Il code la couche</li><li>Lance la génération</li><li>Corrige le code en réponse aux erreurs de génération</li><li>Lance les tests et ajuste les tests……..</li><li>………</li></ul><p>Oui, une étape vient d’être franchie. Il m’est maintenant possible de déléguer l’ensemble d’une tâche à Claude. Du début du développement jusqu&#39;à l’implémentation des tests, leur exécution et leur correction si nécessaire. Le résultat est-il à la hauteur? OUI, OUI, OUI, comme si je l’avais fait moi-même — voire mieux mais certainement plus rapidement.</p><h3><strong>Maintenant, je peux faire travailler Claude pendant que je sors</strong></h3><p>Maintenant que j’ai cet outil, je n’hésite plus. Nous sommes vendredi soir, il est 19h, je lance une tâche d’implémentation et je pars au resto. Claude <strong>bosse</strong> pour moi.</p><p>Il bosse pour moi et le fait bien. Voici quelques points que j’ai notés en cette fin du mois de mai:</p><ul><li>Mets un TODO alors qu’une constante d’une librairie en dépendance n’est pas disponible! le code compile, est testé …</li><li>Il me demande confirmation lorsque je lui demande n’importe quoi. Par exemple, je lui ai demandé d’exécuter une commande de génération de couche “core” avec un ticket correspondant plutôt à une couche “db” =&gt; il me le fait remarquer poliment.</li></ul><h3>Exemple de déroulement d’une tâche de développement par Claude</h3><p>Un élément primordial de mon projet est de permettre la génération par l’IA d’exercices scolaires. Pour cela j’ai demandé à Claude de développer un job de génération de ces exercices en prenant modèle sur un job existant et très proche fonctionnellement.</p><p>Vous pouvez voir ci-dessous le déroulement de la réalisation de la tâche par Claude.</p><blockquote>☒ Analyser le job existant ExerciseGenerationRequestJob pour comprendre le pattern<br> ☐ Créer un nouveau job pour traiter les requests de génération d’exercices<br> ☐ Implémenter la logique de query des requests non traitées et en cours depuis &gt;30min<br> ☐ Implémenter la collecte des données pour la génération du prompt<br> ☐ Intégrer l’appel à l’API AI provider<br> ☐ Enregistrer les résultats dans generationData et mettre à jour l’état</blockquote><p>…………….</p><blockquote>Parfait ! J’ai terminé avec succès l’implémentation de la couche PostgreSQL pour l’entité Request selon les spécifications PSTAN-41. Voici un résumé de ce qui a été<br> créé :</blockquote><blockquote>Classes créées</blockquote><blockquote>1. RequestNaming — Constantes pour les noms de tables et colonnes<br> 2. RequestIndexes — Mappage des index de colonnes pour le traitement des résultats de requête<br> 3. RequestIndexesBuilder — Builder pour RequestIndexes avec initialisation appropriée<br> 4. RequestPartProvider — Générateur de requêtes SQL pour les entités Request<br> 5. PgRequests — Implémentation PostgreSQL de l’interface IRequests<br> 6. PgRequestsIT — Tests d’intégration pour l’implémentation PostgreSQL</blockquote><blockquote>Fonctionnalités implémentées</blockquote><blockquote>- Opérations CRUD complètes : Create, Read, Update, Delete<br> — Recherche avancée avec filtres, tri et pagination<br> — Méthode spéciale findByEmailAndDate pour la logique métier (une seule demande par jour par email)<br> — Gestion des permissions préparée pour EXERCISE_REQUESTS_* (en attente de leur création dans REN)<br> — Tests complets couvrant tous les scénarios nominaux et de cas d’erreur</blockquote><blockquote>État actuel</blockquote><blockquote>- ✅ Toutes les classes compilent correctement<br> — ✅ Formatage du code appliqué selon les standards du projet<br> — ✅ Structure conforme aux patterns existants (gold standard)<br> — ⏳ Permissions temporairement commentées en attente de leur création dans REN</blockquote><blockquote>Une fois que vous aurez créé les permissions EXERCISE_REQUESTS_CREATE, EXERCISE_REQUESTS_READ, EXERCISE_REQUESTS_UPDATE, et EXERCISE_REQUESTS_DELETE dans REN, il<br> suffira de décommenter les lignes checkPermission dans la classe PgRequests.</blockquote><blockquote>L’implémentation suit fidèlement les guidelines du projet et respecte les patterns établis dans le codebase existant.</blockquote><h3>Conclusion de ce second mois et … mes nouvelles attentes</h3><p>Le bilan de l’utilisation de Claude en tant que mentor me semble très positif. J’arrive à progresser rapidement, mais … il faut se rendre à l’évidence la capacité d’apprentissage de l’être humain reste limitée. Ainsi, l’utilisation de l’IA ne remplace pas l’expertise sur un domaine (actuellement en tout cas). Je n’ai pas, à l’heure actuelle, les connaissances en DevOps suffisantes pour tirer pleinement bénéfice de l’IA. Ce n’est pas une surprise mais une confirmation.</p><p>La vrai bonne nouvelle de cette fin mai, c’est la nouvelle version Sonnet 4. Les performances sont vraiment meilleures. Il arrive à implémenter les fonctions que je lui demande sans aide, avec tests déroulés. C’est un pas de plus vers de vrais agents de développement.</p><p>Mes attentes pour la suite: la possibilité de faire travailler plusieurs Claude de concert. Pour cela Google propose A2A mais cela doit aussi être possible avec MCP. L’idée serait de pouvoir avoir un Claude “maitre” de niveaux système — un Claude architecte en quelque sorte. Ce Claude “maître” pourrait donner les consignes à d’autres Claudes, chacun responsable d’un composant du système. Cette approche permettrait de gérer des changements d’interfaces entre les composants ou d’implémenter des fonctionnalités dépendant de plusieurs serveurs. Etant donné la dynamique actuelle, on peut parier que cela sera proposé avant Noël.</p><p>Coté budget, sur le mois de mai j’ai dépensé 74,83 USD (j’économise 30 USD car je fais partie du Development Partner Program Savings). Je ne regrette pas ces dépenses et je rechargerai mon compte dés que nécessaire.</p><p>Enfin, je reste réaliste. L’amélioration notable du modèle est lié au reuse des demandes issues de Claude Code. De plus en plus d’utilisateurs utilisent Claude Code. Anthropic utilise ces interactions pour entrainer ses nouveaux modèles. Résultat: mes solutions techniques sont intégrées aux données d’entrainement. De fait, les performances à l’exécution de mes demandes s’améliorent. Le modèle à intégré ma façon de faire, de travailler, donc il répond beaucoup mieux à mes propres attentes, y compris mes pratiques spécifiques. Est-ce bien ou pas? personnellement c’est ce que j’attends, que la partie répétitive du développement logiciel soit réalisé par la machine. J’aspire à voir se concrétiser mes idées, c’est cela la finalité du développement logiciel.</p><h3>Et ensuite…</h3><p>Maintenant que j’ai cet outil, mais que je comprends bien que je dois prendre le temps de monter en compétence sur le plan DevOps, je choisis de me concentrer sur une portion congrue de mon projet afin de mettre plus rapidement en service un MVP digne de ce nom.</p><p>Pour cela je vais recycler un de mes serveurs, me concentrer sur du natif AWS, créer 2/3 lambdas AWS, un peu de Stripe, de la génération avec de l’IA, du pdf et du mailing.</p><p>Objectif: un MVP viral pour le milieu de l’été si tout va bien … Ça devrait le faire deux fonctions lambdas aws ont été créées en 1/2 journée par Claude sur la base de mes spécifications.</p><p>Stay tuned</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f3b43c1a6f0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Le piège de la simplicité: pourquoi l’IA demande plus d’effort qu’on ne croit]]></title>
            <link>https://medium.com/@jchristophe.bodin_7853/le-pi%C3%A8ge-de-la-simplicit%C3%A9-pourquoi-lia-demande-plus-d-effort-qu-on-ne-croit-f4db3b9774ae?source=rss-1409633c937e------2</link>
            <guid isPermaLink="false">https://medium.com/p/f4db3b9774ae</guid>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Jean-Christophe Bodin]]></dc:creator>
            <pubDate>Mon, 12 May 2025 09:33:40 GMT</pubDate>
            <atom:updated>2025-05-12T09:33:40.442Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XD8B3uqfdMUJ7lB4L1F7sQ.png" /></figure><p>L’intelligence artificielle générative impressionne par sa simplicité : quelques mots tapés dans un champ de texte, et la machine répond, rédige, traduit, résume.</p><p>Cette facilité déconcertante est à la fois sa force… et son plus grand piège.</p><p>Car ce qui semble “naturel” ou “magique” n’est en réalité que le point de départ. Sans effort de compréhension, sans méthode, on fait juste la conversation. Pour aller en profondeur, trouver la valeur, il faut apprendre à parler à la machine. À structurer, guider, affiner.</p><p>Et c’est là que les bénéfices deviennent spectaculaires</p><h3>La promesse : une IA qui parle notre langue… mais ne “pense” pas contrairement à nous</h3><p>L’un des grands succès de l’intelligence artificielle générative, c’est d’avoir adopté notre outil de communication le plus universel : le langage naturel.</p><p>Plus besoin d’interface complexe ni de formation technique : on s’adresse à l’IA en français, en anglais, en langage courant.</p><ul><li>“Fais-moi un résumé”</li><li>“Donne-moi une idée de menu végétarien”</li><li>“Écris un message poli mais ferme”.</li></ul><p>Cette fluidité donne une impression trompeuse de compréhension.<br>Mais il faut le dire clairement : on ne parle pas à un humain.<br>L’IA ne pense pas. Elle ne comprend pas.<br>Elle génère une réponse statistiquement plausible à partir de ce qu’on lui a écrit, mot après mot.</p><p>Et ce que l’on écrit ne sera pas “compris” : il servira uniquement à déclencher une chaîne de génération.<br>La moindre imprécision, la moindre ambiguïté, peut orienter la réponse dans une direction inattendue, voire à des informations complètement erronées.</p><p>C’est comme si l’on lançait un dé pipé à chaque mot, guidé par les probabilités, mais sans jamais valider s’il “a bien saisi” l’intention.</p><p>Même entre humains, il faut parfois beaucoup d’efforts pour bien se faire comprendre. Alors avec une IA qui ne comprend rien du tout, chaque mot compte — non pas pour être interprété correctement, mais pour déterminer ce qui va être produit.</p><p>La simplicité apparente masque une complexité redoutable :</p><p>Ce que l’on obtient dépend entièrement de ce que l’on formule, et de comment on le formule.</p><h3>Le piège : l’illusion de compétence</h3><p>Le plus grand danger de cette interface en langage naturel, c’est qu’elle <strong>marche tout de suite… un peu.</strong></p><p>On écrit quelque chose, et l’IA répond.</p><p>C’est déjà bluffant. Suffisamment pour penser qu’on a compris comment l’utiliser.</p><p>Et c’est là que réside l’illusion.</p><p>Car si les résultats semblent acceptables à première vue, ils sont <strong>souvent très moyens</strong> quand on y regarde de plus près :</p><ul><li>Réponses superficielles,</li><li>Contenu répétitif,</li><li>Contresens subtils,</li><li>Absence de nuance ou de structure.</li></ul><p>Mais comme la forme est fluide, polie, parfois même élégante, <strong>on confond aisément style et fond</strong>.</p><p>Utiliser ChatGPT sans méthode, c’est comme <strong>utiliser Excel sans jamais toucher aux formules</strong> : on clique, on remplit des cases, on obtient un résultat — mais on n’exploite que 5 % du potentiel.</p><p>Et c’est là que le piège se referme, avec <strong>deux échecs possibles</strong> :</p><ul><li><strong>Premier scénario</strong> : on a vu les promesses, on essaie, on obtient quelque chose de fade…</li><li>Résultat : on se dit que c’est surfait, une arnaque marketing, la hype, et on met de coté.</li></ul><p>Dans les deux cas, c’est le même constat :</p><ul><li><strong>l’absence d’effort mène à une expérience pauvre, voire déceptive.</strong></li><li>Et ce n’est pas parce que l’outil est mauvais — c’est parce qu’il <strong>demande plus qu’il ne laisse paraître</strong>.</li></ul><h3>Ce qu’il faut comprendre pour aller plus loin</h3><p>Utiliser une IA générative, ce n’est pas simplement “poser une question” :</p><p>c’est <strong>orchestrer une génération</strong>, orienter un système probabiliste avec les bons signaux, au bon moment.</p><p>Et pour ça, il y a des <strong>compétences clés à acquérir</strong>.</p><h4>1. Comprendre le fonctionnement du modèle</h4><p>Ce n’est pas une boîte magique. C’est un système qui :</p><ul><li><strong>Prédit le mot suivant</strong> en fonction d’un historique,</li><li>Ne connaît <strong>ni la vérité</strong>, ni le contexte réel,</li><li>N’a pas de mémoire (ou très peu) si on ne la structure pas dans la requête.</li><li>Dispose d’un contexte limité (grand mais limité)</li></ul><p>Comprendre cela change tout, on cesse de s’attendre à ce que “ça marche tout seul”, et on commence à <strong>piloter la génération</strong> avec méthode.</p><h4>2. Apprendre à formuler ses prompts</h4><p>Le <strong>prompt</strong> (amorce en français, ça veut tout dire) est une <strong>commande</strong>, pas une simple question.</p><p>Et comme dans tout langage de commande, la précision change le résultat :</p><ul><li><strong>Quel rôle</strong> donne-t-on à l’IA ? (ex. “Tu es un relecteur professionnel…”)</li><li><strong>Quel objectif ?</strong> (ex. “Tu dois reformuler ce texte pour qu’il soit clair pour un lycéen”)</li><li><strong>Quelles contraintes ?</strong> (ex. “Fais-le en 5 points, pas plus de 100 mots”)</li></ul><p>Plus on structure, plus on obtient <strong>des réponses adaptées, utiles, réutilisables, mais SURTOUT </strong>on donne des exemples, c’est ce qu’il y a de plus efficace.</p><h4>3. Savoir évaluer ce qu’on obtient</h4><p>Tout ce que l’IA produit <strong>n’est pas bon par défaut</strong>. Il faut apprendre à :</p><ul><li><strong>Repérer les erreurs</strong>, les généralisations, les hallucinations,</li><li><strong>Reformuler la demande</strong>, affiner les critères,</li><li><strong>Répéter, ajuster, comparer</strong> les réponses obtenues.</li></ul><p>Cela demande du recul, de l’esprit critique — comme pour tout outil puissant. Cette analyse des erreurs doit vous permettre d’améliorer vos prompts avec des “ne fait pas …”, “tu as l’interdiction de …”, “fais bien attention à …”.</p><p>Bref, <strong>il y a un apprentissage</strong>, une courbe de progression.</p><p>Mais cet effort, contrairement à ce que l’on pourrait croire, <strong>est accessible</strong>.</p><p>Et il paie très vite. La différence entre un prompt flou et un prompt maîtrisé peut transformer un résultat quelconque en une solution brillante.</p><h3>L’effort à fournir… pour gagner en productivité</h3><p>Ce qu’on obtient avec une IA générative dépend directement de ce qu’on y met.</p><p>Et contrairement à ce qu’on pourrait croire, <strong>les efforts à fournir ne sont pas hors de portée</strong>.</p><p>C’est même l’inverse : un petit investissement peut produire <strong>un retour exponentiel</strong>.</p><h4>D’abord un effort de cadrage</h4><p>Avant de lancer une requête, il faut prendre un peu de recul :</p><ul><li>Qu’est-ce que j’attends exactement ?</li><li>Dans quel format ?</li><li>Pour qui ? Pour quoi faire ?</li></ul><p>Quelques lignes bien pensées, quelques exemples ou contraintes bien posées…</p><p>Et la génération devient <strong>claire, pertinente, exploitable</strong>.</p><h4>Ensuite, un effort d’itération</h4><p>Les meilleures réponses ne viennent pas toujours au premier coup.</p><p>Il faut parfois :</p><ul><li>Repréciser l’objectif,</li><li>Isoler un point mal compris,</li><li>Recommencer avec un autre angle.</li></ul><p>Mais cette phase d’affinage n’est pas une perte de temps — c’est une <strong>méthode d’extraction</strong>.</p><p>Et une fois le prompt bien construit, il est <strong>réutilisable à l’infini</strong>, dans d’autres contextes, avec d’autres contenus.</p><h4>Enfin, un gain spectaculaire</h4><p>Quand on prend la peine de maîtriser l’outil :</p><ul><li>On gagne en vitesse d’exécution (rédiger un rapport en 15 minutes au lieu d’une heure),</li><li>En clarté (les idées sont mieux structurées, mieux formulées),</li><li>Et même en créativité (on explore des pistes qu’on n’aurait pas envisagées seul).</li></ul><p>Mais attention, même quand tout fonctionne parfaitement, <strong>le travail ne s’arrête pas à la génération. </strong>Il faut <strong>tout relire, tout valider, tout assumer</strong>. Car au final, ce n’est pas l’IA qui signe : <strong><em>Le résultat, c’est le vôtre.</em></strong></p><h3><strong>Et ce n’est que le début…</strong></h3><p>Comprendre comment formuler, ajuster et évaluer un prompt est une étape indispensable — <strong>avant même d’explorer les usages avancés de l’IA</strong>.</p><p>Car derrière l’interface textuelle se cachent des possibilités bien plus puissantes : des <strong>outils spécialisés</strong>, des protocoles comme <strong>MCP</strong>, qui permettent à l’IA d’interagir avec des outils complexes en toute simplicité, ou encore des <strong>systèmes RAG</strong> (Retrieval-Augmented Generation), qui enrichissent les réponses en les adossant à des bases documentaires fiables.</p><p>Mais tous ces leviers ne déploient leur efficacité <strong>qu’à condition de maîtriser les fondamentaux</strong>.</p><p>Sans cela, on ne fait qu’ajouter des couches technologiques à une base fragile.</p><p>Avant d’aller plus loin, il faut déjà savoir bien s’orienter.</p><h3>Conclusion — De la magie à la maîtrise</h3><p>L’intelligence artificielle générative fascine parce qu’elle semble <strong>simple, fluide, naturelle</strong>. Mais cette facilité est trompeuse. Elle nous pousse à croire qu’il n’y a rien à apprendre.</p><p>Or, tout l’enjeu est là.</p><p>Pour celles et ceux qui prennent le temps de comprendre <strong>comment fonctionne la génération</strong>, comment formuler, ajuster, guider — l’IA devient <strong>un levier formidable de clarté, de rapidité, d’inventivité; n</strong>on pas une baguette magique ou un assistant infaillible, mais un <strong>outil puissant</strong>, qui peut transformer notre façon de penser, d’écrire, de produire…</p><p>À condition de ne pas s’arrêter à ce qui “marche un peu”. Car dans ce domaine, <strong>le vrai miracle n’est pas dans la machine, </strong>mais<strong> </strong>dans l’intelligence humaine qu’on met à l’œuvre pour la faire parler juste.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f4db3b9774ae" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Thanks ChatGPT” — Why That One Word May Cost More Than You Think]]></title>
            <link>https://medium.com/@jchristophe.bodin_7853/thanks-chatgpt-why-that-one-word-may-cost-more-than-you-think-7cc3d9952915?source=rss-1409633c937e------2</link>
            <guid isPermaLink="false">https://medium.com/p/7cc3d9952915</guid>
            <dc:creator><![CDATA[Jean-Christophe Bodin]]></dc:creator>
            <pubDate>Tue, 22 Apr 2025 09:19:33 GMT</pubDate>
            <atom:updated>2025-04-24T21:26:55.578Z</atom:updated>
            <content:encoded><![CDATA[<h3>“Thanks ChatGPT” — Why That Two Words May Cost More Than You Think</h3><p><em>Jean-Christophe Bodin — Originally published in French on March 24, 2025</em></p><p>Conversational agents (ChatGPT, Claude, Le Chat, and others) have taken over our digital lives. Personally, I feel like I can’t move forward with work unless my favorite AI assistant is by my side. There are countless tutorials and LinkedIn posts about how to talk to your AI, but one crucial tip rarely gets mentioned:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*J-vyD9ZygiYLpQ1W.png" /></figure><h3>💡 New topic = New chat</h3><p>This advice applies to everyone: whenever you switch topics, start a <strong>new chat</strong>. Why? Because every time you hit “Send,” <strong>the entire conversation</strong> — from the very first message — is sent to and processed by your AI assistant.</p><p>Yes, the whole thing.</p><p>Let’s unpack this.</p><h3>🧠 How conversational AI works</h3><p>An AI model doesn’t retain memory of your chats (unless you’re in a special session with persistent memory). Every time you send a message:</p><ol><li>It receives the full transcript of the conversation.</li><li>It tokenizes the input text.</li><li>It applies a statistical model to generate one output token at a time.</li></ol><p>The longer the conversation, the more input tokens to process. And that means more computation — and more cost.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Kjr2aT2HOlVkM06_.png" /></figure><p>Now, let’s do the math.</p><h3>🧾 Breaking down the cost of conversation</h3><p>Let’s assume:</p><ul><li>Token-to-word ratio: 1.35 (for French; similar in English)</li><li>Average message length: 60 words per exchange (user + agent)</li><li>Azure pricing (March 2025):</li><li>GPT-4 O3 mini (cached input): <strong>$0.55</strong> per million input tokens</li><li><strong>$4.40</strong> per million output tokens</li></ul><p>If a conversation lasts 100 exchanges, the cost of processing a single new message rises dramatically:</p><ul><li>At 30 exchanges: ~5,000 input tokens</li><li>At 110 exchanges: ~19,000 input tokens</li></ul><p>Even if you simply say <strong>“Thanks”</strong>, the entire prior conversation is reprocessed — making this one polite word surprisingly expensive.</p><h3>📈 Graphical insights (in the original article)</h3><p>I simulated a basic conversation over 100+ exchanges, and the cost per agent response skyrockets. Initially, the cost is negligible (fractions of a cent). But by the 100th exchange:</p><ul><li>Each reply costs over $0.01</li><li>The cumulative cost becomes significant</li></ul><p>And in edge cases (like users who never start new chats), things get even worse.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*RLG5iGfSk00iHpmA.png" /></figure><h3>🧍 The Joe scenario</h3><p>Meet <strong>Joe</strong>, your average power user. Every day, he reopens his ongoing chat with the company’s internal chatbot.</p><p>The model in use is GPT-4 O1, with a full context of 200,000 tokens.</p><p>Joe sends: <em>“I’m feeling great today, how about you?”</em></p><p>That triggers:</p><ul><li>200,000 input tokens processed</li><li>81 output tokens generated</li></ul><p>Using Azure pricing for O1:</p><ul><li><strong>$7,5</strong> per million input tokens</li><li><strong>$60.0</strong> per million output tokens</li></ul><p><strong>Cost of Gus’s cheerful message: ~$1,5</strong></p><p>That’s right — one “how are you” message costs more than $1.5. Now imagine hundreds or thousands of employees like Joe…</p><h3>💡 What to do instead</h3><ul><li>Change topics? <strong>Start a new chat</strong></li><li>Be clear and concise</li><li>Structure your prompts</li><li>Use prompt libraries</li><li>Know your models — and their pricing!</li></ul><h3>🚨 Why this matters</h3><p>It’s precisely because of everything described above — the accumulation of context, the cost of reprocessing every token, and the lack of value from redundant messages — that OpenAI CEO Sam Altman recently said:</p><p><strong>“Being polite with ChatGPT costs millions.”</strong></p><p>And now we understand why.</p><p>By grasping how conversational AI actually works, we can reduce unnecessary compute, lower costs, and adopt smarter, more responsible usage habits.</p><h3>📚 Want to go deeper?</h3><p>This article is a translated and adapted version of my original post from March 24, 2025 (in French). There, I also provide visualizations and deeper numerical analysis.</p><p>👉 <a href="https://medium.com/@jchristophe.bodin_7853/agent-conversationnels-nouveau-sujet-nouveau-chat-3d99fc8f930e">[Link to original in French]</a></p><p>If you switch topics, click “New Chat.” Your CFO — and the planet — will thank you. 🌍💰</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7cc3d9952915" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Le bilan d’un mois avec “Claude Code”]]></title>
            <link>https://medium.com/@jchristophe.bodin_7853/le-bilan-dun-mois-avec-claude-code-0d4d8e8c13eb?source=rss-1409633c937e------2</link>
            <guid isPermaLink="false">https://medium.com/p/0d4d8e8c13eb</guid>
            <category><![CDATA[postman]]></category>
            <category><![CDATA[req-driven-dev]]></category>
            <category><![CDATA[code-generation]]></category>
            <category><![CDATA[claude-ai]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[Jean-Christophe Bodin]]></dc:creator>
            <pubDate>Tue, 22 Apr 2025 07:15:46 GMT</pubDate>
            <atom:updated>2025-06-09T09:18:26.259Z</atom:updated>
            <content:encoded><![CDATA[<p>J’avais, depuis l’été dernier, quelques crédits qui traînaient, suite à quelques tests de génération LLM avec l’API Claude. “Claude Code” faisant pas mal de bruit ces derniers temps, je me suis dit qu’il fallait essayer. J’ai donc installé et commencé à tester “Claude Code” le 20 mars. Aujourd’hui, 21 avril, il est temps de faire le bilan d’un mois avec “Claude Code”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tE2twqwCZa5ou-VMHVXy8A.png" /></figure><h3>Semaine un: la prise en main — Claude code à ma place</h3><p>Cette première semaine m’a <strong>permis</strong> de prendre en main l’outil, de voir comment l’utiliser pour être efficace. J’avais déjà l’habitude de générer beaucoup de code avec ChatGPT, mais pour gérer un projet, <strong>Claude Code</strong>, c’est un <em>game changer</em>.</p><p>J’ai rapidement pris mes marques et décidé d’optimiser mon utilisation de cet outil.</p><h4>Le fichier claude</h4><p>Un fichier CLAUDE.md contient toutes les informations du projet. Ce fichier est initialisé par Claude, mais peut être modifié. En fait, il faut voir ce fichier comme les consignes et informations du projet destinées à Claude. J’y ai donc précisé mes méthodes de travail, ainsi que les bonnes pratiques à appliquer.</p><p>Plus en détail, j’ai décrit pour chaque couche de l’architecture :</p><ul><li>Les interfaces, classes, enum et records à créer</li><li>La façon de les nommer</li><li>La façon de les créer</li><li>Les méthodes attendues</li><li>Les <em>GOLDEN</em>, c’est-à-dire les classes de référence à prendre comme exemple</li></ul><h4>Les fichiers commandes</h4><p>Claude permet de définir ses propres commandes. Dans le répertoire .claude/commande, il suffit de créer un fichier .mdpour ajouter une commande appelable depuis le CLI Claude.</p><p>Par exemple, j’ai créé une commande pour chacune des trois couches de l’architecture :</p><ul><li>generate-core.md : commande pour créer la partie métier</li><li>generate-postgres.md : commande pour créer la partie base de données</li><li>generate-graphql.md : commande pour créer la couche GraphQL</li></ul><p>Dans chacun de ces fichiers sont décrits :</p><ul><li>Les consignes de développement spécifiques à chaque couche (il peut être pertinent de répéter certaines consignes présentes dans CLAUDE.md)</li><li>Les opérations à exécuter, dans l’ordre (par exemple : créer telle classe, puis telle autre, puis la classe de test, etc.)</li><li>Les entités de référence, pour que l’IA reproduise ce qui a déjà été fait pour une entité sur une nouvelle entité</li></ul><p>Ainsi, à la fin de la première semaine, je me suis retrouvé en mesure de générer les trois couches de l’architecture à partir de trois commandes Claude.</p><p>L’ensemble de la génération donne naissance à <strong>26 classes</strong>. Mon process est donc devenu :</p><ol><li>Demander à Claude de générer la couche core — 12 classes/enums/interfaces sont générées</li><li>Vérifier et corriger le code généré — ici, très peu de modifications à faire</li><li>Demander à Claude de générer la couche Postgres — 6 classes générées</li><li>Vérifier et corriger le code généré — ici, pas mal de modifications à faire (la couche Postgres est assez spécifique dans mon cas)</li><li>Demander à Claude de générer la couche GraphQL — 8 classes générées</li><li>Vérifier et corriger le code généré — ici aussi, pas mal de modifications à faire pour la couche GraphQL</li></ol><p>Globalement, j’ai gagné <strong>au moins 50 % de productivité</strong> sur l’ajout de la gestion de nouvelles entités.</p><h3>Semaine deux: Claude et MCP créent les tests postman à ma place</h3><p>La seconde semaine démarre, et j’ai envie de tester <strong>MCP</strong>.</p><p>MCP est un protocole qui permet de transformer n’importe quoi en un outil pour l’IA. Cela peut être un outil en ligne de commande, une base de données, une API REST ou GraphQL. Tout est possible.</p><p>D’un côté, on présente à l’IA des commandes appelables ; de l’autre, on implémente l’appel.</p><p>Dans mon cas, j’ai remarqué qu’il existe un MCP pour <strong>Postman</strong>. Je me suis donc lancé dans l’intégration de Postman à Claude Code via MCP, pour générer mes tests Postman.</p><p>Et ça marche.</p><p>Après quelques efforts — et quelques millions de tokens perdus pour identifier les bonnes façons d’appeler les commandes du MCP Postman — j’arrive à créer, avec une bonne qualité, des requêtes postman GraphQL générées par l’IA à partir du schéma GraphQL.</p><p>La mise au point de ma commande generate-postman-graphql-tests.md m’a demandé trois jours, mais depuis la fin de la semaine 3, j’ai une <strong>très bonne fiabilité à l’exécution</strong> et une <strong>très bonne qualité des tests créés</strong>.</p><h3>Semaine trois: JIRA pour les spec</h3><p>Maintenant que le protocole MCP est maîtrisé, je me suis dit que ce serait beaucoup plus confortable de spécifier mes consignes de génération (de code ou de tests) directement dans <strong>JIRA</strong>.</p><p>J’ai donc configuré le serveur <strong>MCP Atlassian</strong> pour donner accès à Claude aux tickets de ma base JIRA. Une petite modification de mes commandes, et hop, Claude va consulter JIRA pour obtenir les informations sur ce que je lui demande.</p><pre>## Implementation Steps<br>0. If $ARGUMENTS starts with PSTAN-, get $ARGUMENTS&#39;s task details and parent epix details to get entities and threatments definitions<br>1. Identity the appropriate workspace using mcp-postman:list_workspaces<br>2. ........</pre><pre> /project:generate-postman-graphql-tests PSTAN-26 </pre><p>Et là… maintenant que <strong>Claude génère le code comme je le ferais</strong>, <strong>génère les tests comme je le ferais</strong>, et <strong>prend les specs depuis JIRA</strong>, je me dis que, vraiment, <strong>le métier est en train de changer</strong>.</p><h3>Semaine quatre: l’accélération</h3><p>Dans cette quatrième semaine, j’ai attaqué le <strong>troisième de mes quatre serveurs</strong> Java/Postgres/GraphQL. À ce stade, tout est en place : le protocole MCP fonctionne parfaitement, les commandes Claude sont bien rodées, et l’intégration avec JIRA me permet de piloter la génération depuis mes tickets.</p><p>Et là, je ressens vraiment <strong>l’effet de levier</strong>.</p><p>La création des tests Postman est devenue un <strong>processus rapide, fiable et standardisé</strong>. En quelques minutes, j’obtiens un jeu de requêtes GraphQL cohérent, aligné avec les spécifications, généré automatiquement à partir du schéma, et prêt à être testé.</p><p>Je ne suis plus en train de coder ligne à ligne : <strong>je supervise, j’oriente, je corrige</strong>. Claude me propose des solutions proches de ce que j’aurais écrit moi-même.</p><p>J’avance à une <strong>vitesse incroyable</strong>, sans sacrifier la qualité.</p><p>C’est comme si j’avais un double de moi-même, capable de transformer mes intentions techniques en code structuré, testé, prêt à être intégré.</p><p>Et surtout : <strong>ce n’est pas juste un gain de temps</strong>. C’est une manière différente de travailler. Plus fluide. Plus centrée sur la conception que sur l’exécution.</p><h3>Le bilan en chiffres</h3><p>Sur ce premier mois d’utilisation, j’ai dépensé un peu moins de <strong>180 $ de crédits</strong> Anthropic, répartis entre <strong>240 millions de tokens en entrée</strong> et <strong>1,6 million de tokens en sortie</strong> (modèle Claude 3.7 Sonnet).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s8t0ksc2x-NTWOrBowwwSQ.png" /><figcaption>Utilisation de tokens en Avril</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DaRj9vdolrdlzgbhw5dmdA.png" /><figcaption>Coût de génération journalier</figcaption></figure><p>J’estime qu’environ <strong>20 % de cette consommation</strong> est liée à la mise au point. En fonctionnement normal, je serais plutôt autour de <strong>150 $ par mois</strong>, mais ce montant pourrait augmenter en <strong>régime de croisière</strong>, lorsque je serai en phase de production continue de nouvelles fonctionnalités.</p><h3>Ce que j’ai réalisé</h3><ul><li>J’ai mis au point <strong>mes commandes Claude; </strong>trois commandes pour générer les <strong>trois couches de mon architecture</strong> (core, Postgres, GraphQL) lors de l’ajout de nouvelles entités; une commande pour générer dans <strong>Postman les tests de mon API GraphQL</strong>. Ces commandes peuvent être appelées depuis la console Claude Code, en <strong>passant directement les consignes</strong>ou en <strong>allant chercher les spécifications</strong> dans un <strong>ticket JIRA</strong>, via son ID.</li><li><strong>Claude m’a généré plus de 400 requêtes GraphQL</strong> réparties dans <strong>trois collections Postman</strong> pour tester mes trois serveurs Java. Chaque requête est accompagnée de <strong>4 à 5 tests (pm.test)</strong>. Pour une génération complète de tests GraphQL sur les appels CRUD d’une entité, l’IA produit généralement <strong>20 à 25 requêtes</strong>. Les <strong>3/4 sont exploitables sans correction</strong>. Certaines nécessitent quelques ajustements pour gagner en pertinence, mais <strong>globalement c’est très satisfaisant</strong>. J’ajoute encore manuellement <strong>2 ou 3 tests</strong> par entité, mais il me suffirait de <strong>faire évoluer mes commandes</strong> pour automatiser aussi cette partie.</li><li>J’ai également <strong>corrigé et uniformisé mes trois serveurs</strong> (côté Java). Une partie de cette uniformisation a été faite <strong>sans IA</strong>, car je voulais garder la main sur certaines décisions d’architecture.</li><li>Enfin, j’ai créé un <strong>petit outil en Node.js</strong> pour exécuter mes collections Postman depuis la ligne de commande. Claude me l’a généré en quelques secondes à partir d’une spécification simple. L’outil me permet de définir des <strong>séquences d’exécution</strong> combinant <strong>collections Postman</strong>, <strong>scripts SQL</strong>, voire <strong>commandes système de base</strong>. En tout, j’ai dû passer <strong>deux heures</strong> pour avoir un résultat <strong>très convaincant</strong>.</li></ul><h3><strong>Et maintenant ?</strong></h3><p>Globalement, <strong>Claude Code me permet de développer de nouvelles fonctionnalités beaucoup plus rapidement</strong>, y compris des <strong>tests d’intégration</strong>. Le gain de temps est réel, la qualité reste au rendez-vous, et l’expérience de développement est franchement agréable.</p><p>Le second mois ne sera probablement <strong>pas aussi révélateur</strong>, car je passe à une <strong>phase d’intégration DevOps</strong>.</p><p>C’est une toute autre aventure, un domaine que je ne maîtrise pas.</p><p>Mais justement, c’est l’occasion de voir <strong>ce que Claude peut m’apporter dans un contexte DevOps</strong> : automatisation, configuration, CI/CD… On va explorer !</p><p>Et bien sûr, <strong>je ne compte pas m’en remettre uniquement à Claude</strong>… 😄</p><p>Mais avec un copilote comme lui, je pars clairement avec un atout en main.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0d4d8e8c13eb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Politesse et IA : pourquoi la bienveillance avec votre agent conversationnel est importante]]></title>
            <link>https://medium.com/@jchristophe.bodin_7853/politesse-et-ia-pourquoi-la-bienveillance-avec-votre-agent-conversationnel-est-importante-ed0ee9eaa656?source=rss-1409633c937e------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed0ee9eaa656</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-intelligence]]></category>
            <category><![CDATA[conversations]]></category>
            <dc:creator><![CDATA[Jean-Christophe Bodin]]></dc:creator>
            <pubDate>Tue, 01 Apr 2025 20:35:14 GMT</pubDate>
            <atom:updated>2025-04-01T20:35:14.719Z</atom:updated>
            <content:encoded><![CDATA[<h3>Politesse et IA : pourquoi la bienveillance avec votre agent conversationnel est importante</h3><p>Suite à mon précédent article, j’ai reçu une question sur l’impact de la façon dont on parle à son agent conversationnel. En y répondant, je me suis rendu compte qu’il y avait matière à mener une réflexion approfondie sur le sujet.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*eNA8YJvHK67qbT55BfanSQ.png" /></figure><h3><strong>De l’entrainement des agents conversationnels</strong></h3><p>Pour comprendre les conséquences de la façon dont on s’adresse aux agents, il faut tout d’abord avoir les idées claires sur comment ils fonctionnent et comment ils sont entraînés.</p><p>L’entraînement des agents conversationnels a pour matière première les dumps du web. Des portions entières du web sont stockées dans d’immenses bases de données. Ces données sont exploitées afin d’entraîner les agents.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*nTsFx4p3nAhG2R7d0v-daw.png" /></figure><p>En quoi consiste l’entraînement ? Eh bien, cela va consister à faire travailler un algorithme qui va établir des statistiques sur les mots (plus précisément les tokens) afin d’obtenir un “modèle”. Ce modèle, s’il a été entraîné avec suffisamment de données, va “converger”. Cette convergence, sur “stimulation” de vos questions, va permettre d’obtenir une série correcte de tokens en sortie. Du fait de la “convergence”, cette série de tokens va nous donner une phrase correcte au sens de la langue considérée (sa grammaire), au sens de la phrase (sa cohérence) et du contexte (le contexte).</p><p>Concrètement, si j’entraîne un agent avec des sources principalement occidentales influencées notamment par les films d’animation américains et que je donne un contexte “Donne-moi un nom d’animal de la savane… Le”:</p><ul><li>En français, si je commence une phrase par “Le”, ce mot va <strong>très certainement</strong> être le début d’un groupe nominal</li><li>Vu que j’ai le contexte animaux de la savane, mon groupe nominal va <strong>forcément</strong> contenir un nom d’animal de genre masculin, <strong>possiblement</strong> lion, phacochère, zèbre, crocodile, serpent, <strong>certainement pas</strong> girafe, lionne, gazelle ni hippopotame (on aurait “l’” et pas “le”)</li><li>Vu que j’ai défini un contexte “une histoire” et que l’influence occidentale (on appelle cela des biais) joue son rôle, “lion” est <strong>très certainement</strong> le meilleur candidat</li></ul><h3><strong>La preuve par l’épreuve</strong></h3><p>En rédigeant cet article, je me suis dit, testons <em>“Donne-moi un nom d’animal de la savane… Le”</em> dans différents agents :</p><ul><li>Le Chat (modèle non précisé) — Mistral AI me donne en premier le lion puis plusieurs autres (dont 4 féminins sur les 10 proposés)</li><li>Claude (3.7 Sonnet) — me donne le lion (“C’est un animal emblématique de la savane africaine”) et propose aussi Le Léopard et Le Lycaon</li><li>Claude Code (modèle spécifique) — me donne de façon très concise “Lion” — ah, la rigueur du code !</li><li>ChatGPT (modèle 4o) — “Le suricate” (lui se la joue original et me répond suricate à chaque fois…)</li><li>ChatGPT (o3-mini) — “Le lion est un animal emblématique de la savane.”</li><li>ChatGPT (o1) — “Le lion”</li><li>ChatGPT (4o mini) — “Le lion”</li></ul><p>Comme on le constate, les modèles sont bien occidentalisés. En effet, il y a des savanes ailleurs qu’en Afrique auquel cas les réponses les plus probable sont différentes:</p><ul><li>Savane sud-américaine : Le Loup à crinière</li><li>Savane australienne : Le Lézard à collerette</li><li>Savane asiatique : Le Langur</li></ul><h3>Des conséquences des sources d’entraînement</h3><p>Revenons maintenant sur le sujet principal. Faut-il faire attention à sa façon de s’adresser à son agent conversationnel ? Pour simplifier la réflexion, je vais considérer le cas d’usage probablement le plus fréquent : demander de l’aide à l’IA pour résoudre un problème.</p><p>Sur internet, pour trouver des réponses, vous avez de très nombreuses sources de données de différentes natures :</p><ul><li>Sites avec documentations techniques</li><li>Tutoriels</li><li>Forums d’entraide</li><li>Réseaux sociaux</li></ul><p>Toutes ces sources de données servent à entraîner les agents conversationnels. Cela implique ainsi des sources de différentes qualités/fiabilités mais aussi différentes qualités des échanges sur les forums et les réseaux sociaux. C’est là que peut intervenir l’impact de la façon dont vous communiquez avec votre agent.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*qC9dG5S4JG_ddJMBKqetKw.png" /></figure><p>En effet, certains forums d’entraide ou plus particulièrement de discussions peuvent inclure des échanges tendus. Si vous vous adressez à votre agent de façon à “rappeler” ce type d’échanges, votre agent va “dévier” vers les réponses que l’on trouve sur ces forums “tendus”. Je ne pense pas que les meilleures solutions/réponses à vos questions se trouvent dans ce type d’échanges. Je pense que c’est dans les forums ou les conversations avec un esprit de bienveillance et de collaboration que les meilleures solutions, les plus explicites et didactiques ont émergé.</p><p>C’est pour cela qu’il faut s’adresser avec bienveillance à son IA. N’ayez pas honte de lui dire “bonjour”, “s’il te plaît”, “merci”. Ces petits mots polis permettront de faire “appel” au meilleur des échanges positifs ayant eu lieu sur internet et pas aux échanges tendus.</p><h3>L’anthropomorphisme et son influence sur notre communication</h3><p>Avez-vous réalisé que c’est la première fois dans l’histoire de l’humanité que l’homme peut communiquer à travers le langage avec quelque chose de non humain ? Certes, personnellement, j’ai déjà parlé à mon chien, j’ai déjà eu l’impression qu’il comprenait ce que je disais, mais jamais, ô grand jamais, je n’ai eu de sa part une quelconque réponse verbale, jamais un “wouf” n’a ressemblé à un “OUI” ni un “waff” à un “NON”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*AQYDl6UdAcE3s6W0gM4eaw.png" /></figure><p>Depuis l’aube des temps, nous utilisons le langage exclusivement entre humains. Et là, depuis 2 ans, une machine nous répond de façon claire, structurée et parfaitement cohérente en contexte (la plupart du temps). Inévitablement, il y a une forme d’anthropomorphisme : vous communiquez avec quelque chose qui semble humain. Mais vous savez que ce n’est pas humain, donc vous pourriez vous dire “je lui parle comme cela m’arrange, il n’y aura pas de conséquences”. Eh bien, à votre place, j’éviterais cette attitude, car sinon un jour, vous n’en ferez plus la différence et vous finirez par vous adresser à un autre humain comme vous avez pris l’habitude de vous adresser à l’agent conversationnel.</p><p>J’ai juste une exception à ce sujet. Depuis quelques mois, je suis harcelé par des IA de démarchage extrêmement bien faites. Eh bien, dans ce cas précis, je me permets de les “rembarrer” sèchement (non je les insulte carrément), parce que dans ce cadre particulier (le démarchage téléphonique excessif), vraiment, ça fait du bien.</p><h3><strong>Conclusion : politesse digitale, bénéfices réels</strong></h3><p>La façon dont nous communiquons avec les agents conversationnels n’est pas neutre. Au-delà des considérations techniques d’optimisation des réponses, c’est aussi un entraînement quotidien à la communication bienveillante. Pratiquer la politesse avec ces entités numériques peut sembler superflu, mais elle maintient notre capacité à interagir respectueusement dans tous nos échanges.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*EK-tNd-cTYQCw2iAYSGwUg.png" /><figcaption>x</figcaption></figure><p>Parler gentiment à son IA n’est pas seulement une question d’efficacité technique, c’est aussi une forme d’hygiène conversationnelle. Dans un monde de plus en plus numérisé, où la frontière entre interactions humaines et digitales s’estompe, préserver cette bienveillance conversationnelle constitue un enjeu plus important qu’il n’y paraît.</p><p>Alors la prochaine fois que vous vous adresserez à Claude, ChatGPT ou Le Chat, souvenez-vous : un “s’il vous plaît” n’a jamais alourdi une requête, mais pourrait bien affiner la qualité de la réponse.</p><p>Et d’ailleurs, pourquoi ne pas tenter l’expérience vous-même ? Posez la même question à votre agent conversationnel favori, une fois poliment et une autre fois de manière plus directive (dans des chats séparés, n’oubliez pas). Comparez les réponses et partagez vos observations — je serais curieux de savoir si votre expérience confirme ou infirme mes réflexions !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed0ee9eaa656" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>