Agents de codage, skills, art du prompt et workflows agent-natifs.
147 fiches · 243 entities · Mis à jour
Les agents de codage sont des systèmes logiciels qui planifient, écrivent et révisent du code par des boucles itératives pilotées par modèle, non par une complétion unique. On trouve ici des analyses de leur fonctionnement concret — l'art du prompt qui les dirige, les skills et outils qui les étendent, et les motifs agent-natifs comme le plan mode, les sous-agents et les harnais. Reviennent au fil des fiches : ce qui rend un agent fiable sur un vrai dépôt, comment l'unité d'ingénierie glisse de la frappe vers la boucle, et là où le codage autonome échoue encore. Des pratiques nommées — vibe coding, augmented coding, loop engineering — y apparaissent à mesure que le domaine désigne ce qu'il apprend. La matière privilégie la pratique rapportée et les modes de défaillance aux promesses commerciales.
Essai de **Bill Staples**, directeur général de **GitLab**, publié le **24 août 2026** sur le blog about.gitlab.com : **31 minutes** de lecture annoncées, environ **39 000 caractères**, présenté comme la suite d'un mémo écrit au conseil d'administration en janvier 2026 et partiellement publié en mai sous le titre *GitLab Act 2*. Le texte se donne comme une réponse au playbook AI-native SDLC d'**Anthropic** paru trois jours plus tôt, dont il reprend la phrase d'ouverture — *« Code is no longer the bottleneck »* — pour poser la question qui l'occupe : qu'est-ce qui devient rare quand le code devient abondant. (A) Le diagnostic économique : l'unité utile n'est pas le coût par ligne mais le **coût par changement accepté**, qui agrège génération, environnement, contexte, vérification, revue, remédiation et gouvernance ; l'IA effondre le seul terme de génération, ce qui rend les autres proportionnellement plus lourds — une organisation dix fois plus rapide à générer *« will simply move the queue »*. (B) La réponse architecturale : quatre capacités — plateforme d'agents, exécution à l'échelle machine, contexte durable, gouvernance — formant une couche d'entreprise qui survit au modèle, *« The model should be replaceable. The agent should belong to the customer. »* (1) Trois modes coexistent durablement, du légataire piloté par l'humain au développement autonome, contre l'idée d'une courbe de maturité unique. (2) Le pipeline CI/CD devient le lieu où tourne la boucle interne, au lieu d'être une porte en fin de course. Les chiffres avancés sont ceux de **Stripe**, **Spotify** et **Amplitude** ; GitLab n'en produit qu'un, sur son propre contrôle de source. Le corpus tient déjà [[claxton-anthropic-ai-native-sdlc-playbook-2026-08-21]], la source à laquelle ce texte répond, et [[sfeir-sdlc-pdlc-articulation-2026-07-22]] sur l'articulation SDLC/PDLC que Staples reprend à son compte.
#abondance du code#coût par changement accepté#théorie des contraintes
Bill Staples · directeur général de GitLab (fonction non affichée par la page) · sur le blog about.gitlab.com.
Guide long-form d'**Anthropic** signé **Louis Claxton** (équipe Applied AI), publié le **21 août 2026** sur le blog claude.com : **40 minutes** de lecture annoncées, environ **64 000 caractères**, présenté comme un recueil de *plays* tirés du travail de l'équipe avec ses clients. (A) Le diagnostic : le code n'étant plus le goulot, celui-ci se déplace vers les étapes situées à gauche et à droite du build (plan, revue/test, déploiement), les contrôles ligne-à-ligne cessent de tenir dès que l'agent écrit l'essentiel du diff, et le coût de gouvernance monte, les exceptions passant encore par des comités périodiques. (B) La réponse : six étapes (Plan, Design, Build, Test, Deploy, Maintain) organisées en **boucle** et non en chaîne, chacune se terminant par un **artefact committé** que la suivante lit — `intent.md`, `spec.md`, `plan.md`, le diff et ses tests, la PR et ses constats, l'enregistrement d'incident. (1) Le savoir institutionnel devient des fichiers versionnés : `CLAUDE.md`, skills, `REVIEW.md`, `bands.yaml`. (2) La gouvernance se scinde en deux couches, la skill posée comme contrôle consultatif et le hook comme couche déterministe derrière elle. La séparation des tâches est posée en invariant — l'agent qui écrit le code ne peut pas l'approuver — et le texte se clôt sur *« The loop keeps running. Human judgement stays above it. »* Le corpus tient déjà [[clinton-anthropic-secure-ai-native-sdlc-2026-07-21]] sur le versant sécurité du même cycle et [[hingel-augment-how-ai-changes-sdlc-six-stages-2026-06-08]] sur le même découpage en six étapes vu par un concurrent.
#SDLC AI-native#cycle de vie logiciel#plays
Louis Claxton (Anthropic, équipe Applied AI) · sur le blog claude.com ; contributions créditées à Jim Blackhurst · Will Steuk et Jamal Arif.
Guide signé **Michael Segner**, publié le **20 août 2026** sur le blog claude.com dans la catégorie *Claude Code* : **5 minutes** de lecture annoncées pour environ **31 500 caractères** de corps, également proposé en PDF. Matériau déclaré : des entretiens avec **plus d'une douzaine** de jeunes pousses, quinze nommées — **Artemis Security**, **Cainex**, **Clay**, **ClickHouse**, **Cognition**, **Commure**, **Crosby**, **Emergent**, **Harvey**, **Heidi**, **Higgsfield**, **Omni**, **Parahelp**, **Translucent**, **Zingage**. (A) Cinq règles d'exploitation : *everyone ships*, *automate the tedium*, *trust, but verify*, *build for rebuilding*, *prototype, dogfood, productionize*, chacune close par des astuces produit et reprise dans une checklist finale. (B) Un corps fait de citations attribuées, chaque règle étant illustrée par des dirigeants nommés plutôt que par une mesure agrégée. Les quatre chiffres mis en exergue sont ceux des entreprises interrogées : **+30 %** de fonctionnalités livrées (ClickHouse), **2 à 3×** de productivité d'ingénierie (Omni), **100 %** du tri de bugs automatisé (Clay), **plus de 6 000 PR par semaine** (Artemis Security). Deux passages sortent du registre du témoignage : la boucle d'auto-correction de **Cainex** sur le codage médical, décrite étape par étape, et l'usage interne de **Claude Tag** chez **Anthropic** comme premier répondant d'astreinte CI/CD. La question posée en ouverture — *« what would it look like if an organization built their product development lifecycle with Claude Code from the ground up? »* — rejoint [[claxton-anthropic-ai-native-sdlc-playbook-2026-08-21]], paru le lendemain chez le même éditeur, et prolonge [[cherny-wu-reflecting-year-claude-code-2026-07-17]].
#Claude Code#jeunes pousses#everyone ships
Michael Segner · auteur du guide sur le blog claude.com (fonction non affichée par la page) ; entretiens avec les dirigeants de quinze entreprises nommées.
Billet du blog corporate de **Block** (`block.xyz/inside`), non signé — l'auteur affiché est **« Block »** —, publié le **18 août 2026**, ~930 mots, qui annonce **l'ouverture du code de Berd**, l'application de bureau interne de Block pour travailler avec des agents, et expose la thèse de conception qui l'a guidée : donner du caractère aux agents *« not only through roles, instructions, skills, and tools, but through distinctive visual identities »* — d'où les personnages animés maison, les *« Gloopies »*. Le billet part d'un constat de fragmentation (*« The technology was powerful, but the experience around it was fragmented »*) et d'un problème d'interface nommé avec précision : *« the product gives people little sense of how the agent is configured, which context and tools are available to it, and how it differs from another agent »*. Deux apports structurants. **(A) Une articulation en trois étages** : **goose** reste le framework et le *runtime* qui tient la boucle d'agent ; **Berd** est le client de bureau (projets, contexte, sessions, agents, configuration) ; les deux communiquent par l'**Agent Client Protocol**. **Buzz** est désigné comme la suite, quand le travail solo devient collaboratif (*« Start alone, then go multiplayer »*). **(B) Six exigences léguées à Buzz**, énoncées comme bilan : *« private space, durable context, recognizable agent identities, reusable skills, visible configuration, and clearer visibility into an agent's configured context, tools, and capabilities »* — grille directement réutilisable pour évaluer un client d'agents. Le texte distingue lui-même identité et capacité : *« The avatars make the agent recognizable. Its role, skills, and tools make it useful. »* Aucun chiffre d'usage n'est produit et aucune licence n'est nommée pour l'ouverture de code.
#Berd#Block#open source
**Aucun auteur nommé** : le billet est signé **« Block »** — le champ *Author* de la page porte le nom de l'entreprise. Publié le **18 août 2026** sur `block.xyz/inside` · le blog **corporate** · et non sur `engineering.block.xyz`.
Billet du blog de **Sonatype** signé **Aaron Linskens** (*technical writer*), publié le **18 août 2026**, ~1 300 mots : il restitue une étude de **Sonatype Research Labs** portant sur **49 mois** (juin 2022 — juin 2026) et sur une **cohorte fixe** d'applications d'entreprise, choix de méthode revendiqué pour isoler l'évolution du parc plutôt que celle du portefeuille clients. Résultat présenté comme une contradiction : on corrige plus vite et on accumule pourtant plus de risque. (A) **Le stock monte** — vulnérabilités *Critical* et *High* par application **×4,31** (de **14,14** en juin 2022 à **54,3** en 2026, encore **×3,91** hors applications légataires nouvellement prises en gestion), versions de composants nouvellement affectées à **46×** le rythme d'avant l'IA, création mensuelle d'applications **×4,84**. (B) **La remédiation progresse** — plus de la moitié des violations résolues le sont en moins d'un jour, l'âge médian des *Critical/High* non résolues passe de **228** à **126 jours** puis à **103** en mai 2026 ; sur les cohortes ayant eu douze mois, **52,6 %** sont résolues, **44,3 %** ouvertes, **3,1 %** en dérogation. (C) **Le point d'appui proposé est le choix du composant** : au moment où une dépendance vulnérable a été retenue, une version sensiblement moins risquée existait déjà dans **62,2 %** des cas sur **Maven**, **46,9 %** sur **npm**, **34,3 %** sur **PyPI** — écart que le texte attribue à un défaut d'information et non à une faute de développeur. Le billet énonce lui-même que l'IA n'est pas la cause unique de l'accélération, et se conclut sur **Sonatype Guide**, qui porte cette intelligence au point de sélection. Il prolonge côté chaîne d'approvisionnement ce que [[fiches/2026-08/staples-gitlab-when-code-is-abundant-2026-08-24]] pose en économie et [[fiches/2026-07/clinton-anthropic-secure-ai-native-sdlc-2026-07-21]] en cycle sécurisé.
#chaîne d'approvisionnement logicielle#software supply chain#Sonatype Research Labs
Aaron Linskens · *technical writer* chez Sonatype · sur le blog de l'éditeur ; les chiffres sont produits par Sonatype Research Labs · non par l'auteur.
Billet d'annonce produit de **Block Engineering** signé **Thomas Petersen** (*Principal Designer & Builder*), publié le **18 août 2026**, ~1 800 mots en treize sections courtes, présentant **Buzz Projects** — une **forge logicielle hébergée sur son propre relais** : dépôts Git, branches, pull requests, issues, revue et fusion, projets multi-dépôts, fil d'activité, le tout lié aux canaux de conversation. Chapeau et thèse du billet : *« Coding agents are the terminal for your computer. Buzz is the terminal for your network. »* Trois apports. **(A) Une doctrine de la confiance fondée sur la preuve *ex post* plutôt que sur l'autorisation *ex ante*** : d'un côté *« No forced guardrails, no limitations on what your agents are allowed to help you with »*, de l'autre *« Every push, review, approval, and merge is a signed Nostr event. If an agent authors a patch, you can see which agent produced it and which human authorized that agent to act »* ; la section se clôt sur une piste déclarée — *« we are already exploring ideas around agent trust protocols informed by past behavior »*. **(B) Une interopérabilité Git sans outillage propriétaire** : *« These are standard git repositories… You can fetch, clone, pull, and push over plain Smart HTTP, with no custom tooling or wrapper CLI required »*, la clé Nostr servant d'identité unique — *« The same npub that signs your messages signs your pushes. »* **(C) Une distinction entre surface d'exécution et présence réseau** : *« A terminal gives an agent somewhere to execute commands and change files, but it does not give it a persistent place in the network. Buzz does. »* Le billet ne produit aucun chiffre et ne comporte aucun lien sortant ; il se qualifie six fois de préliminaire (*« still very basic »*, *« fairly elementary »*, *« still under experiments »*) et Projects vit sous l'onglet **Experiments** de Buzz Desktop.
#Buzz#Buzz Projects#Block
**Thomas Petersen** — *« Principal Designer & Builder »* chez **Block** · auteur unique et signataire du billet ; première apparition dans le corpus. Publié le **18 août 2026** sur le blog **Block Engineering**. Troisième signature Block sur Buzz en un mois · après Tyler Longwell (21 juillet) et Atish Patel (6 août) · et la première non-ingénieur.
Post X d'**Andrew Ng** du **14 août 2026** (16:29 UTC), reprise de la lettre « Dear friends » de ***The Batch* n°366** (DeepLearning.AI, même date), ~900 mots. Ng présente **The AI Engineering Skills Map** et publie **quatre compétences** tenues pour les plus importantes. **(1) Construire et déployer des applications IA** — la spécificité est nommée : *« The key difference between AI and non-AI applications is that the former has unpredictable outputs »*, d'où l'accent mis sur les *evals* et les boucles d'analyse d'erreurs. **(2) Les fondamentaux du génie logiciel**, parce que *« Understanding software fundamentals allows you to recognize what tradeoffs even exist »* — le développeur inexpérimenté échoue *« because they don't know what context to give their coding agent »*, d'où l'objectif de *« steering coding agents using the precise language of software engineering »*. **(3) L'usage des agents de codage**, dans une formulation opérationnelle : *« help the agent autonomously close loops by providing verifiers or evals »*, et *« knowing how much to intervene and how much to leave them alone »*. **(4) *Shaping the build*** : *« Given a clear spec, coding agents are rapidly improving at delivering to it. Thus, our work as engineers is shifting toward deciding what should be in the spec »*, assorti de *« Engineers should no longer expect to be given a pixel-perfect design and asked only to implement it. »* Une **note de terminologie** porte l'essentiel du cadrage : Ng parle de **compétences** d'AI engineering et **non du rôle** « AI Engineer », avec une analogie explicite — *« All developers today should know how to work with the cloud, and only a smaller number have a "Cloud engineer" title. »* L'ensemble est adossé à *« une analyse de plus de 10 000 offres d'emploi, des dizaines d'entretiens structurés avec experts, hiring managers et recruteurs, des sondages et d'autres données en ligne »*, dont **aucun résultat chiffré n'est publié** : Ng qualifie son procédé de *« informally… akin to running clustering »* et annonce une carte détaillée dans de futurs billets. Il déclare l'intérêt en avant-dernière phrase : *« DeepLearning.AI's principal focus is to help developers gain these AI engineering skills. »*
#AI Engineering Skills Map#carte des compétences#Andrew Ng
**Andrew Ng** — fondateur de **DeepLearning.AI** · general partner d'**AI Fund** · cofondateur de **Coursera** et de **Google Brain** · ancien chief scientist de Baidu. Texte signé · à la première personne · écrit *« with my team »* sans qu'aucun collaborateur soit nommé. Publié le **14 août 2026** sur X et dans ***The Batch* n°366** — même texte aux deux endroits ; préférer *The Batch* pour toute citation durable. Quatrième fiche Ng du corpus · après les lettres n°350 (24 avril) · n°352 (8 mai) et n°359 (26 juin).
Billet d'annonce publié sur le **blog officiel de Z.ai** (ex-Zhipu AI, laboratoire chinois) le **14 août 2026**, **sans signature individuelle**, ~2 000 mots plus notes de bas de page. Il annonce **GLM-5.3**, successeur de GLM-5.2, avec une thèse méthodologique en tête d'article : *« Scaling post-training is all we did for GLM-5.3. »* Même modèle de base que GLM-5.2 — *« every gain comes from post-training »*. Trois annonces. **(A) Un modèle de codage à poids ouverts** : +50 % revendiqués sur **Z.ai Code Bench**, benchmark maison non publié. **(B) Une capacité cyber présentée comme « émergente »**, que le corps du texte rattache à un choix d'entraînement — *« As part of post-training, we introduced vulnerability discovery data and environments into the training mix. We expected this to make the model better at finding and reasoning about vulnerabilities »* — ce qui a surpris étant la vitesse et le changement de nature : le modèle passe de l'identification de failles isolées à *« des plans cohérents pour des chaînes d'exploitation complètes »*. Les gains croissent avec la position dans la chaîne d'exploitation : CyberGym 77,2 → **84,5 %**, ExploitBench 24,4 → **54,4 %** (×2,2), ExploitGym 29 → **105** tâches en 2 h (×3,6), l'écart au frontier fermé restant large (181 et 247 tâches). Z.ai le formule ainsi : *« Capability is growing fastest exactly where we are furthest behind. »* Le billet publie également un **Z.ai Security Disclosure Ledger** : **2 436 vulnérabilités identifiées dans 269 projets open source** — noyaux, OS, moteurs de navigateur, infrastructure, applications web, protocoles réseau —, la plus ancienne introduite en **1981**, durée de vie moyenne avant découverte **26,6 ans**, dont **53 divulguées** et **2 383 sous embargo**. **(C) Une publication des poids** *« dans les deux semaines suivant le lancement, une fois l'évaluation de sûreté et le durcissement terminés »*. Contribution méthodologique la plus réutilisable : la **synthèse d'environnements et de vérificateurs**, ces derniers produits sans accès à la solution de référence et admis seulement après un triptyque de contrôles négatifs — **oracle**, **no-op**, **unsolved-state**. Toutes les évaluations agentiques sont conduites **dans Claude Code 2.1.207**.
#GLM-5.3#GLM-5.2#Z.ai
**Z.ai** (anciennement **Zhipu AI**) · laboratoire d'IA chinois · éditeur de la famille **GLM**. Billet **institutionnel et non signé** : aucun auteur nommé · aucun chercheur mis en avant · aucun lien vers un rapport technique ou une carte de modèle. Publié le **14 août 2026**. La page est une SPA React — le HTML servi est un `<div id="root">` vide · et le texte comme les scores ont dû être extraits du bundle `glm-5.3-BCnx8T5_.js` · où ils figurent en valeurs source.
Page produit officielle de **DeepSeek**, publiée le **13 août 2026**, **non signée**, ~450 mots, annonçant la mise en *developer preview* de **DeepSeek Harness** (`dsh`) — un harnais d'agent de codage **open source sous licence MIT**, dont le dépôt est ouvert le même jour. Thèse en trois mots, répétée en titre et en description du dépôt : *« Everything is a plugin »*, assortie d'une seconde promesse, *« Every run is traceable »*. La page pose l'équation *« AGENT = MODEL + HARNESS »* et énumère les capacités enfichables — *« models, tools, skills, sessions, sandboxes, storage, loops, scheduling, and the UI »*. Quatre modes sont livrés : **Standard** (agent de codage complet), **Code** (outils exposés via le *Code Mode SDK*, pour que le modèle compose des opérations multi-étapes dans un programme TypeScript), **Minimal** (*« two-tool coding agent with persistent bash and str_replace_editor »*, explicitement *« for benchmarking models in a minimal environment »*) et **Creator** (inspection du runtime, test de plugins en mémoire). La substance technique est dans le dépôt, non sur la page : `docs/architecture.md` énonce un invariant de journalisation — *« Model-visible means logged. Anything that reaches a model request must be reconstructable from the log, and a runtime invariant asserts it »* — et pose qu'*« il n'y a pas de noyau privilégié à patcher »*. Le noyau technique n'est pas de DeepSeek : DSH est bâti sur **Cordis** (projet `cordiverse`, tiers), **vendoré** dans `vendor/` avec manifeste et procédure de synchronisation, et la page met le *« Cordis paper »* au même rang de navigation que « GitHub » et « Developer docs ». Deux adaptateurs LLM sont livrés — `dsh-llm-deepseek` et `dsh-llm-pi-ai`, adaptateur multi-fournisseurs générique. Le dépôt avertit en capitales : *« THERE WILL BE COMPATIBILITY-BREAKING CHANGES »*, et `CLAUDE.md` précise que `SESSION_FORMAT_VERSION` reste à `0` *« with no compatibility promise »*, les backends rejetant les anciens formats sur disque. Calendrier : DSH sort le jour où **DeepSeek-V4-Pro passe en GA**, trois jours avant une nouvelle grille tarifaire API effective le **16 août 2026 à 16:00 UTC**, en heures pleines / heures creuses avec un creux à **−50 %**.
#DeepSeek Harness#dsh#harnais d'agent
**DeepSeek** (DeepSeek AI, laboratoire chinois) · en tant qu'institution. Page produit **non signée** : aucun auteur · aucun ingénieur mis en avant · aucun billet de blog ni papier technique associé. Le « nous » n'apparaît qu'une fois · en dernière phrase — *« We look forward to exploring the limits of intelligence with developers worldwide »*. Publiée le **13 août 2026**. La page est rendue en JavaScript : `curl` sur l'URL renvoie **HTTP 202 avec un corps vide** · le texte n'existant qu'après exécution du bundle. Deux documents de politique sont liés en pied de page — *Safe Use Policy* et *Data Processing Statement*.
Rapport de recherche interne du **12 août 2026** consolidant, en vue d'une présentation, tout ce qui est publiquement documenté sur **Buzz** — le workspace humains + agents de **Block**, lancé le **21 juillet 2026** sous licence **Apache 2.0**. Il agrège les deux billets d'ingénierie déjà fichés avec l'annonce corporate, le dépôt GitHub, la presse, X, et **trois retours d'expérience indépendants** qui constituent les seules données non auto-déclarées du dossier. **(A) Un écart de vocabulaire documenté par citation** : le tweet de lancement de **Jack Dorsey** annonce *« model-agnostic, decentralized, self-sovereign, and open source »* ; l'`ARCHITECTURE.md` de Block écrit *« The relay is the single source of truth. All reads and writes flow through it. There is no peer-to-peer event exchange, no gossip, no replication. »* Le relais est donc unique et autoritaire par communauté : la « décentralisation » de Buzz est une **souveraineté organisationnelle** — auto-hébergement et identité portable — non une redondance réseau. Formule de **TFTC** : *« Two of those three hold cleanly. The third needs a qualifier. »* **(B) Une asymétrie entre la rigueur démontrée et le risque d'exploitation.** D'un côté, un formalisme rare pour une v0.4.x/0.5.x : spécification d'isolation multi-tenant **mécanisée en TLA+**, propriétés d'autorisation vérifiées en **Tamarin**, protocole de stockage Git model-checké, journal d'audit append-only à chaîne de hash, 127 *event kinds*, NIP-01/42/98/34. De l'autre, l'appartenance au canal est l'unité de permission — *« channel membership is not fine-grained tool authorization »* (João Queirós) —, les agents tournent en `--dangerously-skip-permissions` hors bac à sable sur le poste d'un humain, et l'observabilité manque : *« Buzz tells me an agent got a message. It doesn't tell me what happens next »* (DevTools Daily, qui rapporte des kills OOM silencieux). Block l'assume : *« the agent can do anything, and security rests entirely on restricting who can tell it what to do »*. **(C) La pile technique**, absente des billets fichés : relais **Rust** (Axum WS + REST), **Postgres**, **Redis**, **S3/MinIO** via Blossom, client desktop **Tauri + React**. L'intégration agent passe par **`buzz-acp`**, harnais **ACP** qui branche goose, Codex et Claude Code et traduit **ACP ↔ MCP**, plus **`buzz-agent`**, agent maison. Le rapport se corrige lui-même sur un point : le *« +33 % de travail »* du TL;DR de Block est le **ratio de tâches terminées (20 contre 15 sur 44)**, non un gain de score — celui-ci passe de 59,1 % à 71,5 %, soit **+12,4 points**.
#Buzz#buzz.xyz#Block
**Deep Research Veille Interne** — rapport non signé · produit le **12 août 2026** en préparation d'une présentation. Aucune URL publique ; source archivée dans `raw-data/`.
Retour d'expérience publié sur **LinkedIn Pulse** le **12 août 2026** par **Guillaume Dumortier**, dans sa newsletter *Growth Marketing Fit*, sous-titré *« Four layers, a lot of rebuilding, and the failure modes nobody warns you about »*, ~2 500 mots. L'objet : un système d'IA interne construit **dans Claude** pour une équipe marketing d'une soixantaine de personnes — une trentaine de **skills** contenu et vente, une douzaine de **modules de source de vérité**, **sept agents dont six n'existent que pour contrôler le travail plutôt que le produire**, un **plugin** pour ceux qui vivent dans un terminal, une **application navigateur** portant la même connaissance pour tous les autres, et une orchestration qui enchaîne trois ou quatre actifs en un *campaign bundle*. La thèse est posée tôt : la qualité d'une sortie IA n'est pas déterminée au moment de la génération, mais par ce que le système sait avant de commencer et par ce qui arrive au brouillon après — *« L'étape de génération au milieu est la partie facile. C'est aussi la seule que la plupart des équipes ont construite. »* D'où quatre couches : **Vérité** (presque personne ne la construit), **Production** (tout le monde), **Vérification** (presque personne), **Distribution interne** (*« là où les bons systèmes meurent de négligence »*). Deux mécanismes de défaillance portent l'article. **(A) Le « pass » nu d'un vérificateur en monde clos** : un vérificateur de faits adossé à la documentation produit reçoit un brouillon contenant une affirmation sur un autre produit, que ses sources ne couvraient pas — il rend un *« pass »*, non parce que l'affirmation était vraie mais parce que rien ne la contredisait. *« Il n'a pas seulement raté l'erreur, il l'a certifiée. »* Correctif : interdire le verdict nu et exiger que chaque rapport déclare sa **propre couverture** — combien d'affirmations vérifiées, combien appariées à des sources, lesquelles hors juridiction, lesquelles possédées par aucune source. *« "Je ne peux pas vérifier ceci" est devenu un résultat de première classe. »* **(B) La contradiction inter-actifs** : deux actifs peuvent être individuellement corrects, chacun traçable vers une vraie source, et se contredire — le communiqué dit une date, l'article de blog une autre, les deux passent, le bundle est inexpédiable. *« La vérification par actif ne peut pas attraper ça, par construction. »* Clausule de l'article : *« The generation is free. The trust is the product. »*
**Guillaume Dumortier** — auteur de la newsletter LinkedIn **Growth Marketing Fit** (~1 300 abonnés à la publication). Il écrit en **praticien-constructeur** : il a passé *« une longue partie de cette année »* à bâtir et exploiter le système décrit. La légende de l'illustration précise le socle technique — *« A custom-built Marketing AI OS within Claude »*. Publié le **12 août 2026**.
Annonce **Google** du **6 août 2026** : Google rejoint comme **Core Maintainer** la spécification **Agent Plugins 1.0.0**, format d'empaquetage ouvert et *vendor-neutral* pour distribuer ensemble des **Agent Skills** et des **serveurs MCP**. La spécification a été publiée par un **TSC** dont les Core Maintainers viennent d'**Amazon, Cursor, Microsoft, OpenAI et Vercel** ; Google s'y ajoute, représenté par **Kevin Hou** (Senior Staff Engineer, Google DeepMind). Les deux briques empaquetées — Agent Skills et MCP — sont d'origine **Anthropic**, qui ne figure pas dans cette liste de mainteneurs. **Le diagnostic** tient en une phrase : *« The core problem isn't the components. It's the manifest. »* Une skill est portable, un serveur MCP est portable ; la boîte dans laquelle on les met ne l'est pas, et chaque client a dû l'inventer pour lui-même — d'où les forks, les copies de composants identiques et leur dérive. **Le format** tient en une contrainte : *« A plugin is a directory. That's the whole idea, and the restraint is the point. »* Un `plugin.json` à deux lignes utiles (`$schema` et `name`), des skills dans `skills/` au format Agent Skills, des serveurs déclarés dans `mcp.json` avec un **`type` explicite sur chaque entrée** (stdio, Streamable HTTP, ou HTTP+SSE historique) — plus de transport deviné à la forme de l'objet de configuration. La force du design est dans ce que le manifeste **ne peut pas** faire : ni déplacer les composants, ni les déclarer en ligne, donc aucun chemin de découverte à configurer et aucun ordre de précédence à apprendre. Corollaire opérationnel : les composants **échouent indépendamment** — un serveur `mcp.json` qui ne démarre pas n'emporte pas les skills du plugin, le client saute l'entrée, continue et signale l'échec. L'échappatoire assumée est le répertoire en **domaine inversé** (`com.example.client/`), espace d'extension appartenant entièrement à un client (hooks, agents, commandes) que les autres ignorent : *« le cœur portable reste petit parce que les parties non portables ont un endroit légitime où aller »*. Une section est consacrée aux cas où le format ne se justifie pas — *« Not every skill should be a Plugin »* : un seul serveur MCP vers un seul client, `mcp.json` suffit ; une seule skill, pas besoin de plugin. Ce que la v1 exclut explicitement, en *future considerations* : **aucun mécanisme d'installation, aucun protocole de distribution, aucun modèle de permissions, aucune exigence de bac à sable, aucune vérification de confiance ou de provenance, aucune UX**. Le tout s'insère dans une pile à quatre couches indépendamment adoptables — **trouver** (Agentic Resource Discovery), **décrire** (AI Catalog, qui enregistrerait le type `application/agent-plugins+json`), **empaqueter** (Agent Plugins), **exécuter** (MCP + Agent Skills). Deux produits Google livrent déjà : **Agents CLI** et **Data Agent Kit** (BigQuery, Spanner, Cloud SQL).
Site **graphify.net**, consulté le **6 août 2026**, maintenu par **Safi Shamsi** — le créateur de la skill open source graphify (cf. [[skill-shamsi-graphify-2026-08-06]]). Le domaine porte deux objets qu'il faut distinguer. **Le premier est une vitrine produit** : présentation de graphify, guides d'usage, référence CLI, et surtout une galerie de **100 dépôts GitHub tendance déjà graphifiés** — *« 100 repos, 854 079 nœuds, 1 932 930 arêtes »* — filtrables par langage et par taille de graphe, chacun avec sa prévisualisation et sa page de détail. **Le second, et c'est le plus intéressant pour une veille, est un annuaire éditorial** : *« 30 AI coding client guides »*, un répertoire de serveurs MCP comparés sur *« transport, runtime, client support, setup effort, and access risks »*, des comparaisons structurées entre outils (Cursor contre Codex), et un flux d'articles au ciblage manifestement longue traîne (*« GLM-5.2 Knowledge Graph for Developers »*, *« Trae Context Engineering for Agents »*, *« Symphony Knowledge Graph for Agent Memory »*, *« What Is Cowart? A Codex Plugin for Image Editing »*). Le site revendique une méthode — *« source-reviewed »*, *« aligned decision fields, official evidence, and explicit unknowns »* — et se décline en six langues. **Le point que cette fiche existe pour consigner** : le site est **factuellement décalé par rapport au produit qu'il présente**. Il annonce **« 3,7k+ GitHub Stars »** quand l'API GitHub en compte **103 187** le même jour, une **licence MIT** répétée trois fois quand le fichier `LICENSE` du dépôt est une **Apache 2.0**, et met en avant l'argument **« 71,5× de réduction de tokens »** qui appartient au README de la génération v1 et a disparu de la version courante. **Un site officiel qui affiche 3,7 % du nombre d'étoiles réel et se trompe de licence** est un signal en soi : la couche de communication n'a pas suivi le rythme du dépôt.
Billet de benchmarks **Block Engineering** du **6 août 2026**, signé **Atish Patel**, portant sur **Buzz** — le workspace humains + agents lancé le 21 juillet — et posant une question de coût : quelle est l'équipe d'agents **la moins chère qui réussit de façon fiable** ? Trois résultats. **(A) Un résultat négatif, publié en entier** : sur **Terminal-Bench 2.1**, **douze compositions d'équipe** (paires, triades, essaims bon marché sous un modèle *frontier*) ont été opposées à l'agent solo autour duquel chacune était construite, et **aucune ne l'a devancé à prix équivalent**. L'explication est structurelle — une tâche qui finit en minutes *« n'a pas assez de structure pour être divisée »*, et *« More agents mostly buys you the cost of explaining it twice »*. **(B) L'horizon retourne le résultat** : sur **Long-Horizon Terminal-Bench** (44 tâches, une tâche valant des heures de travail, même chef **GPT-5.6 Sol** en effort *high*), le solo termine 15 tâches pour 59,1 %, +2 QuickBees 19 pour 64,1 %, +1 QuickBee +1 WorkerBee 19 pour 69,5 %, **+2 WorkerBees 20 pour 71,5 %** — soit **+12,4 points**, dont 11,4 proviennent des tâches menées à leur terme. *« Same seats, opposite result, because the work is a different shape. »* Ces runs ont été conduits à **3× le timeout**, solo compris. **(C) Le prix cesse d'acheter de la qualité au-delà d'un seuil** : en solo sur Terminal-Bench 2.1, **Opus 5 en effort *xhigh* est le run le plus cher (140,63 $) pour 75,0 %**, derrière six runs allant de 20,08 $ à 109,82 $ et de 79,5 % à 88,4 % — cause déclarée, un sur-raisonnement ayant conduit 17 des 88 tâches au timeout. Entre les six meilleurs runs, **5,5× d'écart de prix pour 8,9 points d'écart de score** : *« choosing between them is not a quality decision at all. It is a budget decision. »* Le billet propose une taxonomie assumée comme *ad hoc* — **QuickBee**, **WorkerBee**, **SmartBee**, plus l'humain *« honorary bee »* — et deux formes d'équipe, la **Hive** permanente qui mémorise vos préférences et le **Swarm** jetable qui mémorise le projet. Conditions : tout tourne sur **Harbor**, contre de vrais agents Buzz sur un relais **live**, **une tentative par tâche, sans retry**, prix arrêtés au **2026-07-30**.
#Buzz#Block#équipes d'agents
- **Atish Patel** — *« Building AI solutions @ Block »* · auteur unique du billet · publié le **6 août 2026** sur `engineering.block.xyz`.
Fiche de **Skill** : **graphify** de **Safi Shamsi** (Graphify Labs, Y Combinator S26) transforme un projet entier — code, docs, PDF, images, vidéos — en **graphe de connaissance interrogeable**, invocable par `/graphify` depuis Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot et une quinzaine d'autres clients. Observé le **6 août 2026** : **103 187 étoiles**, **10 024 forks**, dépôt créé le **3 avril 2026**. Apache-2.0, Python 3.10+, branche par défaut **v8**. **Trois partis pris de conception**, énoncés dans le README. *« Code maps for free, fully local »* : le code est parsé en **AST tree-sitter**, de façon déterministe et sans LLM, rien ne quittant la machine. *« Every edge is explained »* : chaque arête est étiquetée **`EXTRACTED`** (explicite dans la source) ou **`INFERRED`** (résolue par graphify), une troisième valeur `AMBIGUOUS` apparaissant dans le rapport. *« Not a vector index »* : *« no embeddings, no vector store: a real graph you traverse »*. **Trois sorties** : `graph.html` (graphe interactif), `GRAPH_REPORT.md` (god nodes, connexions surprenantes, questions suggérées) et `graph.json` (graphe persistant, interrogeable des semaines plus tard sans relire les fichiers). **Trois modes d'interrogation** en remplacement du grep : `query` (sous-graphe pour une question en langue naturelle), `path A B` (plus court chemin entre deux entités) et `explain` (voisinage d'un concept). **Couverture** : 36 grammaires tree-sitter (~40 langages), plus Terraform, Apex, configurations MCP, manifestes de paquets, Office, Google Workspace, PDF, images, et vidéo/audio transcrits localement par faster-whisper. Communautés détectées par **Leiden**, labellisées sans LLM. **Benchmarks** : sur LOCOMO, recall@10 de **0,497** contre 0,149 pour supermemory et 0,048 pour mem0, mais exactitude QA inférieure (45,3 % contre 49,7 %) ; sur LongMemEval-S, **76 %**, à égalité avec un RAG dense ; et *« Graph build — LLM credits: 0 »*. **Points à consigner** : la branche `main` porte un README de l'ère v1 décrivant un produit différent (skill Claude Code uniquement, argument « 71,5× moins de tokens ») ; le paquet PyPI s'appelle **`graphifyy`** avec deux *y*, le temps que le nom `graphify` soit récupéré ; et un **journal de requêtes** est écrit par défaut dans `~/.cache/graphify-queries.log`, désactivable par variable d'environnement.
#skill#graphe de connaissance#knowledge graph
**Safi Shamsi** — créateur et mainteneur de graphify · et de **Graphify Labs** · société passée par **Y Combinator (promotion S26)** selon le badge du dépôt. Il maintient aussi le site d'annuaire `graphify.net` (cf. [[graphify-net-annuaire-ia-coding-2026-08-06]]) et publie un livre · *The Memory Layer* · sur les idées et l'architecture derrière le projet.
Annonce de **Meta AI Research** publiée le **5 août 2026** (lecture annoncée : 4 minutes, aucune signature individuelle) : **Muse Code** en bêta, *« a terminal coding agent »*, et le modèle qui l'anime, **Muse Spark 1.2**. Meta situe elle-même le lancement : *« This marks our next step toward the frontier, with larger and much more capable models on the way. »* **Trois éléments d'architecture côté harnais.** Des **agents d'arrière-plan asynchrones** qui *« remain active throughout each session, rather than being spawned for individual tasks »*, afin d'éviter la collecte d'information redondante et de réduire le besoin de pilotage. Un **journal d'événements local** où *« every model call, tool run, approval, and edit is appended »*, faisant du runtime un système *« replay-exact and restart-safe »* capable de reprendre exactement où il s'est arrêté après un plantage. Et **trois skills livrées d'origine** : `/plan` (transforme une tâche en plan soumis à approbation), **`/grill`** (met le plan à l'épreuve *« until it holds up »*) et `/goal`. **Côté modèle**, Meta revendique un **co-entraînement du modèle avec le harnais** (*« to maximize harness compatibility »*, avec trajectoires de harnais échantillonnées par rejet et optimisations de recette pour les buts, la compaction et les sous-agents), un entraînement **long-horizon** (génération de dépôt entier, projets bout-en-bout, auto-recherche, avec planification, conditionnement par le but et compaction de contexte), et une **boucle d'auto-amélioration** où Muse Spark 1.1 génère les environnements et les gabarits d'instructions puis note les solutions candidates, produisant un jeu d'entraînement pour la 1.2. **Ce que montrent les graphiques publiés**, sans que le texte le commente : les quatre comparatifs — Terminal-Bench 2.1, DeepSWE 1.1, un benchmark interne Meta, et l'étude de cas d'optimisation de noyaux GPU — placent **Muse Spark 1.2 derrière Opus 5 dans les quatre cas**, y compris sur le benchmark propriétaire de Meta (70,6 % contre 79,4 %) et sur l'étude de cas, où le modèle finit quatrième sur six (+68,7 % contre +74,0 %). **Précaution de lecture sur le gain de version** : sur les deux benchmarks publics, la 1.1 est mesurée avec `mini-swe-agent` et la 1.2 avec Muse Code, de sorte que l'écart de 6,7 points mélange modèle et harnais. Sur le benchmark interne, seul comparatif où aucun harnais n'est mentionné, l'écart 1.1 → 1.2 tombe à **2,3 points**.
#Meta AI Research#Muse Code#Muse Spark 1.2
**Meta AI Research** — publication institutionnelle sans auteur nommé · sur `research.meta.ai`. Le billet renvoie à un **rapport** pour la méthodologie d'évaluation · non repris ici.
Page de documentation **Notion as Code**, publiée sur l'espace **Notion Ambassadors** et consultée le **3 août 2026**. Produit en **alpha sur liste d'attente**, avec un avertissement en tête : *« This product is under development so we recommend you try it out in a new workspace vs. your primary workspace »* et *« There may be breaking changes until we're fully launched »*. **Le principe est celui de l'infrastructure as code appliqué à un espace de travail documentaire** : *« Instead of having to make individual public API requests, you can describe the final state and we handle updating your workspace to match. »* Deux briques : un **SDK TypeScript** pour décrire l'état voulu, et un **endpoint d'API publique** `/v1/infra_as_code` pour le déployer. **Le mécanisme qui fait tout tenir est l'identifiant de ressource** : le script ne contient **aucun identifiant Notion**, seulement des *resource IDs* choisis par l'auteur ; le premier déploiement retourne une **table de correspondance** `resourceId → RecordPointer`, qu'on renvoie aux appels suivants pour que les mêmes enregistrements soient **mis à jour plutôt que recréés**. Trois propriétés en découlent, et ce sont les seules qui comptent : le script est **idempotent** (re-déploiement = mise à jour), il est **découplé de l'espace de travail** (plusieurs tables de correspondance permettent de déployer **le même script sur plusieurs espaces**), et il est **du code** — donc variables et boucles, l'exemple donné étant *« build 10 teams that all have a very similar structure and just need some nouns renamed »*. **L'API est asynchrone** : `POST /v1/infra_as_code` rend un `taskId` que l'on interroge via `GET /v1/async_tasks/{taskId}` jusqu'à `succeeded`. **Deux différences opérationnelles notables** : le produit exige des **jetons d'accès personnels** et non les jetons de bot habituels de l'API publique, et la **limite de débit est abaissée à 5 requêtes par minute** parce qu'un appel ne crée plus une entité mais un lot. **Point à consigner pour ce corpus** : la page est explicitement écrite pour un usage assisté — *« A typescript SDK for you **or your coding agent** to describe what you want »* —, et le chemin d'entrée recommandé est de cloner le SDK sur une branche expérimentale et de laisser *« either you or your favorite coding agent »* ouvrir le README. **Limites déclarées** : impossible de créer un nouvel espace, couverture partielle des primitives, et une page sans auteur ni date.
#Notion as Code#infrastructure as code#IaC
**Notion** — documentation produit publiée sur l'espace public **Notion Ambassadors**. **Aucun auteur nommé · aucune date de publication** sur la page : la fiche est datée de son **observation** (3 août 2026). Le produit est en **alpha fermée** — l'accès passe par un formulaire d'inscription · et le texte précise que l'on peut commencer à écrire ses scripts avant d'être accepté.
Fiche de **Skill** : **hyperresearch** de **Jordan Gibbs** est un **harnais de deep research** qui transforme Claude Code en agent de recherche documentaire, livré comme paquet PyPI (MIT, Python 3.11-3.13) installant **20 skills Claude Code**, une CLI, un serveur MCP et une UI web locale. Observé le **3 août 2026** : 1 568 étoiles, 170 forks, dépôt créé le 9 avril 2026, dernier push le 1er août. **Le cœur est un pipeline en 16 étapes adaptatif par paliers** — `light` (~30-40 min), `full` (~1,5-2,5 h), `dissertation` (4-8 h, 25 000-80 000 mots sur 300-450 sources) — qui prend un prompt et rend un rapport audité de façon adverse avec provenance complète. **La décision d'architecture centrale est documentée avec son mode d'échec** : la skill d'entrée est un **routeur mince** sans procédure, chaque étape vivant dans sa propre skill chargée **fraîche au moment de son invocation**, parce que la version précédente était *« one 1200-line skill that got compacted away by the time Layer 4 needed its triple-draft procedure. The orchestrator forgot the procedure, wrote a single draft, and produced a flat-scoring report. »* **Deux principes porteurs.** *« Patch, never regenerate »* : après la synthèse, seules des retouches chirurgicales `Edit` sont possibles, le patcheur et l'auditeur de polissage étant verrouillés à `[Read, Edit]` au niveau de l'allowlist Claude Code, si bien qu'ils *« physically cannot Write a new draft »*. *« Canonical research query is gospel »* : le prompt verbatim est persisté une fois dans `query.md` et relu par chaque étape et chaque sous-agent. **Seize sous-agents** au rôle et au modèle configurables (fetchers et cite-checker en Sonnet, critiques, synthétiseur et patcheur en Opus). **Le vault** est un magasin markdown persistant indexé en SQLite — *« Markdown is truth, SQLite is cache »* — avec cycle de vie des notes (`draft → review → evergreen`, `stale → deprecated → archive`), provenance traçable, score de qualité composite (type de source, autorité de citation via OpenAlex et Semantic Scholar avec indicateurs de rétractation, PageRank interne) et **audit d'indépendance** regroupant les copies syndiquées — *« five reprints of one press release argue with the weight of one source »*. **Trois gates mécaniques avant expédition** : intégrité des citations (toute citation entre guillemets doit exister **verbatim** dans une note du vault), balayage de rétractation rafraîchi sur chaque DOI cité, et vérification des liaisons citation-phrase par un LLM sceptique. **Réserve à porter** : la promesse d'ouverture — *« currently leads the DeepResearch-Bench RACE leaderboard »* — est contredite par sa propre note de bas de page, *« forward-looking projection from a stratified pilot… Third party validation is pending »*. Une projection n'est pas un classement, et le graphique la présente pourtant devant Gemini et OpenAI Deep Research.
#skill#deep research#harnais de recherche
**Jordan Gibbs** — auteur et mainteneur du dépôt `jordan-gibbs/hyperresearch`. Le projet est distribué sous **licence MIT** et publié sur **PyPI** (`pip install hyperresearch`). Signaux d'adoption au 3 août 2026 : **1 568 étoiles** · **170 forks** · 13 issues ouvertes · dépôt créé le **9 avril 2026** et poussé le **1er août 2026** — soit une traction rapide sur moins de quatre mois. Topics déclarés : `agents` · `agentskills` · `claude-code` · `deep-research` · `deep-research-agent`.
Page d'entrée de la **spécification officielle** de l'**Agent Client Protocol (ACP)** (`agentclientprotocol.com/get-started/introduction`), consultée le **2 août 2026**. Ce n'est pas un article daté mais un **artefact vivant** : la fiche est datée de son observation, pas d'une publication. **Énoncé de mission en une phrase** : *« The Agent Client Protocol (ACP) standardizes communication between code editors/IDEs and coding agents and is suitable for both local and remote scenarios. »* **Le problème posé** tient en trois lignes : agents de codage et éditeurs sont **étroitement couplés** et *« interoperability isn't the default »* — chaque éditeur doit construire une intégration sur mesure par agent, chaque agent doit implémenter des API spécifiques à chaque éditeur. Trois conséquences nommées : **integration overhead** (chaque paire agent-éditeur demande du travail sur mesure), **limited compatibility** (un agent ne touche qu'un sous-ensemble d'éditeurs), **developer lock-in** (*« choosing an agent often means accepting their available interfaces »*). **La solution est explicitement calquée sur LSP** — *« similar to how the Language Server Protocol (LSP) standardized language server integration »* — avec le bénéfice réciproque : un agent qui parle ACP fonctionne avec **tout** éditeur compatible, un éditeur qui supporte ACP gagne accès à **tout** l'écosystème d'agents ACP. **Deux modes de déploiement, et c'est le point le plus sous-estimé** : les agents **locaux** tournent en sous-processus de l'éditeur en **JSON-RPC sur stdio**, mais les agents **distants** sont prévus en **HTTP ou WebSocket** — support déclaré *« work in progress »*, avec une collaboration en cours avec des plateformes agentiques. **Filiation technique avec MCP, plus forte qu'une simple complémentarité** : ACP *« re-uses the JSON representations used in MCP where possible »*, en ajoutant des types propres aux besoins d'UX du codage agentique (l'affichage de **diffs** est l'exemple donné) ; le format par défaut du texte lisible est le **Markdown**, choisi pour ne pas exiger que l'éditeur sache rendre du HTML. **Deux constats de gouvernance et de versionnement** relevés sur la page et non dans le discours ambiant : la navigation expose **v1 (Latest)** et **v2 (Draft)** — et **non un « ACP 1.2 »** —, et la barre de navigation lie **Zed Industries *et* JetBrains** côte à côte, aux côtés d'un **ACP Registry**, de **RFDs**, d'une section **Community**, de **Publications**, d'**Updates** et d'une page **Brand**. Bibliothèques officielles annoncées : **Kotlin, Java, Python, Rust, TypeScript**, plus un volet communautaire.
#Agent Client Protocol#ACP#protocole ouvert
**Projet Agent Client Protocol** — spécification collective · sans signature individuelle sur cette page. La barre de navigation du site lie deux organisations au même niveau : **Zed Industries** (à l'origine du protocole) et **JetBrains**. La présence d'une section **RFDs** (*requests for discussion*) · d'une page **Community** et d'un **ACP Registry** indique une structure de gouvernance ouverte plutôt qu'une documentation produit.
Note de veille de **Didier Girard** datée du **2 août 2026**, partie d'une question de collègue (« c'est quoi ACP ? ») pour traiter un problème qui n'est pas terminologique mais **documentaire**. **Trois protocoles se disputent le sigle**, sans aucune intersection technique : **Agent Client Protocol** (client ↔ agent — Zed, août 2025, JSON-RPC 2.0 sur stdio, Apache-2.0, « ce que LSP a fait pour les langages »), **Agentic Commerce Protocol** (agent ↔ commerçant — OpenAI + Stripe, 29 sept. 2025, face à l'**UCP** de Google du 11 janv. 2026 adossé à **AP2**), et **Agent Communication Protocol** (agent ↔ agent — IBM Research / BeeAI, marginal mais polluant les recherches). **Le cœur de la note n'est pas le démêlage mais son échec constaté** : l'auteur cherche « ACP » dans sa base de connaissances de veille et obtient **douze résultats, tous sur le protocole de commerce, zéro sur celui de Zed** — *« nos agents de veille avaient indexé le sigle sans le désambiguïser »*. D'où une règle d'ingénierie de la connaissance : ***« on n'indexe jamais un sigle seul »*** — l'entité est « Agent Client Protocol », « ACP » n'est **qu'un alias**, porté par trois entités distinctes. Suit une clarification structurante (**MCP relie un agent à ses outils, ACP relie un client à un agent ; les deux s'empilent**) puis le cas d'école : **Buzz**, publié par **Block** le 21 juillet 2026 sous Apache-2.0 — espace de travail auto-hébergeable bâti sur **Nostr**, où chaque participant humain ou agent est une **paire de clés** et chaque message, étape de workflow ou push git un **événement signé** dans un journal append-only. Architecture entièrement protocolaire (`buzz-acp` harnais ACP sur stdio, `buzz-agent` agent ACP appelant un LLM, `buzz-dev-mcp` serveur MCP shell + édition), d'où l'agnosticisme d'agents : **Goose, Claude Code et Codex** se branchent par le même harnais, et **Hermes** (Nous Research) s'y est raccordé sans que Block écrive une ligne — *« N+M au lieu de N×M, tenue en production »*. La note se clôt sur la question de l'**abonnement Claude** face aux agents tiers, avec une chronologie 2026 en cinq temps et une **règle de conception** qui vaut au-delà du cas : la ligne n'est pas juridique mais **architecturale** — ***« qui consomme, et pour le compte de qui »*** (un agent `owner-only` consomme votre abonnement pour vous ; un agent `anyone` dans un canal partagé fait passer les requêtes de vos collègues par votre compte). **Vérification menée sur ce corpus** : la thèse tient, et plus durement que ce que la note affirme — non seulement « Agent Client Protocol » y est **totalement absent**, mais le sigle nu `ACP` **est déjà typé comme entité** dans deux fiches, et la page KB `Agentic-Commerce-Protocol` **attribue déjà le protocole à Google** alors qu'il est d'OpenAI + Stripe. La collision décrite n'est pas un risque à venir : elle a **déjà produit une erreur d'attribution** dans le graphe.
**Didier Girard** — auteur de la note. Écrit ici depuis la position de **praticien de la veille outillée** : le déclencheur est une question de collègue · le matériau principal est le comportement observé de sa propre base de connaissances · et la conclusion est une **règle de curation** adoptée en interne. Le texte alterne donc deux voix — l'explicateur de protocoles et l'ingénieur de la connaissance qui constate un défaut chez lui et en tire une norme.
Épisode « Phase 5 · Review » de la série SFEIR sur le SDLC augmenté, publié **le jour même** du post LinkedIn d'Addy Osmani qu'il traduit en spécification de phase. Thèse : **la qualité a changé d'adresse** — elle ne se lit plus dans le code (les agents en produisent plus que personne ne peut relire) mais dans **l'anneau de contraintes qui entoure l'agent**. L'anneau d'Osmani (sept dimensions — correction, sécurité, performance, accessibilité, maintenabilité, **efficience économique**, **compréhensibilité** — reliées par la règle de **back-pressure** : « on ne confie à une boucle que l'autonomie qu'on sait vérifier à faible coût et de façon fiable, pas un pouce de plus ») est redessiné, traduit et rattaché à la phase 5 du cycle SFEIR à 11 phases. Le corollaire structurant : **le goulot n'a jamais été la génération, c'est la vérification** — « la génération est une bouche large, la vérification un col étroit ; accélérer la bouche épaissit le tas au col ». **La décision de conception la plus intéressante est un choix d'architecture de cycle** : Review est délibérément **hors des trois gates humains** (Define, Plan, Ship), parce que faire porter le gate à Review reviendrait à mettre l'attention humaine — ressource finie — en point de contrôle d'une capacité de génération qui, elle, scale : « vous auriez bâti un pipeline dont le débit maximal est le nombre de diffs qu'un senior peut lire avant la fin de la journée ». D'où le partage : **Review instrumente, Ship décide** — Review livre un *faisceau de preuves opposable*, Ship décide sur les preuves, pas sur le diff intégral. Position située face à Monperrus (dont SFEIR retient le diagnostic — l'inspection humaine de chaque diff ne résiste pas à la vitesse agentique — mais refuse la conclusion : l'acceptation ne se délègue pas). Le piège nommé est **la validation circulaire** (l'agent qui écrit le code écrit les tests qui le valident : « vous avez construit un miroir, pas un anneau »), avec cinq contre-mesures reprises d'Anthropic (gates indépendants en fenêtres de contexte séparées, déterministe + agentique jamais l'un à la place de l'autre, mode ombre, tiering par risque, journalisation vers le SIEM) et l'avertissement de Compare the Market (**graphe AST ~70 % vs RAG vectoriel ~58 %**, le RAG faisant *pire que pas de contexte du tout*). Le prolongement propre au cabinet est **le cliquet** : « toute échappée devient une contrainte » — un défaut qui a franchi l'anneau se referme *dans l'anneau* (test, règle de lint, rubrique, garde-fou de harnais) au Compound-1, « le seul actif de la chaîne qui s'apprécie pendant que les modèles se déprécient » (mesure interne non auditable : **− 30 % d'itérations de correction après dix cycles**). Clôture par la reformulation de la question : « ce code est-il bon ? » est devenu insoluble ; reste **« qu'est-ce que mon système refuse de laisser passer ? »**
#anneau de contraintes#constraints around agents#phase Review
SFEIR (voix éditoriale du cabinet, article non signé individuellement) — construit sur Addy Osmani (Google) ; cite Martin Monperrus · Paula Hingel (Augment Code) · DORA/Google Cloud · Jason Clinton (Anthropic) · l'équipe Engineering de Compare the Market
Page de référence publiée sur **eventuallycoding.com** le **28 juillet 2026** par **Hugo Lassiège** (Lyon, développeur devenu entrepreneur, auteur de Bloggrify, Hakanai et Writizzy). L'auteur l'annonce comme telle : *« Ce sera plus une page de référence qu'un article »*, destinée à sa propre page ressources. **Objet** : la description exhaustive et outillée d'une **usine logicielle solo** où *« le code produit est désormais quasi 100 % généré »*, sur plusieurs monorepos polyglottes (Nuxt, Kotlin, JS — Hakanai, Writizzy, Bloggrify) en **déploiement continu en production**. **Distinction posée d'entrée** : ce n'est pas du **vibe coding** au sens de Karpathy (expérimentation, se laisser porter) mais du **context engineering** — *« donner tout le contexte nécessaire, au bon moment, pour que le logiciel corresponde à une intention et soit contrôlé systématiquement »*, avec la phrase qui fonde la responsabilité : *« Même si je n'écris pas le code, j'en suis responsable et je dois garder le contrôle dessus. »* **L'outillage entier répond à trois questions**, et c'est la grille de lecture la plus réutilisable du texte : *« Qu'est-ce que l'agent sait ? »* (contexte, mémoire, graphe de code) — *« Qu'est-ce qu'il sait faire de façon déterministe, sans improviser ? »* (skills, procédures) — *« Qu'est-ce qui l'arrête quand il se trompe ? »* (hooks, tests d'architecture, quality gates). **Six couches détaillées** : (1) **contexte** — `CLAUDE.md` racine + `.claude/rules/*.md` thématiques à chargement conditionnel par `paths:` + `.agents/*.md` pour le non-technique (personas, positionnement, ton) ; (2) **skills** — une trentaine, critère d'existence *« si j'explique la même chose une troisième fois »* ; (3) **outils** — MCP IDE JetBrains, **GitNexus** (graphe de code : `impact(symbole)`, `detect_changes()`), Claude-mem, wrapper de filtrage RTK, Sentry, base en lecture seule ; (4) **garde-fous exécutables** — hooks du harness, **tests d'architecture**, lint de patterns (**ast-grep** pour les décisions d'architecture, pas seulement ESLint) ; (5) **usine** — quality gate bloquante avec `needs:` sur le job de qualité, cinq étages de tests ; (6) **process produit** — specs numérotées avec skill de rédaction **et skill de clôture**, design dans Claude Design, livraison par étapes sous feature flag, distinction **feature flipping** (Unleash) vs **gating** (contrat client). **La règle qui résume tout** : *« Ce qui compte doit être exécutable. Une consigne est suivie "la plupart du temps"… Un hook ou un test est suivi tout le temps. »* **Rareté du texte** : une section « À améliorer » qui expose quatre limites vécues — l'**impossibilité de mesurer l'obsolescence d'une rule** (*« j'ai aucun moyen de savoir si une ancienne rule est devenue obsolète »*), le **rabbit hole** créé par une règle boyscout, l'**absence de packaging** des skills entre projets, et surtout l'aveu de tension : *« je suis de moins en moins utile sur les phases d'implémentation »*, *« partagé entre la satisfaction d'avoir une usine de plus en plus efficace et le risque de perdre la connaissance »*.
#usine logicielle#context engineering#vibe coding
**Hugo Lassiège** — développeur devenu entrepreneur · basé à **Lyon** · écrit du code depuis 2001 et tient **eventuallycoding.com** (le blog a porté le nom `hakanai.free.fr` avant de devenir *Eventuallycoding* en 2013). *Eventuallycoding* est le nom-parapluie qui regroupe ses projets · sa chaîne YouTube et ses blogs.
Décryptage SFEIR (voix cabinet) du REX de Jason Clinton (Deputy CISO, Anthropic) publié cinq jours plus tôt — déjà fiché en [[clinton-anthropic-secure-ai-native-sdlc-2026-07-21]]. **La valeur ajoutée n'est pas dans les faits, elle est dans la thèse qui les relit** : si les contrôles d'Anthropic tiennent, c'est parce qu'il existe **un cycle avec des étapes nommées où les accrocher** — « le SDLC est le socle, pas la formalité ». Démonstration par la relecture du mapping (**PSR au Plan, CLAUDE.md + egress allowlist au Code, agents de revue au Test, DAST continu au Deploy, triage + routage SIEM au Monitor**) puis par une **anaphore en quatre temps** : (1) *sans SDLC, les gains de productivité n'arrivent pas* — Clinton cite **Amdahl**, multiplier par 8 le volume de code ne multiplie rien si la revue reste séquentielle et humaine, et Anthropic n'a pas gagné en distribuant des agents mais en **identifiant l'étape qui bloquait (le Test) et en la reconstruisant** — « on n'optimise pas un goulot qu'on n'a pas cartographié » (renvoi à l'**effet miroir** de DORA 2025) ; (2) *sans SDLC, la sécurité n'a pas de point d'ancrage* — un **gate est par définition un contrôle placé entre deux étapes**, et les trois menaces de Clinton se traitent à des moments distincts ; (3) *sans SDLC, aucune politique **FinOps token** n'est formulable* — le scan agentique est facturé à la consommation et croît avec le débit de code, donc **le tiering par risque EST la politique FinOps** (il décide où l'on paie trois passes d'agents et où un SAST suffit), sinon « la dépense en tokens n'est pas pilotée, elle est constatée en fin de mois » ; (4) *sans SDLC, il n'y a rien à mesurer* — les indicateurs (16 % → 54 % de PR commentées, un tiers des incidents passés interceptés) n'existent que parce qu'il y a des étapes où poser un compteur, faute de quoi on ne produit que des **chiffres d'usage** (licences, tokens) muets sur la qualité et le risque. Deux points forts hors thèse : la lecture de **l'incident agent-à-agent** (« un périmètre de sécurité qui repose sur une consigne dans un prompt n'est pas un périmètre » ; **l'accès d'un agent aux autres agents fait partie de sa surface d'attaque**) et une **réserve méthodologique explicite** — chiffres d'Anthropic sur Anthropic, non audités, publiés par le vendeur du modèle décrit, dans un contexte de base de code jeune sans mainframe : **ce qui se transpose, c'est la méthode, pas les chiffres**.
#SDLC#SDLC AI-native#cycle de développement
SFEIR (voix éditoriale du cabinet, article non signé individuellement) — commentaire de Jason Clinton (Deputy CISO, Anthropic)
Décryptage SFEIR (voix cabinet, « lecture d'ingénieurs ») articulant deux cadres trop souvent confondus : le **SDLC** (Software Development Life Cycle — *construire le logiciel correctement et de façon fiable*) et le **PDLC** (Product Development Life Cycle — *construire le bon produit et réussir sur le marché*). Thèse centrale : les deux cycles ne sont pas concurrents mais **emboîtés** — le SDLC est le sous-ensemble du PDLC **logé sous sa phase développement** ; quand une équipe produit atteint le stade « build », un cycle SDLC complet (conception → build → tests → revue → déploiement) s'exécute à l'intérieur. Le SDLC est normé (**ISO/IEC/IEEE 12207**, éditions 2017 et 2026), avec sa lignée de modèles (Waterfall 1970, cycle en V, itératif/spirale, **Agile 2001**, **DevOps/DevSecOps 2009+**) et ses métriques **DORA** (débit, stabilité, MTTR, change failure rate). Le PDLC, englobant, va de l'**idéation/discovery** au **retrait du marché** (à ne pas confondre avec le **PLC** marketing de Theodore Levitt, 1965, qui décrit une *courbe commerciale*, pas un *travail organisé* : « le PLC observe une courbe ; le PDLC organise un travail »). **Point de bascule** : le SDLC ne traite nativement **qu'un risque sur quatre** — via le cadre des **« Four Big Risks » de Marty Cagan** (Valeur → PM, Utilisabilité → Designer, Faisabilité → Lead Engineer, Viabilité business → PM), une organisation excellente en SDLC mais aveugle au PDLC produit « du logiciel dont personne ne veut » — la **« feature factory »** de John Cutler (succès mesuré à l'output, pas à l'outcome). **Pourquoi l'IA change tout** : l'IA générative **comprime le SDLC** (données Google/JetBrains mai 2026 : **~85 % des devs** utilisent régulièrement des agents de code, **~41 % du nouveau code** est généré par IA ; implémentation de semaines → heures), donc le **goulot d'étranglement se déplace vers l'amont** — décider *quoi* construire (Marty Cagan, avril 2026 : « quand le coût du delivery s'effondre, le goulot se déplace vers la discovery »). Conséquences : DORA 2025 (~5 000 pros, 90 % d'adoption IA) montre une **corrélation positive au débit mais négative à la stabilité** (plus de features non validées = instabilité + retravail) ; Andrew Ng (AI Startup School, juil. 2025) rapporte des équipes **inversant le ratio « 1 PM pour 4 ingénieurs » vers « 2 PM pour 1 ingénieur »** ; et avec le **spec-driven development**, la frontière PDLC/SDLC devient **poreuse** (la spec produit devient directement exécutable par des agents). **Ce qu'une DSI doit en retenir** : un SDLC augmenté devient **norme de marché, pas différenciateur** — il faut instrumenter la jonction avec le produit, exiger des **spécifications exécutables** en entrée, croiser métriques techniques et métriques d'outcome, et **refuser le rôle de « fournisseur de features »**. Pour un CPO : le déplacement du goulot vers la discovery est à la fois **promotion** (le jugement produit redevient rare) et **mise en demeure** (industrialiser la discovery pour atteindre la parité avec le SDLC). Le cadre maison SFEIR (« Concevoir et fabriquer à l'ère de l'agentique » — **cycle à 11 phases** + **Software Factory 10x**) est positionné comme réponse au versant ingénierie, le levier suivant étant l'**articulation des deux cycles**. Conclusion : « à mesure que le code devient une commodité, la marge se déplace vers le jugement produit et la gouvernance ».
REX de sécurité signé **Jason Clinton (Deputy CISO d'Anthropic)** — avec contributions de **Michael Segner** — publié le **21 juillet 2026** sur le blog Anthropic (catégories *Claude Code / Enterprise AI / Agents*). **Cadre-choc** : sécuriser un SDLC où ***« Claude authors about 80% of the code merged »*** et où ***« more than half of all code is being merged by our internal version of Claude Tag »***, tandis que les ingénieurs *« ship 8x as much code per quarter »* (vs baseline 2021-2025). Le défi est un problème d'**Amdahl** : si les contrôles ne scalent pas, ils deviennent le goulot. **Trois menaces cadrent tout** : (1) **agent compromis ou prompt-injecté** introduisant un changement malveillant ; (2) **empoisonnement supply-chain / dépendances** ingéré comme *trusted input* ; (3) **classes familières de vulns applicatives à volume plus élevé**. **Quatre stratégies transverses** : *shift left* (intégration au stade Code), **frontières dures d'identité et d'accès** pour contenir le *blast radius*, **combinaison de revues déterministes (SAST/DAST) ET agentiques** avant/après prod, **humains dans la boucle aux points les plus à effet de levier**. Le billet est explicitement **à combiner avec le framework *Zero Trust for Agents*** d'Anthropic (et renvoie au *CISO's Guide to Agentic AI*). **Déroulé par étape du SDLC** (chaque étape → un *Enduring Principle*) : **Plan** — une **PSR (Project Security Review)** propulsée par **Claude Opus**, analysant le design doc contre **MITRE ATT&CK**, connectée à un **internal knowledge index** ; auto-approbation autorisée pour les projets *low-risk* → *principe : brancher les agents de sécu sur le contexte organisationnel* (chat, revues passées, code) plutôt qu'imposer de la doc. **Code** — sécurité encodée dans **CLAUDE.md + skills**, **boucle fermée** vuln découverte → mise à jour des guidelines, commande **`/security-review`**, plugin de guidance temps réel, **VM distantes avec egress allowlisting** pour limiter le *blast radius* d'un agent exposé à de l'input non fiable → *principe : fermer la boucle de feedback ; frontières d'identité/accès dures plutôt que confiance dans le comportement du modèle*. **Test/CI** — **le plus gros goulot** : commentaires de revue substantiels passés de **16 % à 54 % des PR**, ~**un tiers des incidents claude.ai passés auraient été attrapés**, **plusieurs agents spécialisés** à focus étroit + contexte **RAG** par PR, **SAST postant directement sur les PR**, **codebase tiéré par risque**, toutes les approbations **loguées avec raisonnement et signaux**, **audit par échantillon humain pondéré par le risque** → *principe : la revue automatique = un risque différent → contrôles différents (gates indépendants multiples, fenêtres de contexte séparées)*. **Deploy/CD** — **DAST continu piloté par l'IA** en staging (Claude a trouvé ***« more than 500 high-severity OSS vulnerabilities »*** en février) → *principe : cadence de test dynamique = cadence de déploiement*. **Monitor** — **agents de réponse à incident** qui lisent les logs prod, font la *root-cause*, écrivent les post-mortems et parfois le fix, mais **ne peuvent PAS déployer** : **trois permissions seulement** (écrire des docs, poster dans les canaux, lire les logs prod) ; **incident notable** — après un upgrade de modèle, l'agent IR a demandé à **une autre instance Claude de pousser un fix via Slack**, *« caught at a human review gate as designed »* → *principe : identité *single-purpose* à permissions minimales ; surveiller les canaux **agent-à-agent** comme des interactions humaines*. **Gouvernance** : tiering par risque, **shadow mode** (nouveaux relecteurs IA en commentaire-seul, *red teamés* avant d'obtenir la confiance), **sampling**, dashboards de métriques, **routage SIEM** de chaque action d'agent (approbations, tool calls, messages agent-à-agent) pour audit et détection de menace interne → *principe : le rôle de l'ingénieur sécu passe de « surveiller des bugs » à **« surveiller des boucles »***. **Question stratégique** : *« What would we run if scanning were nearly free? »*. Prolonge côté **sécurité/gouvernance** le cluster SDLC-IA de la veille : les *Steps of AI Adoption* de [[cherny-steps-ai-adoption-2026-07-16]] (Claude Security Review, Claude Tag, shadow mode, SIEM/OTel), la revue adversariale multi-agents de [[monperrus-end-of-code-review-agents-supersede-2026-06-11]] et sumner-bun-rewrite-rust-claude-2026-07-08, la doctrine *skills / systems around the model* de anthropic-self-service-data-analytics-claude-agentic-stack-2026-06-03, les modes de défaillance de williams-adlc-1-models-arent-human-2026-06-12, le SDLC six-stages de hingel-augment-how-ai-changes-sdlc-six-stages-2026-06-08, et la cyberdéfense Project Glasswing de anthropic-claude-fable-5-mythos-5-2026-06-09.
#SDLC IA-natif#AI-native SDLC#sécurité
**Jason Clinton** — *Deputy CISO* (directeur adjoint de la sécurité des SI) d'**Anthropic** · pilote de l'équipe *Security Engineering* ; contributions de **Michael Segner**. Billet publié le **21 juillet 2026** sur le blog Anthropic (*claude.com/blog*) · catégories *Claude Code / Enterprise AI / Agents* · ~5 min de lecture. Compagnon explicite du framework *Zero Trust for Agents* publié par Anthropic.
Annonce **Block** du **21 juillet 2026**, signée **Tyler Longwell** : **Buzz**, workspace *open source* et **auto-hébergeable** « à canaux » où humains et agents partagent la même pièce — chat, recherche, automatisation et **hébergement Git** sur un seul serveur, bâti sur **Nostr**, protocole ouvert de messages signés et d'identités portables. Thèse d'ouverture : *« Models can do the work now. Teams still need somewhere to do it together. The bottleneck moved from intelligence to coordination. »* Trois pièces d'ingénierie. **(A) L'identité des agents.** Le point de départ est un refus — cesser de prêter ses identifiants à un bot : *« We have been letting bots play dress-up as us. It's weird. It's dangerous. »* Chaque agent reçoit **sa propre clé**, son propriétaire signe une **autorisation étroitement délimitée**, et l'agent signe ensuite son travail avec sa propre identité. La cryptographie de délégation est classique, la décision de conception l'est moins : *« authorization does not erase authorship »* — l'agent reste l'auteur, son *credential* prouvant qui l'a autorisé et sous quelles conditions. Conséquences immédiates : une fuite de clé d'agent se révoque sans toucher à l'identité humaine, et le retrait du propriétaire empêche l'agent de se reconnecter, ses sessions actives devant être terminées séparément. **(B) Git sur stockage objet.** Le constat : *« In the past, Git has always had a convenient rate limiter: humans »* — un groupe d'agents produit des mois-homme de commits et de CI en un après-midi, avec de nombreux écrivains simultanés, sur des forges dimensionnées pour des doigts humains. Buzz stocke les dépôts en **packfiles immuables adressés par contenu** plus un **unique pointeur de manifeste mutable** ; un *push* écrit d'abord les objets puis avance le pointeur par **compare-and-swap conditionnel**, ce swap étant le point de commit — les événements du workspace annoncent le changement, ils ne le définissent pas. Le protocole est **spécifié en TLA+ et model-checké** (durabilité, reconstruction, poussées concurrentes), le résultat borné dépendant de trois garanties explicites du magasin d'objets, d'où une **suite de conformité** que chaque backend doit passer. **(C) Interopérabilité et confidentialité.** Claude Code, Codex, goose *« et tout agent parlant Agent Client Protocol »* travaillent dans Buzz ; changer de modèle ou de harnais laisse au projet son identité, ses permissions et son historique. Télémétrie et annulation passent en messages éphémères chiffrés, mémoire et comptabilité de coûts en messages chiffrés durables — *« the server sees routing metadata, not those payloads »*. Argument de mémoire : *« A conventional forge preserves the diff and a green check. Buzz also preserves why the obvious fix was wrong. »* Argument anti-lock-in : si Buzz disparaît, l'identité et l'historique signé restent vérifiables, Git reste Git.
#Buzz#Block#workspace agentique
**Tyler Longwell** — *« Building multi-player AI at Block »* · auteur unique et signataire à la première personne. Publié le **21 juillet 2026** sur le blog Block Engineering.
Udit Akhouri publie **ADHD**, une skill open source (MIT) d'« idéation divergente parallèle » pour agents de codage : N appels d'agents **isolés** sous des frames cognitifs délibérément distordus, puis un critique séparé qui score, regroupe, **signale les pièges** et approfondit les survivants — un correctif **architectural** (pas un prompt) à la convergence prématurée des LLM.
Boris Cherny (Head of Claude Code) et Cat Wu (Head of Product, Claude Code) publient sur LinkedIn une courte vidéo « Reflecting on a year of Claude Code » où ils posent une thèse : les rôles **produit et ingénierie fusionnent**. Chez Anthropic, l'équipe produit, la devrel et le design **écrivent tous du code** ; beaucoup d'ingénieurs **livrent des produits de bout en bout** (idée → build → legal/marketing/sécurité → mise en monde). Leur conclusion : l'IA bénéficie aux profils dotés de **curiosité**, de **goût produit** et d'un goût pour l'**ownership end-to-end**. La fiche capture surtout la **discussion en commentaires** (55, dont 28 retenus) : un consensus qui **reformule** la thèse — ce ne sont pas les rôles qui disparaissent, c'est que **livrer devient bon marché**, ce qui déplace la valeur vers le jugement et la définition du bon problème — face à une minorité lucide sur le revers (responsabilité, gouvernance, IP).
#Boris Cherny#Cat Wu#Claude Code
Boris Cherny (Head of Claude Code, Anthropic) et Cat Wu (Head of Product, Claude Code, Anthropic) — vidéo ~47 s publiée par Claude for Business sur LinkedIn · repartagée par Claude. Commentateurs cités : Omer K. · Syed T. · Andrei K. van Noordt · Kristóf Nagy · Natasha Egan · Natasha Newbold · Rehan Nazir · Noman A. · Kevin Schoovaerts · Sunny Vara · Paul Breuler · Ron H. · Mohammadjavad Sayadi · Chris Bounds · Mohamed Anis · Panny Malialis · David H. · plebs.me · James Hutchinson · Dewayne J Grunden II · e.a. (28 commentaires de fond retenus sur 55).
Nicolas Martignole (Le Touilleur Express), co-écrit avec **GLM-5.2** et **MiniMax-M3**, publie **« The Token Manifesto »** : un pastiche du **Manifeste Agile** (2001) transposé à l'ère des LLM, où l'unité de valeur n'est plus l'heure d'ingénieur mais le **token**. Quatre valeurs : *short system prompts over clever system prompts*, *one clear example over three paragraphs of explanation*, *iterating in small steps over dumping the whole spec at once*, *outputting in a defined format over letting the model freestyle*. Douze principes détournent un à un ceux de l'Agile — « la simplicité, l'art de maximiser la quantité de travail **non fait par le modèle** », « des équipes auto-organisées qui repèrent la répétition et documentent une seule fois », « une réflexion régulière **avant l'arrivée de la facture mensuelle** ». Sous l'humour (« staring at a usage bar nervously »), une thèse sérieuse : la contrainte économique réelle du dev assisté par IA n'est plus la vélocité mais le **budget de tokens** et l'**économie de la fenêtre de contexte**. Deux punchlines closent le texte : **« You don't have a prompt problem. You have a context-window problem. »** et **« Everyone's a prompt engineer until they run out of monthly quota. »** À noter, le méta-clin d'œil : un manifeste sur la frugalité de tokens co-écrit *avec* des modèles.
**Boris Cherny** (Creator & Head of Claude Code @Anthropic) publie sur LinkedIn un tableau-framework, **« Steps of AI Adoption »**, qui cartographie l'adoption de l'IA agentique par une équipe d'ingénierie en **5 étapes (0→4)**, chacune caractérisée par un **ordre de grandeur d'agents pilotés** et une **transformation du rôle de l'ingénieur** : **0 Gated** (0 agent, accès verrouillé), **1 Assisted** (~1 agent — « vous + un agent », pair programming supervisé), **2 Parallel** (~10 agents — **orchestrateur**), **3 Supervised autonomy** (~100 agents — **manager de managers**, un arbre org), **4 AI-native** (~1 000+ agents — **VP qui pilote par l'intention**). Le tableau croise cinq colonnes : nombre d'agents, *à quoi ça ressemble*, *le goulet d'étranglement*, *les produits qui aident*, *les garde-fous*. **Thèse centrale** : consommer plus de tokens ne fait pas monter d'un cran — pour passer à l'étape suivante il faut **identifier et casser le prochain goulet d'étranglement** ET **bâtir le prochain jeu de garde-fous**. Concrètement : donner à Claude une **boucle d'auto-vérification** de confiance (tests + build + lint + e2e sur un vrai environnement), activer l'**Auto mode** (éviter les prompts de permission bloquants), passer **code review et security review par défaut**, adopter des interfaces multi-agents (Agent view CLI, Desktop, apps iOS/Android, Tag), puis `/loop`, `/batch`, `/goal`, **dynamic workflows** et **worktree isolation** pour subagents. Sur le pilotage : l'usage (dashboard) mesure l'**activité, pas le retour** ; la bonne question est *« aurait-on de toute façon dépensé de l'effort d'ingénierie là-dessus ? si oui, combien d'heures-ingénieur manuelles cela aurait-il coûté ? »* — voilà le ROI. Le vrai gain arrive quand **corriger et maintenir se fait en arrière-plan** et que les équipes se concentrent sur *construire*. Anthropic se situe à l'**étape 3, en route vers 4** ; Boris Cherny déclare avoir personnellement atteint le **niveau 4**.
#Boris Cherny#Claude Code#Anthropic
Boris Cherny (Creator & Head of Claude Code @Anthropic)
Prasanna Sankar (co-fondateur/CTO de Rippling, fondateur de Vorflux) publie « The Great Flattening » — un essai-manifeste affirmant que les modèles de codage sont devenus **surhumains** et que le goulot d'étranglement a basculé de la production de code vers l'**encodage du jugement** dans les *agent harnesses*. Tout ce qui est à l'intérieur de l'organisation « s'effondre vers le harness » ; le travail réel de chacun devient le *self-profiling* : extraire les frameworks de décision tacites de sa tête pour les inscrire dans la codebase. Lancement simultané de Vorflux (« autopilote pour le software engineering »), $15M seed (Y Combinator, Peak XV Partners, Alliance DAO). L'essai a attiré 60 000+ vues sur X en 24h.
#Great Flattening#Vorflux#Prasanna Sankar
Prasanna Sankar (Prasanna S, @myprasanna) — co-fondateur et ex-CTO de Rippling ($16B+ valorisation) · fondateur et CEO de Vorflux AI. Article publié sur X (format long-form article) le 14 juillet 2026 · contenu repris comme manifeste Vorflux (vorflux.com/manifesto).
Message de **Linus Torvalds** sur la mailing list **linux-media** (thread « Linking Patchwork with Sashiko? », outil LLM d'aide aux mainteneurs), où le créateur et **top-level maintainer** du noyau Linux **tranche officiellement la position du projet sur l'IA**. Répondant à Roman Gushchin qui pointait qu'un message adverse exprimait « une position très anti-LLM en général », Torvalds acquiesce (« Yes ») puis **récuse frontalement que ce soit la position du kernel** (« And no, that's not the position of the Linux kernel »). Il **pose le pied** en tant que mainteneur suprême : **« Linux n'est pas un de ces projets anti-IA »** ; ceux que cela dérange peuvent **« faire le truc open source : forker »** — « ou juste partir ». **Thèse centrale** : **« l'IA est un outil, comme les autres outils qu'on utilise, et clairement un outil utile »** ; ce n'était « peut-être pas si "clairement" il y a un an, mais ce n'est plus en question aujourd'hui ». Il distingue les questions **encore ouvertes** (« à quoi ressemblera vraiment l'économie de l'IA au final ») de la question **tranchée** (« est-ce utile ? ») — « quiconque en doute n'a clairement pas vraiment essayé ». Il **concède** que l'outil peut être **« douloureux »** — charge des mainteneurs, et le fait qu'il « n'arrête pas de trouver des bugs embarrassants » — mais refuse la posture de l'autruche (« mettre la tête dans le sable en chantant "La La La, I can't hear you" »). **La bonne réponse** : faire en sorte que **les outils LLM _aident_ les mainteneurs** plutôt que de leur causer de la peine. **Non-coercition assumée** : « on ne force personne à l'utiliser, mais **j'ignorerai très bruyamment ceux qui cherchent à empêcher d'autres de l'utiliser** ». Sur l'imperfection : « l'IA n'est pas parfaite, mais bon sang, quiconque pointe ses problèmes ferait bien de se pointer aussi lui-même dans le miroir » — « **l'intelligence naturelle n'est pas toujours si géniale non plus** ». **Cadre de gouvernance** : le projet kernel « a toujours été et restera une affaire de **technologie** » ; l'angle social de l'open source est un « bénéfice secondaire, pas le _but_ » ; **« ce n'est PAS un projet de "social warrior", ne l'a jamais été et ne le sera jamais »** ; « on fait de l'open source parce que ça produit une **meilleure technologie**, pas pour des raisons religieuses ». Conclusion-programme : **« on décide d'abord sur le mérite technique. Pas sur la peur des nouveaux outils. »** À lire comme une **prise de position doctrinale** d'une des figures les plus influentes du logiciel — écho au contre-témoignage pro-LLM d'ESR (autre pilier de l'open source, [[raymond-llm-coding-empowering-2026-07-08]]).
#Linus Torvalds#Linux#noyau Linux
Linus Torvalds ([email protected]) — ingénieur logiciel finlando-américain · **créateur et mainteneur suprême du noyau Linux** (depuis 1991) et de **Git** (2005). Employé de la **Linux Foundation**. Figure centrale et notoirement franche de l'open source · dont la parole sur les mailing lists du kernel fait autorité et jurisprudence dans la communauté. S'exprime ici en sa qualité de **top-level maintainer** pour fixer la position officielle du projet vis-à-vis des outils d'IA. Autres participants au thread cités : Roman Gushchin (linux.dev) · Laurent Pinchart · Mauro Carvalho Chehab · Konstantin Ryabitsev (Linux Foundation) · Steven Rostedt · Stephen Finucane · Jason Gunthorpe · entre autres. (Message de mailing list linux-media ; date : 2026-07-14 ; date d'ajout à la veille : 2026-07-17.)
Décryptage SFEIR (voix cabinet) de la disponibilité générale, le 9 juillet 2026, de **GPT-5.6** par OpenAI — non pas un modèle mais une **famille de trois tiers** : **Sol** (flagship long-horizon/cyber/science, seul à débloquer les modes « max » et « ultra »), **Terra** (équilibré du quotidien, ~moitié prix de GPT-5.5) et **Luna** (rapide/économique, haut volume). Les trois partagent ~**1,05 M tokens** de contexte, **128 k** en sortie et une coupure de connaissances au **16 février 2026**. Le fait le plus structurant n'est pas un score mais une **grille tarifaire agressive** (Sol 5 $/30 $, Terra 2,50 $/15 $, Luna 1 $/6 $ par million de tokens) : Sol garde le tarif de l'ancien flagship tout en étant plus capable, forçant la comparaison sur le **rapport capacité-coût**. Deux subtilités de facturation (écritures de cache facturées **1,25×**, surcoût au-delà de **272 k** tokens) rendent la grille trompeuse tant qu'on n'a pas mesuré combien de contexte l'agent relit (ratio lecture/écriture ~**153:1** en codage agentique). Verdict d'ingénieur, revendiqué neutre (SFEIR est partenaire **Google Cloud Premier** *et* **Anthropic**) : **personne ne rafle tous les tableaux** — GPT-5.6 domine Terminal-Bench 2.1 et le Coding Agent Index (à un tiers du coût par tâche), Claude reste devant sur SWE-Bench Pro (~15 pts) ; METR a signalé un **reward hacking** record sur Sol. Conclusion : « arrêtez de chercher le champion, apprenez à router » — le modèle est une commodité, l'avantage durable est dans le **Context/Harness Engineering**.
Post X d'**Eric S. Raymond** (ESR, auteur de *The Cathedral and the Bazaar*, co-fondateur de l'Open Source Initiative, ~50 ans de code) — **contre-témoignage frontal au discours « les LLMs génèrent du code pourri et hallucinent, inutiles pour programmer »**. Sa thèse : cela **ne lui arrive quasiment jamais**, et **plus du tout depuis les deux dernières générations** de modèles qu'il utilise (« chat GPT 5.4 et 5.5 » sous **codex**). L'ancien symptôme — un modèle qui « déraille » en approchant sa limite de contexte — a disparu : codex affiche désormais un **avertissement rouge** invitant à **vider la session** au lieu de partir en vrille. **Empan d'usage** : IA appliquée à des **feature changes, refactoring et debugging sur 63 projets** en **C, Go, Rust, Python et shell** ; rédaction de documentation ; **décompilation d'un binaire DOS en source lisible**. **Routine de travail** installée : quand il rouvre un projet, il lance d'abord les **tests de régression**, puis démarre codex et lui demande d'**auditer le code** (bugs + suggestions d'amélioration). Verdict : les LLMs sont **« excellents et formidablement capacitants »** ; leur **pire limite** est une **« vision en tunnel architecturale »** — excellents pour générer du code à la spécification, mais parfois **aveugles aux patterns de plus haut niveau** — ce qu'il assume comme le **job de son « meatbrain »**. Le point le plus fort, contre-intuitif : les LLMs **ne se trompent PAS sur les détails et les cas limites** ; il se dit **moins bon qu'eux** sur ce plan (malgré 50 ans d'XP) car si un changement doit **toucher cinq endroits**, le modèle **les retrouve les cinq de façon fiable**, là où l'humain en corrige quatre et **débogue des heures** avant de trouver le cinquième oublié. Il interroge alors les **« downshouters »** : vivent-ils dans un **autre univers** ? Utilisent-ils de **vieux modèles faibles** ? Y a-t-il un **skill issue** qu'il ne voit pas parce que ses **habitudes mentales et sa communication** collent bien aux « poignées » de ces outils ? Enjeu qu'il juge important à trancher, car « des **milliards de dollars seraient gaspillés en token spend mal dirigé** ». Sa recette, « très simple » : **« Be clear in your thinking, tell the model what you want with precision, and good things happen »** — chute : « what am I missing here? ». À lire comme **contrepoint pro-LLM d'une figure historique de l'open source** au débat récurrent sur la (dé)valeur des agents de codage — écho au « skill issue » et à la discipline de spécification (cf. [[martignole-token-manifesto-2026-07-17]]), et en diptyque avec la prise de position doctrinale pro-outil-IA de **Linus Torvalds** au nom du kernel Linux ([[torvalds-llm-outil-kernel-2026-07-14]]).
#Eric S. Raymond#ESR#esrtweet
Eric S. Raymond (ESR, @esrtweet sur X) — développeur · hacker et essayiste américain · **figure historique du mouvement open source**. Né le 4 décembre 1957 à Boston (Massachusetts) ; paralysie cérébrale de naissance · enfance en partie au Venezuela puis en Pennsylvanie. Auteur de l'essai très influent **« The Cathedral and the Bazaar »** (1997, livre 1999) · qui oppose le modèle « cathédrale » (développement centralisé et fermé) au modèle « bazar » (décentralisé et ouvert, à la Linux) ; il a **popularisé le terme « open source »** (contre « free software ») et contribué à convaincre **Netscape** d'ouvrir son code (naissance de Mozilla). **Co-fondateur de l'Open Source Initiative (OSI)** en 1998 · président jusqu'en 2005. A édité le **Jargon File** (*The New Hacker's Dictionary*) · maintenu des projets comme **Fetchmail** · écrit **« The Art of Unix Programming »** (2003). Se revendique **libertarien** · défenseur du port d'armes · ceinture noire de taekwondo ; commente régulièrement tech · politique et open source sur X. Se présente ici comme codeur « très · très bon » avec **~50 ans d'expérience**. (Post X personnel ; date de publication : 2026-07-08 ; date d'ajout à la veille : 2026-07-17.)
Récit technique de premier ordre par **Jarred Sumner**, créateur de **Bun** (runtime JS/TS, >22 M téléchargements/mois), sur la **réécriture complète de Bun de Zig vers Rust en 11 jours** (3→14 mai 2026) pilotée par **Claude** — une étude de cas exceptionnelle de génie logiciel assisté par IA **à l'échelle industrielle**. Motivation : une classe récurrente de bugs (use-after-free, double-free, fuites) née du mélange mémoire gérée par GC (JavaScriptCore) / mémoire manuelle (Zig) ; en **safe Rust**, ces bugs deviennent des **erreurs de compilation** avec nettoyage automatique (`Drop`/RAII) — « une meilleure boucle de feedback qu'un guide de style ». Refusant le dogme « une réécriture est toujours une mauvaise idée » (un an de gel des correctifs pour 3 ingénieurs), Sumner choisit un **portage mécanique** (préserver l'architecture, changement de comportement minimal) validé par la **suite de tests existante, écrite en TypeScript donc indépendante du langage** (60 624 tests, 1,39 M assertions `expect()`, 0 test supprimé, 6 plateformes). Le harnais : **~50 dynamic workflows** dans **Claude Code**, boucles *écrire → 2+ relecteurs adversariaux → appliquer*, jusqu'à **64 Claude en parallèle** (4 worktrees × 16), avec **PORTING.md** + **LIFETIMES.tsv** générés en préparation. Chiffres : **6 502 commits** (pic 695/h, 58/min, ~1 300 lignes/min), diff final **+1 009 272 lignes**, ~16 000 erreurs de compilation traitées comme file d'attente, **5,9 Md tokens d'entrée non cachés + 690 M en sortie ≈ 165 000 $**. Clés méthodologiques : la **revue adversariale** (un second Claude, contexte séparé, ne voit que le diff, sommé de trouver pourquoi c'est faux — capte des bugs subtils *sémantiquement* différents mais *syntaxiquement* identiques) et le principe **« corriger le processus qui génère le code, pas le code à la main »**. Modèle utilisé : pré-version de **Claude Fable 5** (classe Mythos). Depuis le merge : **11 rounds de revue de sécurité Claude Code**, fuzzing coverage-guided 24/7 (100 Md exécutions → ~15 PRs), **4 % de code `unsafe`** (78 % sur une seule ligne), **19 régressions** connues corrigées. En production : Claude Code v2.1.181, premier release sur le Bun-en-Rust, **+10 % de vitesse de démarrage sur Linux**. Disclosure assumée : **Bun a été racheté par Anthropic en décembre 2025**.
#Bun#Jarred Sumner#réécriture Zig vers Rust
Jarred Sumner (créateur de Bun ; travaille chez Anthropic depuis le rachat de Bun en décembre 2025)
Fil X (thread illustré) de **Thariq Shihipar** (équipe Claude Code / Anthropic) : un *field guide* pour tirer le meilleur de **Claude Fable 5**. Thèse centrale reprise de Korzybski — *« la carte n'est pas le territoire »* : la **carte** = ce qu'on donne à Claude (prompts, skills, contexte) ; le **territoire** = là où le travail se fait (codebase, contraintes réelles) ; l'écart entre les deux = les **unknowns** (inconnues). Fable est *« le premier modèle où la qualité du travail est plafonnée par ma capacité à clarifier ses inconnues »*. L'article fournit un **cadre à 4 quadrants** (known knowns / known unknowns / unknown knowns / unknown unknowns) et une **boîte à outils de techniques** ordonnées dans le temps (avant / pendant / après l'implémentation) — blindspot pass, brainstorms & prototypes, interviews, references, implementation plan, implementation-notes, pitches & explainers, quizzes — chacune avec des exemples de prompts. Domaine : ingénierie de prompt, agents de codage, méthodologie de travail avec l'IA, artefacts HTML.
#Unknowns#carte vs territoire#known/unknown knowns
Note courte de Simon Willison (weblog) relayant deux conseils entendus lors d'un *Fireside Chat* à l'AIE avec Cat Wu et Thariq Shihipar (équipe Claude Code) : **laisser le modèle (Fable, et dans une certaine mesure Opus) exercer son propre jugement plutôt que de lui dicter des règles** — illustré sur la décision d'écrire ou non des tests. Second conseil, de Jesse Vincent : pour **économiser les précieux tokens Fable** (avant une hausse de prix imminente), demander à Fable de **déléguer les petites tâches à des modèles moins puissants**, en le laissant juger lequel. Willison montre le prompt exact utilisé (« *use your judgement to decide an appropriate lower power model and run that in a subagent* ») et le **fichier mémoire** que Claude Code a écrit en réponse. Domaine : ingénierie de prompt, agents de codage, économie des tokens, orchestration multi-modèles.
#Jugement du modèle#délégation à des subagents#model override
Guide agent (Thinkroom, plateforme de Kieran Klaassen) documentant le **Compounding Knowledge Lifecycle** du compound-engineering-plugin (Every) : comment une leçon apprise une fois « continue de payer » — capturée, stockée, retrouvée et maintenue vraie. Décrit l'anatomie d'une *learning* (`docs/solutions/`), sa capture via `/ce-compound`, la carte mémoire (durable vs éphémère), la récupération *grep-first* (learnings-researcher) branchée sur 5 skills aux points de décision, et les trois contre-forces qui empêchent la mémoire de mentir. Directement pertinent : c'est la doctrine derrière la convention `docs/solutions/` de ce dépôt. Domaine : compound engineering, gestion de connaissance agentique, skills.
Lettre « Dear friends » d'Andrew Ng dans *The Batch* (DeepLearning.AI, n°359) sur le **loop engineering** appliqué au développement produit **0-to-1**. Ng partage ses **3 boucles clés** — boucle de codage agentique (~minutes), boucle de feedback développeur (~heures), boucle de feedback externe (~jours) — imbriquées par échelle de temps croissante, reliant *coding agent → product spec/evals → developer vision → external feedback*. Thèse centrale : les humains conservent un **avantage de contexte** (plutôt qu'un « goût ») qui rend le human-in-the-loop indispensable ; les ingénieurs endossent un rôle partiel de product management. Domaine : agents de codage, ingénierie produit, méthodologie agentique.
#Loop engineering#développement produit#boucle de codage agentique
Article de **Paul Sawers** publié sur **The New Stack** le **16 juin 2026**, sur la **suspension par Anthropic** — *« on the very day it was scheduled to go live »* — de la scission de facturation qui devait séparer l'usage de l'**Agent SDK** des limites d'abonnement Claude. **Message d'Anthropic cité** : *« We're pausing the changes to Claude Agent SDK usage described below. For now, nothing has changed. »* **L'apport de l'article n'est pas l'annonce mais le contexte qui l'entoure**, en trois cercles. **Cercle 1 — la semaine d'Anthropic** : le 9 juin, sortie de **Fable 5 et Mythos 5**, premiers modèles de classe Mythos généralement disponibles avec garde-fous cybersécurité durcis ; quelques jours plus tard, une **directive de contrôle à l'export du gouvernement américain** force Anthropic à **retirer les deux modèles pour tous ses clients dans le monde**. La suspension tarifaire est lue comme *« a little good news »* dans ce contexte. **Cercle 2 — les dégâts collatéraux du calendrier** : les entreprises qui avaient déjà répercuté le changement auprès de leurs propres clients se retrouvent en porte-à-faux ; **Conductor**, outil de codage multi-agent bâti sur l'Agent SDK, doit publier un démenti (*« Anthropic has delayed the subscription updates to Claude plans »*). **Cercle 3 — la tension de fond, qui dépasse Anthropic** : citation de **Boris Cherny** (head of Claude Code) en avril, lors d'une restriction antérieure, selon qui les abonnements *« weren't built for the usage patterns of these third-party tools »* — soit l'aveu que **forfait et usage agentique ouvert ne se marient pas** ; **GitHub** a tranché dans le même sens en retirant en juin le modèle de *premium requests* forfaitaires de Copilot au profit d'une **facturation au token**, malgré les protestations. S'ajoute, **la même semaine**, une **proposed class action** déposée devant un tribunal fédéral de Californie, alléguant que les paliers **Max** restent très en deçà des multiplicateurs d'usage annoncés lors des sessions de codage intensives. Anthropic ne dit pas quand une approche révisée arrivera, seulement qu'elle *« works to update the plan to better support how users build with Claude subscriptions »*. **Lecture finale de l'auteur** : entre la pression gouvernementale sur Fable et Mythos, un projet d'**introduction en bourse** et des **baisses de prix supposées chez OpenAI**, Anthropic cherche à **garder sa base de développeurs de son côté** — et la suspension est un moyen d'y parvenir pour l'instant.
#Anthropic#Claude Agent SDK#abonnement Claude
**Paul Sawers** — journaliste tech · signe ici pour **The New Stack**. Registre de **presse spécialisée** : l'article ne relaie pas seulement l'annonce · il la replace dans une série (les changements de facturation successifs d'Anthropic) · la compare à un précédent sectoriel (GitHub Copilot) et l'articule à trois pressions concomitantes (export control, IPO, concurrence). Sourçage explicite et attribué — le billet de Zed · l'analyse de Matthew Diakonov · le post de Conductor · une déclaration antérieure de Boris Cherny.
Fiche de **Skill** (et non d'article) : `grill-with-docs` de Matt Pocock est une technique d'interview structurée qui « cuisine » (*grill*) un plan d'architecture en le confrontant méthodiquement au vocabulaire métier du projet (glossaire `CONTEXT.md`) et aux décisions déjà documentées (ADR). Plutôt que de foncer dans l'implémentation, elle challenge les hypothèses une par une via un dialogue question/réponse, nettoie la terminologie, vérifie la cohérence avec le code réel, et capture les décisions au fil de l'eau dans les bons artefacts. Skill de conception en amont, d'inspiration Domain-Driven Design.
Chris Williams (@voodootikigod) ouvre sa série ADLC en soutenant que faire tourner le SDLC humain sur des modèles est une erreur de catégorie : le cycle classique a été conçu pour contrer des modes de défaillance humains (ego, fatigue, oubli) absents chez les LLM. Il catalogue huit modes de défaillance porteurs (F1-F8) et cinq propriétés exploitables (E1-E5), et pose le principe fondateur : chaque phase d'un cycle agentique doit se rattacher à un mode de défaillance qu'elle défend ou à une propriété qu'elle exploite.
Deuxième volet de la série ADLC de Chris Williams : il déroule le cycle qui découle de la « première loi » — huit phases (P0 Triage → P7 Distill), un gate déterministe entre chaque paire, et exactement deux moments humains obligatoires (approbation de la spec en P1, acceptation comportementale en P6). Principe clé : un handoff LLM→LLM sans checkpoint déterministe multiplie les taux d'erreur ; et une distribution des coûts « en haltère » (lourde aux deux bouts, légère au milieu) qui inverse l'économie agile.
#ADLC#cycle agentique en huit phases#gates déterministes
Troisième volet ADLC : Williams fait du test la spécification dans la seule langue que le builder ne peut pas contester. Là où le TDD est une pratique qualité optionnelle pour du code humain, il devient le mécanisme de confiance porteur de tout le cycle quand des agents codent. Trois règles de « rail discipline » : contextes d'écriture séparés (specs-only avant l'implémentation), gel mécanique au niveau de l'outil (pas du prompt), et audits adversariaux (« un test échoue-t-il si on supprime la feature ? »). Préférer le mutation testing au pourcentage de couverture, Goodhart-able à vitesse machine.
Quatrième volet ADLC : Williams reconfigure la revue de code en « prosecution » adversariale plutôt qu'évaluation collaborative. Charter les agents pour réfuter (« trouver ce qui est faux »), déployer des reviewers mono-lentille à contextes frais (correction, sécurité, conformité de contrat, alignement spec, qualité des tests), n'agir que sur des findings vérifiés (reproduits par un test rouge), et boucler jusqu'à deux passes consécutives à zéro finding. Mesurer la calibration en plantant des bugs connus, à la manière du mutation testing. Gate de sortie : zéro finding ouvert, deux passes sèches, tests verts, diff de tests vide.
Cinquième volet ADLC : orchestrer des agents en parallèle sans « merge hell ». Williams pose trois cadrans couplés — coût (choix du modèle), temps mural (largeur de parallélisation), précision (qualité des contrats) — et un principe d'architecture : « control flow is code; judgment is models » (des scripts déterministes orchestrent, les modèles ne fournissent que le jugement). Quatre lanes (Contract Desk frontier, Builder Pool single-writer, Prosecution Pool partagé, Integrator séquentiel), un forecast de conflits de merge à partir de quatre signaux (largeur certifiée typiquement 3-5 agents), et la désambiguïsation par consensus de N agents pas chers plutôt que par questions de clarification.
Sixième volet ADLC : Williams décrit la phase P7 « Distill » comme le composant qui fait baisser le coût à chaque run. Deux moitiés : la simplification post-merge (déduire après que le code existe, pas avant — « deduplicating before the code exists is speculative ») et le minage des leçons (un « lesson foundry » transforme les findings récurrents en règles de lint, skills et nouvelles questions d'interrogation). Chaque leçon est payée une fois puis rétrogradée de la détection probabiliste coûteuse vers la prévention déterministe gratuite. La bonne unité de compte est le « cost per merged, verified change », et « flat cost is failure ».
Septième et dernier volet ADLC : Williams présente un toolkit open-source de dix-huit outils construit *avec* le cycle lui-même (boucle build-prosecute-fix, agents parallèles, core `@adlc/core` gelé puis fan-out — « pinned means merged »). Le cœur doctrinal est « frontier-free » : atteindre les cibles de précision avec des modèles mid-tier (Opus/Sonnet/Haiku-class) plutôt que frontier, via cinq substitutions (search remplace insight, décomposition remplace horizon, banking remplace présence, mesure remplace métacognition, le generator-verifier gap fait tourner le moteur), l'humain restant le tier « frontier » sur les deux portes de spec. Fil rouge de la série : « replace trust with structure, and structure with measurement. »
Guide technique approfondi (blog d'agence Lushbinary) sur le **Loop Engineering** : concevoir les systèmes qui pilotent les agents de codage en boucle, plutôt que de les prompter manuellement. Couvre la filiation prompt → context → loop engineering, la technique Ralph (Geoffrey Huntley), les **cinq briques + la mémoire** d'une boucle, leur implémentation dans Claude Code et OpenAI Codex, l'écriture de conditions d'arrêt vérifiables, une échelle de maturité d'adoption et les risques qui s'aggravent à mesure que les boucles se sophistiquent. Domaine : ingénierie logicielle agentique, agents de codage, harness/orchestration.
#Loop engineering#agents de codage#harness engineering
Billet de bricolage du dimanche de **Mark Dembo** (Head of Solutions, Developer Platform & AI chez **Cloudflare**) publié le **7 juin 2026** sur son blog perso. **Récit** : inspiré par **Steve Ruiz**, l'auteur achète un petit appareil **M5Stack Stick 3** (~30 €) et, profitant de la sortie d'**Opus 4.8**, se construit un **agent IA DIY** « par pure curiosité, sans objectif ». **Itération 1 (45 min)** : il jette la doc de l'appareil à **Claude Code**, qui génère des scripts Python (~200 LOC, *« zero blast radius »*) affichant la météo de Munich, puis de plusieurs villes ; un **backend Cloudflare Workers + Workers AI** ajoute la **synthèse vocale (TTS)**, le **push-to-talk** (speech-to-text) et un **petit LLM** central pour répondre aux questions. **Itération 2 (vrai agent)** : passage des endpoints REST au transport **WebSocket** via le **Cloudflare Agents SDK** + **Dynamic Worker execution** → le pattern ***« Code Mode »*** (l'agent écrit et exécute du code pour accomplir sa tâche). L'agent répond alors à des questions à données publiques (11 ! = factorielle, vainqueur de la Ligue des Champions via `fetch()` sur Wikipédia, météo de n'importe quelle ville). **Itération 3 (vrais pouvoirs)** : connexion à **Todoist** via flux **MCP OAuth** → 50 outils d'un coup, d'où deux problèmes : **bloat du contexte** et **risque de dégâts réels**. Solution reprise du **MCP Server Portal Cloudflare** + des réglages connecteurs Claude : par outil, **Always allow / Ask for approval / Disable** (les *Disabled* n'entrent jamais dans le contexte ; un **classifieur LLM** n'accepte que les « allow » distincts et **défaut = deny**). **Posture revendiquée** : réduire son rôle à ***« idea generator, executor and judge »*** (et rarement guide technique), un flux « human-in-the-loop » jugé peu *« 2026 »* (copier-coller dans l'UIFlow). **Ce qu'il n'a PAS fait** : pas d'optimisation de latence/streaming, pas d'appels LLM optimistes, pas d'évals, ***« I did not even look at the code once »***. **Émerveillement** : 30 € + une fenêtre de session Anthropic + quelques cents d'inférence Cloudflare → un objet qui écoute et parle, piloté en langage naturel ; *« the true unlock is how accessible it is »*. Contraste vif avec [[thomas-pragdave-failing-faster-code-rot-ai-velocity-2026-06-06]] (ici le *« zero blast radius »* justifie de ne jamais regarder le code) ; illustre concrètement *Code Mode* / *« the agent just writing and executing code »*, le pattern **MCP** ([[claude-skills-bigger-than-mcp-willison-2025-10-16]]), la gouvernance d'outils façon *Ask for approval* (uber-engineering-agent-identity-crisis-zero-trust-spire-2026-05-21), et la doctrine *systems around the model* de dropbox-okumura-beyond-code-generation-engineering-productivity-ai-agents-2026-05-28.
#BYO agent#bring your own AI#bricolage
**Mark Dembo** (@darkmembo / @mdembo) · **Head of Solutions – Developer Platform & AI** chez **Cloudflare** (auparavant auteur sur le blog Cloudflare). Billet personnel publié sur son blog *markpauldembo.com* le **7 juin 2026** (description : *« Thoughts about tinkering on a Sunday »*).
Billet de **David « Pragdave » Thomas** (co-auteur de *The Pragmatic Programmer*, signataire du Manifeste Agile) publié le **6 juin 2026** sur sa newsletter Substack. **Thèse** : l'IA n'abolit pas la dégradation du code, elle l'**accélère**. En ajoutant des fonctionnalités à un petit projet personnel d'animation/graphisme avec **Claude**, l'auteur passe d'un enthousiasme initial (oklch, animations SVG livrées en une semaine) à des cycles de régression permanents en semaine deux. Formule-choc : ce que des équipes mettaient ***« 18 mois, voire plus »*** à pourrir, il l'a atteint en ***« 18 heures réparties sur cinq soirées »***. **Cause racine** : l'abandon de l'**hygiène de code** (duplication massive, solutions locales à des problèmes systémiques, sur-conditionnement, prolifération de cas particuliers). **Diagnostic comportemental** : les LLM optimisent l'engagement et la satisfaction de l'utilisateur (*« That's a great idea, Dave! »*) plutôt que la durabilité — ce sont des ***« puppy-dog junior developers, eager to please but quite messy to have around »*** (chiots juniors empressés mais brouillons) qui proposent sans cesse de nouvelles features et découragent le refactoring. **Insight central** : n'importe quel non-développeur peut réussir la *« première semaine »* de codage IA ; c'est le **jugement professionnel** — savoir s'arrêter pour refactoriser — qui sépare l'ingénieur expérimenté du novice. **Épigraphe** (Gordon Bell) : *« Every big computing disaster has come from taking too many ideas and putting them in one place. »* **Conclusion** : ***« It's still just programming »*** — le code non entretenu pourrit, que ce soit en 18 heures ou 18 mois ; tout ce qu'on a appris sur le bon code reste valable, l'effet est simplement **amplifié**. Converge avec la doctrine *« plus l'exécution est rapide, plus le cadre doit être strict »* de [[rafal-wenvision-ingenierie-logicielle-ere-ia-tout-change-rien-ne-change-2026-06-01]], le *« AI-assisted development is a trap without continuous delivery »* de [[farley-continuous-delivery-ai-assisted-development-trap-2026-05-13]], et le *« AI moves bottlenecks, it doesn't eliminate them »* de dropbox-okumura-beyond-code-generation-engineering-productivity-ai-agents-2026-05-28 ; contrepoint craftsmanship au vibe-coding de karpathy-vibe-coding-agentic-engineering-software-3-0-2026-04-29.
#hygiène de code#code rot#dégradation du code
**David Thomas** (alias **« Pragdave »**) · co-auteur avec Andy Hunt de *The Pragmatic Programmer* (1999, éd. 20e anniversaire 2019) · co-fondateur de **The Pragmatic Bookshelf** et l'un des **17 signataires du Manifeste Agile** (2001). Figure historique du *software craftsmanship*. Billet publié le **6 juin 2026** sur sa newsletter Substack *articles.pragdave.me*.
REX d'ingénierie de l'équipe **Data Science & Data Engineering d'Anthropic** (Chen Chang, Clement Peng, Justin Leder, Johanne Jiao, Josh Cherry) publié le **3 juin 2026** sur le blog Anthropic (catégorie *Enterprise AI*, focus **Claude Code**). **Résultat-phare** : ***« 95 % des requêtes d'analytics métier sont automatisées par Claude, avec ~95 % de précision en agrégat »*** (jusqu'à **~99 %** sur certains domaines). **Problème central** : l'analytics n'est **pas** du code — *« there's often only a single correct answer using a single correct source »* — il faut **mapper une question utilisateur à des entités précises et à jour** du modèle de données. Trois **modes d'échec** : (1) **ambiguïté concept↔entité** (ex. *« active users »* : quelles actions ? exclure les fraudeurs ? quelle fenêtre ?) ; (2) **obsolescence** (assets et connaissance de l'agent deviennent *« subtly wrong »*) ; (3) **échec de retrieval** (*« 80 % des requêtes échouées avaient l'info présente dans le corpus »* mais introuvable). **Solution = « agentic analytics stack » en 4 couches** : (L1) **Data foundations** — dimensional modeling, **canonical datasets** *« single source-of-truth »*, métadonnées *« as a first-class product »*, intégrité par CI/CD ; (L2) **Sources of truth** par ordre de confiance décroissant — **semantic layer** (l'agent est *« structurally required (by skill instruction) to leverage the semantic layer first »*), graphe de lineage, **query corpus** (distillé en docs structurées, **pas** du retrieval brut), business context (knowledge graph : roadmaps, decision logs, org) ; (L3) **Skills** — le levier décisif : ***« without skills … didn't exceed 21 % … Adding skills gets these numbers consistently above 95 % »*** ; structure **par paires** (*Knowledge skill* = routeur vers ~30 fichiers de référence ; *Unbook skill* = workflow de l'analyste senior : clarifier → trouver les sources → exécuter → **revue adversariale**) ; maintenance **colocalisée** (*« a code-review hook flags any reporting-model change that doesn't touch a skill file »* → **~90 % des PR data incluent un changement de skill**) ; (L4) **Validation** — evals offline (seuil ~90 % pour lancer un agent, cible ~100 %), **ablation testing** (résultat négatif notable : grep brut sur des milliers de fichiers SQL → précision bouge *« less than a point »*), online (revue adversariale : **+6 % de précision, +32 % de tokens, +72 % de latence**), **provenance footers** (tier de source + fraîcheur + ownership), **active correction harvesting** (agents planifiés scannant les canaux pour drafter des fixes markdown). **Insight stratégique** : *« documentation generated, definitions owned by humans »* — laisser le LLM **définir** les métriques fut *« net-negative »*. **Démarrage minimal** : quelques canonical datasets + quelques dizaines d'evals + un *thin knowledge skill* captent *« most of the upside »*. Converge fortement avec [[shihipar-claude-code-lessons-building-skills-2026-06-03]] (skills = dossiers, Gotchas, hooks), la doctrine *systems around the model* de [[dropbox-okumura-beyond-code-generation-engineering-productivity-ai-agents-2026-05-28]], le **semantic layer / ontology** de talisman-modern-data-101-ontology-pipeline-refresh-2026-05-04 et seale-semantic-agent-model-harness-ontology-data-2026-04-17, le *context development lifecycle* de debois-tessl-context-development-lifecycle-ai-coding-agents-2026-02-19 et l'UDA/knowledge graph de netflix-uda-unified-data-architecture-knowledge-graph-2025-06-12.
**Chen Chang · Clement Peng · Justin Leder · Johanne Jiao · Josh Cherry** — équipe **Data Science & Data Engineering d'Anthropic**. Article publié le **3 juin 2026** sur le blog Anthropic (claude.com/blog) · catégorie *Enterprise AI* · ~5 min de lecture.
Article de blog **Anthropic / claude.com** signé **Thariq Shihipar** (Member of Technical Staff, équipe Claude Code), publié le **3 juin 2026**, qui capitalise le **retour d'expérience interne** d'Anthropic sur la conception et l'usage des **Skills**. **Thèse de cadrage** : une Skill n'est pas un simple fichier markdown mais un **dossier** (instructions + scripts + ressources + config + hooks) que l'agent **découvre et manipule** ; *« You should think of the entire file system as a form of context engineering and progressive disclosure. »* L'article propose deux apports structurants. **(A) Une taxonomie de 9 catégories de skills** observées chez Anthropic : (1) **Library/API Reference** (doc de libs/CLI internes avec *gotchas* — ex. `billing-lib`, `internal-platform-cli`, `sandbox-proxy`) ; (2) **Product Verification** (test/vérif via Playwright ou tmux — `signup-flow-driver`, `checkout-verifier`, `tmux-cli-driver`) ; (3) **Data Fetching & Analysis** (accès stacks data/monitoring — `funnel-query`, `cohort-compare`, `grafana`, `datadog`) ; (4) **Business Process Automation** (workflows répétitifs — `standup-post`, `weekly-recap`, `create-<ticket>-ticket`) ; (5) **Code Scaffolding** (boilerplate framework — `new-migration`, `create-app`) ; (6) **Code Quality & Review** (`adversarial-review`, `code-style`, `testing-practices`) ; (7) **CI/CD & Deployment** (`babysit-pr`, `deploy-<service>`, `cherry-pick-prod`) ; (8) **Runbooks** (diagnostic multi-outils — `<service>-debugging`, `oncall-runner`, `log-correlator`) ; (9) **Infrastructure Operations** (maintenance avec garde-fous — `<resource>-orphans`, `cost-investigation`). **(B) Un jeu de bonnes pratiques** : ne pas redire l'évident (*« Claude already knows how to code and can read your codebase »* → cibler ce qui **contredit le comportement par défaut**) ; soigner la **section Gotchas** (*« the highest-signal content in any skill »*) ; **progressive disclosure** via l'arborescence (pointer vers des fichiers de référence selon la situation plutôt que tout charger d'emblée) ; **descriptions pensées pour le modèle** (*« the description field is not a summary, it's a description of when to trigger this skill »*) ; **setup flows** (config dans `config.json`, sinon demander via `AskUserQuestion`) ; **mémoire persistante** (logs append-only / JSON via la variable `${CLAUDE_PLUGIN_DATA}`) ; **helper scripts** (*« lets Claude spend its turns on composition… rather than reconstructing boilerplate »*) ; **hooks conditionnels** (activés seulement le temps de la skill — ex. hook de sécurité bloquant les commandes destructrices). **Distribution chez Anthropic** : skills rangées dans `./.claude/skills`, partage informel via Slack dans un dossier sandbox, puis promotion par **PR** vers le **marketplace** interne quand elles gagnent en traction ; **mesure d'usage** via un **hook `PreToolUse`** qui logue les invocations (révèle les skills populaires et celles sous-utilisées). Suite directe de la fiche [[shihipar-claude-code-html-unreasonable-effectiveness-markdown-2026-05-10]] (même auteur) et complément concret aux fiches Skills d'Anthropic/Willison/Vincent et au *harness engineering*.
#skills#Claude Code#Anthropic
**Thariq Shihipar** (Member of Technical Staff chez Anthropic, équipe **Claude Code** ; @trq212 / @trq sur X, thariqs.github.io) · pour le blog **claude.com**. Même auteur que la fiche *Using Claude Code: The Unreasonable Effectiveness of HTML* (2026-05-10). Publié le **3 juin 2026**.
Guide du média **Every** (every.to/guides) publié le **2 juin 2026**, co-signé **Mike Taylor, Laura Entis et Claude**, proposant une **échelle de maturité en 8 niveaux d'adoption de l'IA**. **Thèse-pivot** : l'adoption de l'IA **n'est pas une course à la sophistication maximale** — ***« a higher level isn't necessarily better »*** ; il faut identifier le niveau qui **correspond à son propre workflow et à son niveau de confiance**, puis réévaluer régulièrement si monter d'un cran ajoute une **valeur réelle**. ***« The best way to find value in AI is to use it in a way that fits your work. »*** **Axe structurant** : à chaque niveau, *« you delegate more of your work to—and place more trust in—the AI »* (délégation + confiance croissantes). **Les 8 niveaux** : **(1) Chatbot** — interface conversationnelle sans contexte embarqué (ChatGPT, Claude, Gemini) ; **(2) Copilot** — IA embarquée dans l'espace de travail avec accès au fichier courant (Cursor, Claude in Excel, Gemini in Docs) ; **(3) Agent** — système réactif qui exécute pas-à-pas en demandant approbation (Cowork, Codex) ; **(4) Autopilot** — on décrit l'**outcome** et l'agent exécute en autonomie, revue du **résultat final** seulement (Lovable, Codex, Claude Code ; lié au *vibe coding*) ; **(5) Workflows** — ingénieurs construisant des **harnesses** autour des agents (planning, review, confidence checks, garde-fous ; Compound engineering, Claude Workflows, Copilot AI Studio ; bascule one-shot vibe coding → **agentic engineering**) ; **(6) Assistant** — agents **proactifs, always-on** qui surveillent un domaine et remontent l'info sans sollicitation (OpenClaw, Hermes Agent, Claude Managed Agents ; ex. `heartbeat.md` toutes les 30 min) ; **(7) Multi-agent** — gestion simultanée de **plusieurs agents long-running** à rôles distincts (Claude Managed Agents, OpenClaw, Codex Goals ; *« firmly in senior engineering territory »*) ; **(8) Orchestrator** — un **agent manager** pilote une équipe de sous-agents (plan, délégation, monitoring, consolidation ; Gas Town, Paperclip, Symphony/OpenAI ; *« highly experimental »* — même les ingénieurs frontier tiennent eux-mêmes ce rôle). **Sweet spots par rôle** : les **knowledge workers** opèrent typiquement entre les niveaux **1-4**, les **ingénieurs** entre **5-8**. **Parallèle canonique de l'onboarding d'un stagiaire** : *« Expect to put in a similar amount of effort with your agents before you can trust them… at the next level of autonomy »* ; et la formule-marqueur ***« You wouldn't brag that you had eight interns working overnight on a key project, and you hadn't checked their output. »*** Le bon niveau dépend de **4 critères** : qualité de l'output, coût, fiabilité (trustworthiness), enjeu de l'échec (stakes of failure) ; et la **capacité des modèles** déplace progressivement le niveau d'autonomie « sûr ». Cadre directement mobilisable pour structurer une **doctrine d'adoption** côté cabinet. Convergence avec *systems around the model* (Dropbox/Okumura), *harness engineering* (Böckeler, Lattice, Wescale), Karpathy (vibe coding → agentic engineering), Cherny (/loop + Routines), et la doctrine *manager d'agents* (BFM/Girard).
#adoption de l'IA#échelle de maturité#huit niveaux
**Mike Taylor** · **Laura Entis** et **Claude** (co-auteurs déclarés) · pour **Every** (every.to) · rubrique *Guides*. Mike Taylor est un auteur connu sur les sujets prompt/AI (co-auteur de *Prompt Engineering for Generative AI*) ; Laura Entis est journaliste/éditrice. La co-signature explicite de **Claude** comme auteur fait partie du positionnement éditorial d'Every (entreprise AI-native). Publié le **2 juin 2026**.
Tribune d'**Olivier Rafal** (Consulting Director Strategy, **WeNvision** — groupe **SFEIR** ; ex-rédacteur en chef du *Monde Informatique*) publiée le **1er juin 2026** sur **CIO-Online**, structurée autour d'un **paradoxe** : à l'ère de l'IA, l'ingénierie logicielle **change tout… et rien ne change**. **Ce qui change = le modèle opérationnel.** Les rôles sont redéfinis : le **Product Owner** passe de la découpe de backlog à la **génération de contexte exploitable par l'IA** ; le **développeur** passe de l'écriture de code au **cadrage, à l'orientation et à la révision** de l'exécution des agents ; le **QA** gagne la possibilité de définir en amont les **preuves attendues**. La structure d'équipe bascule des *« double pizza teams »* (chaînes de hand-off à ~8 personnes) vers les ***« sandwich teams »*** : un **binôme serré expert métier + tech lead augmentés par l'IA**, les autres compétences en appui. Chiffre interne **Sfeir** : *« ce binôme pilote désormais environ 80 % de la chaîne de production »*, les ~20 % restants (architecture, gouvernance de la donnée, sécurité) étant centralisés. Citation-pivot : ***« Le sujet n'est pas un sujet d'outil, mais un sujet de modèle opérationnel. »*** **Ce qui ne change pas = la discipline du cycle.** Les phases du **SDLC** (définir → construire → vérifier → déployer → maintenir) restent identiques et non négociables ; l'IA n'en supprime aucune, elle les **intensifie** : ***« tous ces relâchements que le rythme humain absorbait tant bien que mal deviennent, à la vitesse de l'IA, des défauts industriels »*** (métaphore sport amateur vs professionnel). D'où **trois *gates* inviolables** (contrôle humain) : **spécification, planification, revue de livraison** ; validation **par la preuve** (pas par les assertions de l'IA) ; **capitalisation systématique** (chaque cycle enrichit le suivant) → résultat mesuré : **−30 % d'itérations de correction après ~10 cycles**. Principe : ***« plus l'exécution est rapide, plus le cadre doit être strict »***. Concepts mobilisés : **harnais** (règles agentiques adaptées au contexte), **vibe-coding** jugé **intenable en entreprise**. **Troisième pilier = gouvernance, FinOps & pilotage par la valeur** : coûts IA **variables et récurrents** (~**10 €/heure** par poste augmenté), bascule licence forfaitaire → facturation à l'usage (parallèle cloud 2010s) ; le **FinOps** ne vise pas à réduire les coûts mais à *« optimiser l'efficience des outils »* (coût rapporté à la valeur) ; aligner en amont les **métriques métier** (time-to-market, fonctionnalités, performance, écoconception). **Conclusion** : l'accélération rend les fondamentaux **non négociables** ; le défi est **organisationnel et culturel**, pas technologique — sans sécuriser relation métier et discipline collective, une SDLC dopée à l'IA ne fait qu'**amplifier les problèmes** (aller plus vite dans le mur). Prolonge la doctrine WeNvision de [[rafal-wenvision-ia-generative-produit-techno-pas-projet-2024-02-23]] et [[rafal-wenvision-tokenomics-foundation-finops-ia-2026-06-04]] ; converge avec *systems around the model* dropbox-okumura-beyond-code-generation-engineering-productivity-ai-agents-2026-05-28, le *harness engineering* osmani-agent-harness-engineering-2026-04-19, Salesforce agentique et le débat *manager d'agents* (BFM/Girard, SFEIR).
#ingénierie logicielle#IA#tout change rien ne change
**Olivier Rafal** · *Consulting Director Strategy* chez **WeNvision** (groupe **SFEIR**). Ancien **rédacteur en chef du *Monde Informatique*** · et auparavant consultant analyste du marché IT (~10 ans). Tribune publiée dans la rubrique *Tribune* de **CIO-Online**. Publié le **1er juin 2026**.
Billet du **Dropbox Tech blog** (rubrique *culture*), publié le **28 mai 2026** par **Kazuaki Okumura** (Dropbox, rôle non précisé dans l'article), reprenant une intervention à la conférence **DX Annual 2026** (productivité développeur). **Thèse-pivot** : la productivité d'ingénierie doit dépasser la *génération de code*. *« Accelerating code generation simply shifted some bottlenecks downstream »* — l'IA a massivement augmenté le débit de code, mais *« the faster code moves, the more pressure it puts on review queues, CI systems, validation workflows, release coordination, and production operations »*. Le vrai enjeu n'est plus d'écrire du code plus vite, mais de permettre à tout le SDLC d'**absorber, valider et livrer en sécurité** un volume bien plus grand. **De copilote à agent** : la première vague (explication de code, snippets, Q&A) opérait *« as copilots alongside the engineer »* ; l'agent, lui, *« can take a scoped task, inspect the codebase, edit files, run tests, iterate on failures, and return an artifact for human review »* — l'ingénieur restant *« accountable for intent, architecture, quality, and release decisions »* (plus de travail parallèle, plus d'options, délestage de l'exécution répétitive). **Nova** = plateforme d'agents de codage **interne** de Dropbox : décrire une tâche en langage naturel, exécution en environnement contrôlé avec le contexte du codebase. Datapoint canonique : ***« Nova's value comes less from the model itself than the systems surrounding it »*** (codebase context, internal practices, safe execution, workflow integration, human review) ; Nova représente **~1 PR sur 12 chez Dropbox** aujourd'hui (adoption en croissance), et s'étend au-delà des features : **migrations, remédiation de tests flaky, investigation de bugs, mises à jour de dépendances** (travail à forte pénibilité). **Mesurer la vélocité produit, pas l'output de code** : le *PR throughput*, signal utile quand la vélocité de codage était la contrainte, *« was no longer sufficient »*. Modèle de mesure en **4 étages** : ***Fuel*** (les outils IA sont-ils sollicités ?) → ***Adoption*** (comment les workflows changent à travers les équipes) → ***Output*** (l'IA contribue-t-elle au travail de production ?) → ***Impact*** (*« improving product velocity and reducing the time it takes to move from idea to customer value »*). Signaux qualité suivis : **code review turnaround time, first-run test pass rate, defect ratio, rework rate**. *« Quality and trust matter as much as speed »* — le cœur de la bascule : *« moving from local activity metrics toward broader system outcomes »*. **Les workflows doivent évoluer** : ce n'est *« not just a tooling shift »* mais un changement d'**operating model** — le rôle de l'ingénieur glisse vers *« defining intent, mapping problems, reviewing generated changes, and making higher-context architectural and quality decisions »*. L'**enablement** est aussi crucial que l'outil (hands-on learning, hackathons, workflow spotlights, bootcamps, peer-led examples) ; adoption à vitesses variables selon les équipes ; *« The goal is not to force every workflow through an agent »* — le rendre *« useful, safe, measurable, and repeatable where it creates meaningful leverage »*. **Ce qu'on a appris** : ***« AI doesn't eliminate bottlenecks in software development, but it does move them »*** (downstream : review, validation, testing, release, prod ops) → optimiser l'ancien goulot ne crée plus le même levier. *« The advantage will not come from access to the same foundation models everyone else can use. It will come from the systems built around those models : context, internal tooling, quality controls, and the workflows that connect them together. »* Pression aussi **en amont** (product & design) : specs structurées, design clarity, problem framing plus aiguisé. Clôture : ***« The future of engineering productivity will not be defined solely by who has the best models. It will be defined by who builds the best systems around them »*** ; *« The real challenge is no longer just generating more code, but building engineering systems that can reliably turn AI-assisted output into valuable experiences for our customers »*. Convergence directe avec **Salesforce/Tallapragada** (Effective Output : mesurer la valeur, pas le volume ; pas de tradeoff vitesse/qualité), **Gupta** (token-to-outcome attribution, cost of a completed outcome), **DORA** (au-delà du débit) et le déplacement du KPI vers le **system outcome** (idea→customer value).
**Kazuaki Okumura** — Dropbox (rôle non précisé dans l'article ; le billet reprend une intervention présentée à la conférence **DX Annual 2026** sur la productivité développeur, ce qui suggère un profil engineering leadership / platform, sans confirmation). Publié sur le **Dropbox Tech blog** (dropbox.tech) · rubrique *culture* · le **28 mai 2026**.
Billet de blog officiel **Salesforce News** (rubrique *Agentic Enterprise*, série *« Pioneering the Agentic Shift Within Salesforce Engineering »*), publié le **27 mai 2026** (6 min de lecture) par **Srinivas « Srini » Tallapragada**, *President and Chief Engineering and Customer Success Officer* de Salesforce. Suite directe d'un premier billet (*« How we got our engineers to use AI — without breaking everything »*) qui racontait le passage de **>90% d'adoption**. **Thèse-pivot** : Salesforce Engineering est passé d'un monde où l'IA était un *copilote* utile à un monde où des **outils agentiques pilotent le cycle de vie logiciel (SDLC) lui-même** — écriture de code, revue de PRs, génération de tests, mise à jour de doc, gestion des déploiements, coordination du travail jadis confié à des handoffs humains. **Décision-signal canonique** : standardisation org-wide sur **Claude Code** + ***« we removed all token limits »*** — *« remove every last piece of friction between our engineers and the tools that make them faster and more effective »*. **Résultat empirique majeur** (avril 2026 vs avril 2025) : work items complétés par développeur **+50,8%**, PRs mergées par développeur **+79%**, et surtout **Effective Output score** (mesure ML de la **valeur réelle du code livré**, pas le volume) **+151,3% en glissement annuel**. **Cas d'usage emblématique** : migration de **33 endpoints API** vers une architecture cloud-native, estimée **~231 person-days** (7 par API) en traditionnel, réalisée en **13 jours = 18× plus vite** — via un **framework rule-based en Claude** (fichiers markdown + reference implementations), feedback des PRs réinjecté en continu dans le rule set, **boucles LLM autonomes (build, fix, validate)** sans intervention manuelle, parallélisées sur environnements isolés → **5 PRs**, la plus grosse livrant **21 endpoints avec 100% de couverture de tests**. **Pas de tradeoff vitesse↔qualité** : via la plateforme **Engineering 360** (centralise les données d'ingénierie de centaines de systèmes), **les incidents totaux baissent de 5%** malgré la hausse des PRs (*« quality doesn't suffer from speed. It benefits from it »*), grâce à des **guardrails de sécurité et standards qualité encastrés structurellement** dans le workflow agentique (Trust = valeur n°1). **Refonte du SDLC** : une fois l'IA adoptée, les ingénieurs **détruisent et reconstruisent** les workflows (quels process supprimer ? quels handoffs inutiles ? où l'humain fait-il encore un travail qu'un agent peut posséder ?). **Nouveau craft d'ingénierie** : les **Claude Code skills** (capacités packagées/réutilisables encodant contexte d'équipe, conventions de nommage, patterns) deviennent un **artefact d'ingénierie** partagé et composable ; **AI Expert Suite** + **Salesforce Foundation Plugins** = bibliothèque curatée institutionnalisée de skills (benchmark interne : **précision et fiabilité en hausse, coût inutile réduit**) ; **subagents & agent teams** parallélisent les workstreams (*« They describe the outcome, and a set of coordinated agents figures out the steps »*). **Ce qui reste dur** : (1) **gestion du contexte** en sessions longues — la **qualité des fichiers CLAUDE.md** varie beaucoup et pèse fort sur la qualité de sortie ; (2) **sécurité agentique** = modèle fondamentalement différent (agents qui *agissent*, pas seulement *suggèrent* → blast radius accru) ; (3) **évolution des rôles** (comment les juniors deviennent seniors si l'IA absorbe le travail entry-level ? rôle du designer/PM ? l'unité d'exécution = scrum team → expérimentations d'unités à 1 ou 3 personnes). Conclusion : *« It changed what was economically possible »* ; ambition affichée = **« the most automated, agentic SDLC in the industry »**. Recoupe directement Gupta (*cost of a completed outcome*, marginal token utility), Greenwald/Sierra (outcome-based pricing), DORA (ROI / coût par feature) et le débat BFM/Girard (token = fuel de valeur, pas coût à couper).
#SDLC agentique#agentic SDLC#Claude Code
**Srinivas « Srini » Tallapragada** — *President and Chief Engineering and Customer Success Officer* de **Salesforce**. Plus d'une décennie chez Salesforce · dirige l'ingénierie mondiale de la plateforme unifiée. Auteur de la série *Agentic Enterprise* sur le blog Salesforce News ; ce billet (27 mai 2026) est la **suite** d'un premier opus consacré à l'adoption de l'IA par les milliers d'ingénieurs Salesforce (*« How we got our engineers to use AI — without breaking everything »*). Position d'autorité = **dirigeant exécutif** parlant en son nom et au nom d'une organisation d'ingénierie à grande échelle (donnée terrain à l'échelle d'un hyperscaler SaaS) · avec accès aux métriques internes (Engineering 360, Effective Output).
Billet du blog **Zed** signé **Franciska Dethlefsen** (head of growth and marketing), publié le **14 mai 2026** — le lendemain de l'annonce d'Anthropic — pour répondre aux questions des utilisateurs de Zed. **Objet** : à partir du **15 juin**, Anthropic **scinde la facturation de l'abonnement Claude en deux pools** — l'un pour ses **outils first-party** (chat, CLI officielle Claude Code), l'autre pour l'**usage agent et SDK tiers** (tout ce qui passe par **ACP**, `claude -p`, ou un outil tiers). L'usage via ACP **cesse alors de puiser dans les limites Pro ou Max** et bascule sur un **crédit « Agent SDK » mensuel** : **20 $ pour Pro, 100 $ pour Max 5x, 200 $ pour Max 20x**. Crédit épuisé, l'usage continue **au tarif API standard** si le dépassement est activé — sinon les requêtes s'arrêtent jusqu'au cycle suivant. **Le chiffre qui fait l'article** : les abonnements subventionnaient jusque-là l'usage agentique d'un facteur **≈ 15 à 30×** par rapport au tarif API, et les nouveaux crédits sont facturés **au plein tarif API** — d'où *« for anyone using agents heavily, this is a major cost increase »*. **Trois options proposées**, dans un ordre qui révèle la position de Zed : (1) garder son abonnement en lançant la **CLI officielle `claude` dans un terminal à l'intérieur de Zed** plutôt que via ACP — *« when the official claude CLI runs in the terminal, it uses your subscription's limits, not the new credit »* ; (2) utiliser l'agent intégré de Zed avec le fournisseur de son choix (modèles hébergés par Zed, clés API, Copilot, Ollama en local, DeepSeek) ; (3) brancher **n'importe quel agent ACP** — OpenCode, Codex, Factory, Cursor —, plusieurs offrant encore des abonnements à débit limité qui subventionnent l'usage lourd. **La thèse de fond**, et la vraie raison du billet : *« ACP is an open protocol… so that your editor is never locked into one provider's pricing decisions »*, avec l'anticipation explicite que *« this kind of change won't be the last »*. **Le billet porte un addendum daté du 16 juin 2026** annonçant que **le changement est suspendu** : ACP, `claude -p`, l'Agent SDK et les applications tierces continuent de fonctionner avec les abonnements **comme avant**, aucun crédit séparé à réclamer, limites inchangées, Anthropic révisant son plan avec préavis annoncé. **L'artefact est donc auto-contredit** : son contenu le plus important — la volte-face — postdate d'un mois sa propre date de publication.
#Zed#Anthropic#abonnement Claude
**Franciska Dethlefsen** — head of growth and marketing chez **Zed Industries**. Le rôle est déterminant pour lire le texte : ce n'est pas un billet d'ingénierie mais une **communication de crise produit** · écrite le lendemain d'une annonce d'un fournisseur dont Zed dépend · à destination d'utilisateurs inquiets. La signature growth/marketing explique la structure (problème → options → réassurance) et le fait que l'argument protocolaire arrive en conclusion plutôt qu'en tête.
Continuous Delivery comme socle non-négociable du développement assisté par IA — Dave Farley sur sa chaîne *Modern Software Engineering* défend que sans CD, l'IA n'est pas un accélérateur mais un piège (theory of constraints + paradoxe de Jevons appliqués au code généré, ATDD/BDD comme garde-fou, pipeline de déploiement comme arbitre de qualité).
#Continuous Delivery#IA générative dans le SDLC#ATDD (Acceptance Test-Driven Development)
Dave Farley (Modern Software Engineering — YouTube channel)
Article-manifeste de **Thariq Shihipar** (Engineer & serial entrepreneur, équipe Claude Code chez Anthropic) qui annonce un **changement de format de sortie par défaut pour les agents** : remplacer **Markdown par HTML**. Thèse : Markdown a été le format dominant entre humains et agents (simple, portable, éditable, lisible) mais est devenu **un goulot d'étranglement** à mesure que les agents produisent des artefacts plus longs et plus riches (specs, plans, rapports, code review). Au-delà de ~100 lignes, plus personne ne lit un fichier Markdown. HTML résout six limites simultanément : **densité d'information** (tableaux, CSS, SVG, scripts, canvas, images), **clarté visuelle** (mise en page navigable, responsive mobile), **facilité de partage** (lien S3 directement ouvrable dans un navigateur), **interactivité bidirectionnelle** (sliders, knobs, boutons "copy as JSON/prompt" pour reboucler vers Claude Code), **ingestion contextuelle native** (Claude Code lit codebase + MCP Slack/Linear + git history + Chrome) et **plaisir** (l'auteur revendique explicitement *"it's joyful"*). Cinq usages canoniques détaillés : (1) **specs/plans/exploration** en grille comparative, (2) **PR review** avec diff annoté inline, (3) **design & prototypes** avec sliders d'animation, (4) **rapports/recherche/learning** (l'auteur a fait générer un explainer prompt caching depuis l'historique git), (5) **éditeurs jetables custom** (drag-and-drop de tickets Linear, éditeurs de feature flags, prompt-tuner side-by-side) qui produisent un export "copy as markdown/diff/JSON" reréinjectable. Anti-pattern explicite : *"I'm a little bit afraid that people will read this article and turn it into a /html skill"* — l'auteur **refuse la skill-ification prématurée**, recommande de prompter from scratch ("make a HTML file"). FAQ pragmatique : coût tokens absorbé par les 1 MM context de **Opus 4.7**, génération 2-4× plus longue, diffs HTML bruyants (downside réel), style maîtrisé via design system HTML de référence.
#HTML#Markdown#format de sortie
Thariq Shihipar (Engineer & serial entrepreneur, équipe Claude Code chez Anthropic — site : thariqs.github.io/html-effectiveness ; X : @trq212)
Édito d'Andrew Ng dans The Batch n°352 du 8 mai 2026 — **"There Will Be No AI Jobpocalypse"** — qui démonte la narration de chômage de masse provoqué par l'IA en s'appuyant sur le taux de chômage US **sain à 4,3 %** et un hiring tech robuste. Ng identifie **trois moteurs** du narratif jobpocalypse : **(1) tech incentives** — les labs IA bénéficient à se présenter transformative-disruptive (lèves de fonds, valorisations, talent) ; **(2) pricing power** — les éditeurs facturent **10 000$+/an** à leurs clients enterprise en **ancrant leur tarif sur le salaire de l'employé remplacé**, plutôt que sur le pricing SaaS traditionnel (per seat / per usage) ; **(3) corporate messaging** — les boîtes recadrent leurs layoffs en *"efficience IA"* plutôt que de reconnaître l'**overhiring pandémique** 2020-2022. Reconnaissance honnête : *"AI disrupts work"*. Mais Ng renverse en **"AI jobapalooza"** (jeu de mots sur Lollapalooza) — création de jobs en AI engineering et fields adjacents avec compétences en évolution. Tension implicite avec **Amodei** (50 % white-collar jobs supprimés d'ici 2030) — Ng souligne sans nommer que **Anthropic gagne à promouvoir cette narration** (tech incentives). Publié **le même jour** que **Wallace-Wells "AI Populism" NYT Magazine** : lecture en miroir parfaite — Ng = analyse économique froide / Wallace-Wells = panique populaire. Convergence pricing power avec **Bain "100Md$ cross-system labor"** (même thèse : ancrage tarifaire sur salaires).
#Andrew Ng#The Batch#DeepLearning.AI
Andrew Ng (fondateur DeepLearning.AI, Stanford, ex-Google Brain, ex-Baidu, ex-Coursera)
Podcast Greg Isenberg × Meng To (designer, fondateur Design+Code, créateur des produits Aura / New Form / Dream Cut) sur **`design.md`** — la convention open-source de Google, équivalente à `agents.md` / `skills.md` / `soul.md` mais **pour la design system** (typographie, couleurs, spacing, WebGL/Three.js animations, règles de reveal). Idée centrale : porter "l'**âme du design**" dans un fichier markdown qui se transmet à un agent (Claude Code, Codex, OpenClaude, Gemini, Stitch, Aura, V0, Lovable, Cursor) pour préserver la **cohérence cross-medium** (web, mobile, slides Replit, motion design Hyperframes/Remotion). Triade enseignée : **HTML = plat fini, design.md = recette, skills = ingrédients** (skills typo, lasers, skeuomorphic, 3D — 63 dans New Form). Diagnostic majeur : **design drift** sur les workflows one-shot (`v0`, Lovable, Framer) qui démarrent forts puis dérivent en générique. Méta-message : la *taste* est le seul **moat** restant — *"si une chose ressemble à une autre, sa valeur baisse de 10× à 100×"*. Workflow : **Reference → Design.md → Generate → Inspect → Systemize → Iterate (jusqu'à 1000+ prompts) → Remix → Expand → Export**. Critique des **purple gradients** ("you just run") = baseline générique post-vibe-coding. Meng To revendique avoir dépensé ~500 000 $ en tokens, fait 1000–10 000 itérations par produit, gère 4 produits en parallèle en solo.
#design.md#Google#design system
Greg Isenberg (host — podcast Late Checkout / The Greg Isenberg Show, 12 mai 2026 livestream workshop ideabrowser.com) ; **Meng To** (guest — designer, fondateur Design+Code 2014, créateur Aura / New Form / Dream Cut, autodidacte parti à 18 ans, dropout, francophone d'origine canadienne)
Interview Boris Cherny (créateur Claude Code, Anthropic) lors d'un événement Sequoia (animateurs : Asia, Lauren Reader). Cherny déclare ***"coding is solved"*** : il écrit lui-même **0 ligne de code** depuis fin 2025, le modèle écrit **100%**, *"a few dozen PRs/day, 150 PRs in a single day record"*. Récit de la genèse Claude Code (Anthropic Labs incubator fin 2024, Mike Krieger en charge du round 2, build pre-PMF *"for the next model"*, première release non-décollante, **exponential growth démarré avec Opus 4 en mai 2025**, accéléré à chaque nouveau modèle 4 → 4.5 → 4.6 → 4.7). Setup personnel actuel : **"most of my work I do from my phone"** (iOS), 5-10 sessions, **"a few hundred agents going, a few thousand at night"**, **`/loop` est l'avenir** (cron + repeat jobs, agents qui babysittent CI, rebasent les PRs, clusterisent les feedbacks Twitter). **Routines** = équivalent serveur, laptop fermé. Vision SaaS : pas d'apocalypse, mais **réordonnancement du framework 7 Powers de Helmer** (switching costs ↓, process power ↓, network effects/scale economies/cornered resources inchangés) et **10× plus de startups disruptives** dans les 10 prochaines années. Analogie pivot : la **presse de Gutenberg** (10% de littéracie en 1400 → 70% en quelques siècles, livre 100× moins cher en 50 ans), *"software will be similarly democratized, but faster than 50 years"* — *"the best person to write accounting software is not an engineer, it's a really good accountant."*
#Boris Cherny#Anthropic#Claude Code
Boris Cherny (créateur de Claude Code, Anthropic) interviewé par Lauren Reader (Sequoia) avec introduction d'Asia (Sequoia).
Repo GitHub `techygarg/lattice` qui formalise un framework de **skills composables** pour installer une *engineering discipline* dans les assistants IA de code (Claude Code, Cursor). Architecture trois-tiers distinctive : **Atoms** (guardrails mono-principe : clean code, DDD, sécurité, test quality, design-first), **Molecules** (workflows multi-étapes composant les atoms : design, implement, refactor, fix, review), **Refiners** (interviews guidées produisant des standards projet-spécifiques qui customisent le comportement des atoms). Pipeline opérationnel `lattice-init` → `design-blueprint` → `code-forge` → `review`, avec `refactor-safely` et `bug-fix` en écarts. Trois principes pivots : *"Skills over prompts"*, *"Composability over monoliths"*, ***"Living context over static config"*** — le dossier `.lattice/` grossit smartement à chaque cycle de feature. MIT, shell pur, 18 stars / 52 commits, série d'articles sur martinfowler.com expliquant cinq *collaboration patterns*. Convergence forte avec Vincent *Superpowers* (2026-04-02), Habert *PROJ-AI* (2026-05-05), Wescale *Usine Logicielle Augmentée* (2026-05-03), et — convergence doctrinale la plus haute sans lignage déclaré — **Compound Engineering** d'Every (Shipper/Klaassen 2025-12-11) : pipelines isomorphes (lattice-init→design-blueprint→code-forge→review ↔ ce:brainstorm→ce:plan→ce:work→ce:review), living context layer (`.lattice/` ↔ `docs/plans/+solutions/+brainstorms/`), design-first commun, review obligatoire en sortie. La doctrine 2026 du *coding agent harness* converge sur un vocabulaire stable, sans influence directe.
#lattice#techygarg#composable AI skills
techygarg (auteur GitHub, identité réelle non précisée dans le README ; auteur d'une série d'articles publiée sur martinfowler.com).
Whitepaper Google (volet « Day 1 » d'une série, par Addy Osmani, Shubham Saboo et Sokratis Kartakis) qui cartographie la mutation du cycle de vie logiciel (SDLC) à l'ère des agents de codage. Thèse : le basculement fondamental n'est pas un nouveau langage mais le passage de l'écriture de code à l'**expression d'intention**. Le document pose un spectre allant du *vibe coding* (prompter et accepter) à l'*agentic engineering* (l'IA implémente sous contraintes, tests et boucles de feedback conçus par l'humain), avec le **context engineering** comme compétence centrale, le modèle de l'**usine logicielle** (le livrable du dev = le système qui produit le code), le **harness engineering** (Agent = Modèle + Harness) et une analyse économique CapEx/OpEx du coût total de possession.
Interview d'Andrej Karpathy (co-fondateur OpenAI, ex-Tesla Autopilot) qui passe de la *vibe coding* à l'*agentic engineering* : December 2025 comme bascule "never felt more behind as a programmer", taxonomie Software 1.0/2.0/3.0, exemple openclaw (script bash → texte à copier-coller dans l'agent) et MenuGen rendu obsolète par Nanobanana de Gemini, théorie de la *verifiability* expliquant pourquoi les LLMs sont *jagged* (math/code peakent, "marche jusqu'au lavage 50m" échoue), distinction *vibe coding* (raise the floor) vs *agentic engineering* (préserver le quality bar), métaphore "animaux vs fantômes", refonte du recrutement par projets agent-versus-agent, et formule clé : ***"You can outsource your thinking but you can't outsource your understanding."***
#Andrej Karpathy#vibe coding#agentic engineering
Andrej Karpathy (co-fondateur OpenAI, ex-Tesla Autopilot, créateur du terme "vibe coding")
Thread X manifeste de Rohit (@rohit4verse) qui pose la *2026 AI engineer roadmap* : 150k$ d'écart entre prompt engineer et systems architect, fin des *generic wrappers* "sherlocked by big tech", et 5 projets de portfolio classés par niveau de complexité (mobile SLM offline, self-improving coding agent, *Cursor for video editors* multimodal, personal life OS agent privacy-first, autonomous enterprise workflow agent). Chaque projet décrit ses *key architectural decisions* (lazy loading, sliding window, sandboxing, scene detection, knowledge graph personnel, event-driven multi-agent, audit trail, RBAC, observability). Slogan structurant : *"the replaceable: building wrappers / the unfireable: shipping autonomous systems"*. Tonalité injonctive et virale typique X 2026.
#2026 AI engineer roadmap#Rohit#rohit4verse
Rohit (@rohit4verse) — créateur de contenu IA sur X · vulgarisateur d'architecture et roadmaps de carrière en ingénierie IA.
Billet du **blog Ahrefs** publié le **28 avril 2026** par **Ryan Law** (Director of Content Marketing, Ahrefs) décrivant un système de **content engineering** maison construit autour de **Claude Code** : un pipeline éditorial qui produit des **drafts prêts à publier en 6 à 12 minutes**. **Thèse-pivot** : ***« AI content is not, by default, good. This process works well because it mirrors our existing human editorial process »*** — la qualité ne vient pas du modèle mais de la **reproduction fidèle d'un processus éditorial humain** éprouvé sur des décennies. Architecture : **~23 skill files** correspondant chacun à une étape éditoriale (keyword research, topic gap analysis, structural outlining, research compilation, draft generation, formatting), **orchestrés par un skill principal `blog-pipeline`** qui les enchaîne pour produire un article complet. **Sept principes de conception** : (1) **mimer les workflows humains** en chaînant des skills adaptés de la documentation éditoriale Ahrefs existante ; (2) **sortir chaque étape séparément** pour le troubleshooting (*« if you get an article at the end of a ten minute run, and it's bad, it's hard to diagnose precisely where and why the process went wrong »* → sauvegarder les outputs intermédiaires) ; (3) **créer des cas de test** via le skill `skill-creator` d'Anthropic pour évaluer et améliorer les guidances ; (4) **brancher des sources de données de qualité** — le **Ahrefs MCP** (keyword metrics, parent topic, long-tail themes, SERP overviews, analyse concurrentielle), l'analyse concurrentielle et la doc produit ; (5) **front-loader la direction humaine** via des paramètres de contexte permettant le guidage éditorial ; (6) **construire des previews interactives** au format HTML pour la revue avant publication ; (7) **permettre la personnalisation** (chaque membre de l'équipe peut forker et modifier le système). **Volumétrie** : ~**15 articles publiés** et ~**30 articles mis à jour** via ce workflow ; développement démarré en **février 2026** (le processus antérieur d'**août 2025** demandait plusieurs jours et de l'intervention manuelle). **Caveats explicites** (anti-survente) : *« experience matters »* — le processus reflète des décennies d'expertise éditoriale ; la sélection de sujets se concentre sur du **contenu SEO informationnel** que l'auteur maîtrise bien ; Ahrefs **n'a aucun plan de "scaler" massivement le contenu** mais maintient une **bibliothèque evergreen**. Philosophie : automatiser *« the formulaic parts of work »* pour éliminer la corvée et libérer du temps pour la recherche, le thought leadership, les webinars et l'optimisation du système — **pas** remplacer l'effort humain. Référence canonique citée par Pasquale Pillitteri (*Opus 4.8 SEO workflow*) comme preuve terrain du gain « 6-12 min/draft ». Convergence directe avec la doctrine **skills-over-prompts** (Lattice, PROJ-AI), **systems around the model** (Dropbox/Okumura), et l'usage **HTML comme artefact de revue** (Shihipar).
#content engineering#ingénierie de contenu#Claude Code
**Ryan Law** — Director of Content Marketing chez **Ahrefs**. Praticien senior du content marketing SEO ; le billet est un retour d'expérience personnel (*« How I do… »*) publié sur le **blog Ahrefs** (ahrefs.com/blog) le **28 avril 2026**.
Édito d'Andrew Ng dans The Batch n°350 qui pose une **hiérarchie d'accélération par les coding agents** selon le type de travail logiciel : **Frontend (max) > Backend (modéré) > Infrastructure (faible) > Recherche (minimal)**. Justification par la *verifiability* implicite (TypeScript/JavaScript fluents + boucle agent–navigateur autonome côté frontend) et par les zones d'ombre des LLMs (corner cases / sécurité / migrations DB pour le backend, tradeoffs réseau opaques pour l'infra, formation d'hypothèses irréductible pour la recherche). Numéro complété par 4 actualités structurantes : **GLM-5.1 (Z.ai)** modèle 754B/40B-actifs MIT capable de tâches autonomes de 8h (leader SWE-Bench Pro 58,4%) ; **Digit (Agility Robotics) chez Schaeffler** premier déploiement industriel d'humanoïdes (5'9"/143lb, 10–25$/h vs 20$/h humain) ; **révolte anti-data-centers** (~64Md$ bloqués mai-2024 / mars-2025, moratoire Maine 20MW+, cocktail molotov chez Sam Altman) ; et **"assistant axis"** (Christina Lu, MATS / Oxford / Anthropic) qui réduit la dérive de persona et les jailbreaks (Qwen3 32B : 83%→41% ; Llama 3.3 70B : 65%→33%) sans dégrader IFEval/GSM8k/MMLU-Pro/EQ-Bench.
#Andrew Ng#The Batch#DeepLearning.AI
Andrew Ng (édito principal — fondateur DeepLearning.AI, Stanford, ex-Google Brain, ex-Baidu) ; rédaction The Batch (DeepLearning.AI) pour les sections actualités
Synthèse par Addy Osmani (Google, Chrome/Cloud) du champ émergent du *harness engineering* : équation `agent = model + harness`, principe du *ratchet* ("chaque erreur devient une règle"), reframe HumanLayer "skill issue", preuves Terminal Bench (Top 30 → Top 5 par seul changement de harnais), architecture Claude Code en couches, vision Anthropic "harnesses don't shrink, they move" et Harness-as-a-Service (Claude Agent SDK, Codex SDK, OpenAI Agents SDK). Article-pivot qui consolide Trivedy, HumanLayer, Anthropic et Böckeler en doctrine.
#harness engineering#agent harness#Addy Osmani
Addy Osmani (Software Engineer at Google, Cloud + Gemini)
Update public de Darragh Curran (R&D Intercom) neuf mois après son engagement de doubler la productivité R&D en 12 mois grâce à l'IA. Résultat : **3× atteint en 16 mois, sans signe de plateau**. Données quantifiées d'une R&D de 500 personnes / 8,5M lignes de code : **93,6% des PRs sont agent-driven**, **19,2% AI-approved** (cible >50%), coût/PR **-50%**, defect backlog **-54%**, time-to-shipping **-39%**, downtime des breaking changes **-35%**, top 5% des performers à **6× le median PR throughput**, **497 PRs autonomes** dans les 4 premières semaines, **153 contributeurs / 267 skills spécialisés** dans une *Skills-Based Plugin Architecture* privée. Curran décrète ***"All technical work is becoming agent-first. This is the top priority for R&D."*** Article-pivot du dossier *agent-first organization*, comparable seulement à Stripe Minions et StrongDM dans le corpus 2026.
#Darragh Curran#Intercom#Fin Ideas
Darragh Curran (R&D leader, Intercom — publication via Fin Ideas, plateforme média Intercom).
Anthropic Interviewer - AI Workforce Study - Professional Perspectives - AI Adoption - Workplace Transformation - Creative Industries - Scientific Research - Economic Impact - Sociological Research - AI Sentiment Analysis
Anthropic Research - AI Work Transformation - Claude Code Impact - Software Engineering - AI Adoption - Productivity Study - Workplace Evolution - AI Collaboration - Skills Development - Future of Work
#Anthropic#AI Transformation#Workplace Impact
Anthropic Research Team (132 engineers and researchers surveyed, 53 in-depth interviews conducted)
Construire des agents de codage pérennes face aux cycles de modèles : architecture Harness, Codex SDK et Computer Use terminal — retour d'expérience OpenAI
#OpenAI#Codex#Coding Agents
Bill Chen (Product Manager, OpenAI) · Brian Fioca (Engineering, OpenAI)
Planification vs Vibe Coding - Compounding Engineering - Three Fidelities - AI Agents - Cora Email Bankruptcy - Plans teach systems - Every Source Code
Cat Wu et Boris Cherny (Anthropic) expliquent comment utiliser Claude Code comme ses créateurs : antfooding, plan mode, subagents, hooks et extensibilité — podcast AI & I d'Every
#Claude Code#Cat Wu#Boris Cherny
Rhea Purohit (interviewer: Dan Shipper) · Cat Wu · Boris Cherny