Glossaire

Tous les termes employés dans le programme, expliqués simplement.

Tu débutes ? Lis la première leçon. Aucun compte nécessaire.

Notions d'IA

Agent: Un système d'IA qui enchaîne plusieurs étapes tout seul pour atteindre un but, en choisissant ses tools et en s'adaptant en route.
Agent sans surveillance: Un agent qui mène une tâche du début à la fin sans personne pour le surveiller ni répondre à ses questions en route. Les gens ne voient que le résultat : ce sont donc les contrôles et l'environnement qui assurent la surveillance.
AGI: L'intelligence artificielle générale, une IA hypothétique aussi capable qu'un humain sur presque toutes les tâches. Très discutée, et pas encore là.
Closed model: Un modèle propriétaire, accessible uniquement par l'API ou l'application de son fournisseur.
Coding agent: Un assistant IA qui a des mains. Il lit des fichiers, les modifie et lance des commandes, en vérifiant les résultats au fur et à mesure.
Compaction: Résumer le début d'une conversation pour libérer de la place dans le context window.
Completion / response: Ce que le modèle renvoie après ton prompt.
Context: Tout ce que le modèle voit à l'instant où il répond : ton prompt, la conversation, les pièces jointes et les notes ajoutées en coulisse.
Context rot: Une défaillance de boucle : l'historique grossit jusqu'à noyer le signal. La parade, c'est de résumer les premiers échanges et d'épingler l'objectif.
Context window: Le maximum de tokens qu'un modèle peut tenir d'un coup, ton prompt et tout ce qu'il a déjà lu compris.
Corpus source: L'endroit où vit la vérité dans un montage RAG : les pages, les documents, les contrats ou les anciens tickets dans lesquels tu vas chercher.
Embedding: La représentation numérique d'un texte, qui permet à un système de chercher par le sens plutôt que par les mots exacts.
Embedding models: Des modèles qui transforment le texte en nombres pour que les tools puissent le chercher par le sens. Ils travaillent en coulisse dès qu'un assistant est branché à tes documents.
Fine-tuning: Un training supplémentaire et spécialisé, ajouté par-dessus un modèle de base pour coller à un usage précis.
Frontier model: Le modèle le plus gros, le plus récent et le plus capable d'un fournisseur.
Generation: La dernière étape du RAG : on glisse les passages trouvés dans le prompt et l'IA répond à partir de ce context.
Gradient descent: Le procédé de training par lequel un modèle ajuste petit à petit des milliards de paramètres internes, jusqu'à bien prédire le mot suivant.
Inference: Chaque fois que tu te sers vraiment du modèle. Tu envoies un prompt, il traverse des paramètres figés et produit un résultat.
LLM: Grand modèle de langue, la technologie derrière les assistants de chat comme ChatGPT, Gemini et Claude.
LLM augmenté: Un appel de modèle auquel on ajoute du retrieval, des tools et un memory. Anthropic en fait la brique de base de chaque pattern de workflow et des agents.
Long context: Ce qu'un assistant peut tenir dans une seule conversation. Un long context avale l'équivalent d'une petite bibliothèque d'un coup.
MCP (Model Context Protocol): Une façon standard, pour les applications d'IA, de se brancher à des tools, des données et des services extérieurs. Pense à l'USB de l'IA.
Memory: Une fonction qui retient certains faits te concernant et les remet dans le context au début des conversations suivantes.
Modèle de décision: Un modèle qui répond à une question en choisissant l'une des options que tu définis, avec une probabilité pour chacune, au lieu d'écrire du texte. Jev et Laya en sont des exemples.
Modèles d'image: Des modèles qui génèrent des images à partir d'une description écrite, comme DALL-E, Midjourney ou Stable Diffusion.
Modèles vocaux: Des modèles qui passent de la voix au texte et inversement, comme Whisper pour la transcription et ElevenLabs pour la synthèse vocale.
Multimodal: Des modèles qui gèrent autre chose que le texte, comme les images, et parfois l'audio ou la vidéo.
Open weights: Un modèle dont tu peux télécharger les paramètres pour le faire tourner toi-même.
Prédiction du mot suivant: Le principe de fond d'un LLM. Il prédit le mot suivant le plus probable, encore et encore, jusqu'à former une réponse utile.
Probabilité calibrée: Une probabilité qui correspond à la fréquence réelle des bonnes réponses : sur toutes les réponses données à environ 0,8, environ 80 % sont justes. Elle décrit des groupes de réponses, jamais une seule, et tu ne peux t'y fier qu'après l'avoir vérifiée sur ton propre travail étiqueté.
RAG (Retrieval-Augmented Generation): Le système commence par chercher dans tes documents ou sur le web, puis le modèle répond à partir de ce qu'il a trouvé.
Recherche agentique: Un agent qui trouve ce dont il a besoin pendant qu'il travaille, avec des tools de recherche, des chemins de fichiers et des liens, au lieu de recevoir des passages chargés avant de commencer. Ce qu'il lit est à jour, mais c'est plus lent que le retrieval, et il peut s'égarer sans consignes.
Session: Une conversation d'un seul tenant. Un nouveau chat démarre avec un context vide.
Subagent: Un agent à part, avec son propre context window, qui prend en charge une tâche annexe, comme une recherche ou une relecture, et ne renvoie qu'un résumé. Il ne voit pas la conversation principale : son brief doit donc redire toute règle que tu n'as donnée que dans cette conversation.
System prompt: Les instructions qui fixent le rôle et les règles de l'IA au début d'une conversation.
Token: Les petits fragments de texte qu'un assistant lit et écrit, à peu près 3/4 de mot. La longueur et le coût se comptent en tokens.
Tool: Une connexion qui permet à l'IA de faire autre chose que du texte : chercher, calculer, ou atteindre un autre système.
Training: Le processus coûteux, et unique, par lequel un modèle apprend des régularités sur des quantités énormes de texte. C'est l'affaire des fournisseurs, pas la tienne.
Training cutoff: La date après laquelle le modèle ne sait plus rien de son training. Il rate donc tout ce qui a suivi, sauf si tu le lui dis.

Prompting et techniques

Aiguillage: Un pattern de workflow où une étape range une entrée dans une catégorie et l'envoie à une étape conçue pour ce type d'entrée, par exemple les e-mails de facturation, techniques ou liés au compte.
Altitude des instructions: Le niveau de détail auquel sont écrites les consignes. Trop bas, c'est une liste fragile de règles si… alors ; trop haut, un vœu pieux. La bonne altitude énonce l'objectif, les arbitrages et les limites strictes, avec la raison de chacun.
Cadre en quatre éléments: La structure de prompt qui tient la route : rôle, context, tâche, format. On l'appelle aussi CRAFT ou RCTF.
Chain (prompt chaining): Une suite de prompts où chaque résultat devient l'entrée du suivant. Tu pilotes le chain, l'IA exécute chaque étape.
Chain of thought: Demander au modèle de raisonner pas à pas avant de répondre, ce qui améliore la justesse sur les problèmes à plusieurs étapes.
Chargement à la demande: Ne charger les schémas, les specs, les procédures ou les documents que quand une tâche les réclame, en allant les chercher par leur nom.
Chunking: Couper un corpus en passages digestes (256 à 512 tokens, avec 10 à 20 % de recouvrement) pour qu'on puisse aller les chercher.
Contraintes négatives: Dire à l'IA ce qu'il ne faut pas faire. Ça pousse contre ses réflexes, et c'est souvent plus facile que de décrire ce que tu veux.
Couche permanente: Le petit ensemble de choses lues à chaque tour : les contraintes dures, les règles de la maison et la tâche en cours.
Décomposition d'un processus: Découper un processus qui traverse plusieurs équipes en étapes, et décider lesquelles sont des étapes IA, lesquelles sont déterministes, et lesquelles demandent un humain.
Déterminisme ou jugement: Le déterminisme, c'est une étape qui rend le même résultat à chaque fois. Le jugement, c'est une étape qui peut légitimement varier. Marque chaque étape.
Empilement de rôles: Faire analyser une même chose par l'IA sous plusieurs regards d'experts, l'un après l'autre, puis lui faire synthétiser une seule recommandation.
Étape déterministe: Une étape de processus traitée par une logique fixe : une formule, un champ de base de données, ou un script.
Étape IA: Une étape de processus qui demande un jugement variant selon l'entrée. C'est là que ton budget IA est bien dépensé.
Évaluateur-optimiseur: Un pattern de workflow où un appel de modèle écrit et un autre note le résultat selon des critères clairs, en renvoyant des retours en boucle jusqu'à ce que le résultat passe ou qu'une limite soit atteinte.
Few-shot: Donner au modèle quelques exemples du passage de l'entrée au résultat que tu attends, ce qui rend ses réponses plus fiables.
Formatage du résultat: Garder les résultats intermédiaires lisibles par une machine : tableaux, JSON, champs constants. La prose libre casse les chains.
Ingénierie du context: Choisir tout ce qui arrive dans le context d'un modèle pendant qu'il travaille, pas seulement le prompt : les instructions, les fichiers, les descriptions des tools, les résultats des tools et l'historique. Le but, c'est le plus petit ensemble d'informations utiles qui mène à la bonne action.
Journal de prompts: Une collection de prompts qui ont marché, enregistrés au fil du temps et devenus des templates réutilisables pour ton propre travail.
Meta-prompting: Demander à l'IA de critiquer et de réécrire ton prompt pour qu'il donne un résultat plus fiable.
Orchestrateur-exécutants: Un pattern de workflow où un appel de modèle central découpe une tâche en sous-tâches pendant qu'il tourne, les confie à des appels exécutants et combine leurs résultats. À utiliser quand tu ne peux pas lister les sous-tâches à l'avance.
Parallélisation: Un pattern de workflow qui lance des appels de modèle en même temps : des parties indépendantes d'une tâche côte à côte (le découpage en sections), ou la même tâche plusieurs fois pour comparer les réponses (le vote).
Passage de relais (la jointure): Le moment où le résultat d'une étape devient l'entrée de la suivante. C'est là que les chains cassent le plus souvent, alors mets tes contrôles à la jointure.
Persona: Donner un rôle au modèle pour relever son niveau d'exigence. Ça change la façon dont il répond, pas le fait qu'il ait raison ou tort.
Persona prompts: Donne un rôle à chaque étape, un assistant juridique ou un responsable conformité. Le persona déplace le vocabulaire, la profondeur et le ton.
Planifier puis exécuter: Demander au modèle de planifier et de signaler les manques d'abord, puis de produire le livrable, pour qu'il ne comble pas les trous en devinant.
Préremplir la réponse: Commencer la réponse de l'IA à sa place, ce qui verrouille le format et le ton et réduit beaucoup le drift.
Prise de notes structurée: Faire écrire à un agent, pendant qu'il travaille, des notes dans un fichier hors de son context window, comme une liste de choses à faire ou un fichier de constats, puis les lui faire relire plus tard. Les notes survivent à la compaction, parce qu'elles n'ont jamais été dans le context window.
Progressive disclosure: Charger peu en permanence, et le reste seulement quand c'est pertinent. Garde la couche permanente petite.
Prompt: Ce que tu écris à un assistant. Le prompting, c'est l'art de bien demander.
Prompting en plusieurs étapes: Découper le travail en étapes au lieu d'un gros prompt unique. Chaque étape produit un résultat propre et nommé que la suivante réutilise.
Règle d'or: Donne à l'IA autant de context que possible, toujours. De meilleures entrées donnent de meilleurs résultats, à tous les coups.
Retrieval: Choisir les bons passages pour une requête donnée. La recherche hybride, sémantique plus mots-clés, doublée d'un reranker, est le standard en production.
Structured outputs: Demander un schéma précis, du JSON ou un tableau, pour que le résultat soit clair et facile à reprendre par d'autres tools.
Travail par itérations: Traiter l'IA comme une conversation et améliorer le résultat en quelques tours, au lieu d'attendre que le premier jet soit parfait.
Zero-shot: Demander une tâche au modèle sans lui donner le moindre exemple. Ça suffit pour les tâches simples et bien connues.

Construire et mettre en ligne

Agent loop: Le cycle à l'exécution : lire le context, décider, appeler un tool, lire le résultat, décider à nouveau, jusqu'à ce que la tâche soit faite.
Agentic loop: Une tâche préparée pour qu'un coding agent puisse atteindre un objectif par essais et erreurs : un objectif clair, un contrôle qui dit réussi ou échoué, les commandes pour essayer des changements, et un endroit sûr où tourner avec les validations désactivées. Tout agent fait tourner une boucle ; une boucle agentique, c'est une boucle que tu conçois.
AGENTS.md: Le fichier d'instructions standard, reconnu par tous les tools. Mets tes conventions là, comme source unique de vérité.
Anatomie d'un brief: Ce qu'un bon brief d'agent doit contenir : le rôle, le trigger, les entrées, les étapes, le format de sortie et les guardrails.
Boilerplate: Du code qu'il faut écrire mais qui ne contient aucune idée nouvelle, comme la configuration, le câblage ou une énième fois la même forme de test. Il est facile à décrire et facile à vérifier, ce qui en fait un bon travail à confier à un coding agent.
Branch: Une ligne de travail parallèle dans le même repository. Tu expérimentes sur un branch sans toucher à la ligne principale.
Breaking change: Un changement dans une nouvelle version d'une bibliothèque ou d'un service qui fait échouer, ou se comporter autrement, du code écrit pour l'ancienne version. Certains cassent bruyamment, comme une fonction supprimée. D'autres sont silencieux, comme une valeur par défaut qui change, et seuls des tests qui fixent le comportement les repèrent.
Capteur (contrôle par rétroaction): Un contrôle du harness qui vérifie le travail de l'agent après qu'il a agi, comme un test, un vérificateur de liens ou un modèle relecteur, pour que l'agent puisse se corriger.
Carte des jointures: La carte des passages de relais d'un processus : qui passe la main, qui la reprend, ce qui se perd, le temps que ça coûte, et où l'IA aurait sa place.
Cascade: Faire passer d'abord un modèle rapide et bon marché, et n'envoyer que ses cas incertains à un modèle plus puissant ou à une personne. Ça réduit le coût, mais ça n'améliore l'exactitude que si le deuxième étage fait des erreurs différentes.
Changelog: Une courte note tenue en bas d'un brief, qui liste les changements de chaque version pour que les autres voient comment il a évolué.
Changement à l'échelle du parc: Le même type de modification appliqué à de nombreux repositories, comme une mise à jour de dépendance ou de configuration, en général sous forme d'une petite pull request par repository. Ce sont toujours les contrôles et les responsables de chaque repository qui décident si sa modification est fusionnée.
Checkout: Basculer ton dossier de travail sur un branch ou un commit précis. Même repository, autre vue.
CLAUDE.md: Le fichier d'instructions de Claude Code, à la racine du projet ou dans ~/.claude pour le global. Souvent un simple renvoi vers AGENTS.md.
Code owners (CODEOWNERS): Un fichier qui indique qui est responsable de quels chemins dans un repository. Avec la règle correspondante activée, une modification d'un fichier concerné ne peut pas être fusionnée sans la validation de l'un de ses responsables.
Commit: Un changement enregistré, accompagné d'une note qui dit quoi et pourquoi. L'historique d'un repository est une chaîne de commits.
Compound engineering: Une façon de travailler, décrite par l'entreprise Every, où chaque changement doit rendre le suivant plus facile. Après planifier, réaliser et relire vient une quatrième étape : transformer ce que tu as appris en doc, en exemple, en test ou en contrôle, et te demander si le système repérerait désormais le problème tout seul.
Concurrence optimiste: Une façon pour de nombreux agents de partager un état sans verrous : tout le monde peut le lire, mais une écriture échoue si l'état a changé depuis sa lecture, et celui qui écrit relit puis réessaie.
Conflit de fusion: Ce qui arrive quand un branch modifie les mêmes lignes du même fichier qu'un autre branch. Git ne peut pas les combiner tout seul : une personne ou un agent doit choisir. Découper le travail parallèle par zone rend les conflits rares.
Context budget: Traiter le context window comme un budget que tu alloues délibérément, en mettant le plus sur ce qui change la réponse.
Contexte caché: Les system prompts, les fichiers de référence, l'historique de la conversation et les passages récupérés dépensent tous des tokens à chaque exécution.
Contre-pression: Des contrôles automatiques qui rejettent le mauvais travail d'un agent, comme les tests, les vérificateurs de types et les scanners de sécurité, pour qu'il doive corriger sa modification avant de passer à la suite. Garde-les rapides, parce que l'agent les attend.
Contrôle computationnel: Un guide ou un capteur exécuté par un logiciel ordinaire, comme un test, un linter ou un script. Il est rapide et peu coûteux, et il donne le même résultat à chaque fois.
Contrôle d'état obligatoire: Un contrôle, comme le test suite, qui doit passer avant qu'une pull request puisse être fusionnée dans un branch protégé. Il transforme les tests de simple conseil en point de contrôle.
Contrôle de revert: Retirer un correctif, lancer son nouveau test pour le voir échouer à nouveau, pour la même raison qu'avant le correctif, puis remettre le correctif. Un test qui passe encore sans le correctif ne vérifie pas le correctif, et ne repérera pas le bug s'il revient.
Contrôle inférentiel: Un guide ou un capteur qui s'appuie sur le jugement d'un modèle, comme des instructions écrites ou une relecture par l'IA. Il sait juger le sens, mais il est plus lent, coûte plus cher et peut varier d'une exécution à l'autre.
Correcteur: Ce qui décide si un essai a réussi : du code pour ce qui se vérifie exactement, un modèle avec une grille d'évaluation pour ce qui demande du jugement, ou une personne. Confronte un modèle correcteur à des personnes avant de lui faire confiance.
Coût: Le prix de chaque token, en argent, en latence et en attention diluée.
Coût par résultat utile: La dépense totale divisée par les résultats qui n'ont pas eu besoin d'être repris. La métrique de dépense à avoir dans la tête.
Couverture: Une des forces en tension dans un harness : donner au modèle assez d'informations pour agir juste. Trop peu, et il devine ou invente une API.
Critères de réussite: Les conditions qu'un travail doit remplir pour être considéré comme fini, écrites avant le début du travail. Pour un agent, chacune fonctionne mieux sous forme de contrôle qu'il peut exécuter : un test, une commande ou un résultat que tout le monde peut voir, en vérifiant d'abord que les contrôles du nouveau comportement échouent.
Défaut de conception: Une défaillance qui tient à l'architecture du workflow. Le correctif, c'est de redécouper les étapes ou de repenser l'ensemble.
Deferred tools: Lister les tools par leur nom et laisser le modèle aller chercher la définition complète quand il en a besoin, pour garder le context léger.
Définition de fini: Une courte liste d'énoncés sur le travail terminé, écrits avant que le travail commence, que n'importe qui pourrait vérifier. Chaque ligne est vraie ou fausse pour le résultat : « fini » veut donc dire contrôlé, pas seulement qui a l'air fini.
Définition de prêt: La liste, convenue par une équipe, de ce qu'un élément de travail doit contenir avant que quiconque s'y attaque. Dans une usine, elle décide quels éléments peuvent entrer dans la file des agents ; les autres retournent à leur auteur, avec la pièce manquante nommée.
Développement piloté par les spécifications: Écrire d'abord l'intention, sous forme de spécification, et faire construire un coding agent à partir d'elle. Les niveaux diffèrent par ce que devient la spécification ensuite : utilisée pour un seul changement (spec-first), gardée avec la fonctionnalité (spec-anchored), ou seul fichier que les gens modifient (spec-as-source).
Diff: La liste, ligne par ligne, de ce qui a changé dans tes fichiers : les lignes retirées et les lignes ajoutées. C'est en lisant le diff après chaque étape que tu vois exactement ce qu'un agent a fait.
DORA metrics: Cinq mesures de la livraison logicielle établies par DORA, un programme de recherche mené par Google Cloud. Le délai des changements, la fréquence de déploiement et le temps de rétablissement après un déploiement raté montrent le débit ; le taux d'échec des changements et le taux de reprise des déploiements montrent l'instabilité.
Dossier de décision d'architecture (ADR): Un court fichier du repository qui consigne une décision importante : son contexte, la décision, son statut et ses conséquences. Il explique aux personnes comme aux coding agents pourquoi le code est comme il est, pour que personne ne l'accepte ou ne le change à l'aveugle.
Edge cases: Des entrées valides mais inhabituelles. Un brief doit dire quoi faire des champs manquants, des contradictions et des données sensibles.
Élagage du harness: Retirer les pièces d'un harness une à une, en relançant les mêmes évaluations après chacune, pour ne garder que ce qui améliore encore les résultats. Chaque règle ou chaque contrôle est une hypothèse sur le modèle, et les modèles changent.
Élément de travail: Une unité de travail dans une file partagée, comme une issue dans un tracker. Quand un agent la prend, l'élément est tout son brief : le résultat visé, les contrôles qui le prouvent, ce qui est hors périmètre et à qui demander.
Ensemble de règles: Un ensemble nommé de règles posé sur un repository, comme exiger une pull request, des contrôles réussis et une validation avant toute fusion dans un branch. Les modifications des agents y sont soumises comme celles de n'importe qui.
Entrées de confiance: Des entrées déjà validées en amont, comme une ligne de base de données au schéma imposé. Tu peux agir dessus directement.
Environnement cloud: La configuration préparée d'où partent les exécutions d'un agent cloud : le code récupéré, les dépendances installées, les règles réseau et les secrets. Chaque exécution travaille dans sa propre copie, donc toutes démarrent de la même façon.
Environnement jetable: Un espace de travail créé neuf pour une tâche à partir d'une configuration standard, puis jeté ensuite, comme un worktree, un conteneur ou une sandbox cloud. Rien de ce dont tu as besoin ne vit seulement à l'intérieur, donc n'importe quelle exécution peut être relancée.
Essai: Une tentative sur une tâche, dans une évaluation. Les agents varient d'une exécution à l'autre : chaque tâche a donc droit à plusieurs essais, chacun repartant de zéro.
Étape de validation: La première étape d'un chain, celle qui vérifie que chaque champ obligatoire est là et valide. Si un contrôle échoue, elle s'arrête et appelle un humain.
Évaluation de capacité: Une évaluation faite de tâches qu'un agent a encore du mal à réussir. Elle démarre avec un taux de réussite bas et montre si les changements apportés au harness aident.
Évaluation de non-régression: Une évaluation faite de tâches qu'un agent sait déjà faire, et qui doivent réussir presque à chaque fois. Une baisse veut dire que quelque chose a cassé, souvent après un changement de modèle, d'instructions ou de tools.
Exploitable ou exact: Exploitable veut dire que les étapes suivantes savent lire le résultat. Exact veut dire que le contenu est juste. Les deux comptent.
Fan-out: Découper un changement répétitif en une exécution d'agent par élément, par exemple par fichier, lancée depuis un script avec le même prompt. Chaque exécution démarre avec un context vierge. Essaie d'abord quelques éléments, corrige le prompt, puis lance le reste avec un contrôle sur chacun.
Fichier d'instructions: Un fichier de règles permanentes qu'un agent lit avant de se mettre au travail. AGENTS.md est le nom le plus répandu.
Fichier de suivi: Un fichier qu'un agent lit au début de chaque session et met à jour à la fin : l'objectif, les règles et un journal de ce qui a été fait et de ce qui vient ensuite. Avec une liste d'éléments à côté, une nouvelle session peut reprendre un long travail sans rien refaire ni rien sauter.
Fichiers de référence: Des documents stables, réglementations, guides de style, glossaires, attachés à un assistant personnalisé pour qu'il raisonne avec eux à chaque fois.
Forking: Copier l'agent ou l'assistant partagé par quelqu'un et l'adapter, en héritant de ce que la personne qui l'a construit a appris en le faisant.
Format drift: L'IA rend un résultat dont la forme s'écarte un peu de ce qui était demandé, ce qui casse tout ce qui attendait le format exact en aval.
Formulaire d'admission: Le formulaire ou le template que les gens remplissent pour déposer un élément de travail, avec un champ pour chaque ligne de la définition de prêt et les champs importants obligatoires. Il rend les champs difficiles à sauter, pas impossibles : le tri vérifie donc à nouveau chaque élément. Sur GitHub, c'est un issue form.
Frontmatter: Un petit bloc YAML tout en haut d'un fichier, qui donne des informations sur le fichier lui-même.
Git bisect: La commande git qui trouve le commit où un bug est apparu pour la première fois. Tu marques un bon commit et un mauvais, tu lui donnes un test, et elle cherche dans l'historique en le coupant en deux à chaque fois. Les coding agents savent très bien la lancer pour toi.
Guide (contrôle par anticipation): Un contrôle du harness qui oriente l'agent avant qu'il agisse, comme des instructions, un guide de style ou un template. Il rend une bonne première tentative plus probable.
Harness: Tout ce que tu construis autour d'un modèle : le context que tu lui donnes, les tools qu'il peut appeler, et la boucle dans laquelle il tourne.
Headless run: Une exécution de coding agent lancée depuis un script, sans personne au clavier, comme claude -p ou codex exec. Les tools autorisés, la sandbox et les limites de tours et de dépense doivent tous être fixés avant le départ.
Idempotency: Un agent est idempotent si le relancer deux fois sur la même entrée ne fait courir aucun risque. Il rend le même résultat, ou il passe son tour.
Infrastructure (ou simple outil): Un projet dont beaucoup de gens dépendent. À cette échelle, il lui faut un responsable nommé, un comportement documenté, des HITL gates et un plan de maintenance.
Ingénierie agentique: Développer du logiciel avec des coding agents pendant qu'un ingénieur reste responsable du résultat : il fixe l'objectif, vérifie le code et les preuves, et décide de ce qui est mis en ligne. Simon Willison emploie le terme pour le contraire du vibe coding, où personne ne regarde le code.
Ingénierie du harness: Concevoir et améliorer tout ce qui entoure le modèle d'un agent : ses instructions, ses tools, ses contrôles et ses limites. Au sens de Mitchell Hashimoto, l'habitude de modifier le harness chaque fois que l'agent fait une erreur, pour qu'il ne la refasse plus.
Instructions spécifiques à un chemin: Des fichiers d'instructions qui ne s'appliquent que quand un agent travaille sur les fichiers correspondants, comme un fichier .instructions.md de GitHub Copilot avec un pattern applyTo, ou une règle Cursor avec des globs.
Intégration continue (CI): Le build et les tests automatiques qui tournent sur chaque modification proposée avant sa fusion. Dans une usine logicielle, c'est le premier contrôle que doit passer la modification d'un agent, et une exécution au vert ne vaut que ce que valent les tests qui sont derrière.
Jardinage de la doc: Une exécution régulière, souvent confiée à un agent, qui compare la doc d'un repository au code et ouvre une pull request pour chaque page devenue obsolète. Elle garde juste la doc sur laquelle s'appuient les agents.
Jeu d'évaluation: Un ensemble de tâches que tu peux relancer, chacune avec sa règle de réussite, pour mesurer un agent et son harness avant et après un changement. Fais-le grandir à partir de vrais échecs, et inclus des cas où quelque chose ne doit pas se produire.
Jeu de référence: Des éléments réels tirés de ton travail, chacun étiqueté avec la bonne réponse par des personnes qui connaissent le métier. C'est à lui que tu confrontes un modèle de décision avant de lui faire confiance.
Jeu de rejeu: Une liste fixe d'éléments de travail passés, chacun avec son commit de départ et le résultat qui compte comme réussi. Avant de déployer une modification, tu fais tourner le système actuel et le système modifié sur ce jeu, et tu compares élément par élément.
Jointure: Le point où l'information passe d'une personne, d'une équipe ou d'un système à un autre. Les jointures perdent du temps et de la qualité.
Limite du modèle: Une défaillance où l'IA n'est simplement pas assez fiable sur la tâche. Le correctif, c'est un contrôle déterministe ou un point de contrôle humain plus serré.
Lockfile: Un fichier qui consigne la version exacte de chaque package qu'installe un projet, y compris les packages qu'apportent ses dépendances. Ses changements dans un diff montrent tout ce qu'ajoute un nouveau package.
Merge: Réintégrer les changements d'un branch dans la ligne principale, une fois qu'ils sont prêts.
Merge queue: Une file qui teste chaque pull request avec la dernière version du branch main et les pull requests placées avant elle, avant de la fusionner, pour que des modifications qui passent chacune de leur côté ne puissent pas casser le branch ensemble.
Mise à jour de dépendance: Une modification qui fait passer l'une des dépendances d'un projet à une version plus récente. Une mise à jour qui ne change qu'un numéro de version convient à un simple script ; une mise à jour avec des changements incompatibles demande aussi des modifications du code, et un contrôle que le projet se construit toujours et passe ses tests.
Mode fantôme: Faire tourner un modèle de décision sur du vrai travail pendant que le processus en place reste aux commandes. Tu consignes les deux réponses et tu les compares plus tard ; rien de ce que dit le modèle n'est suivi d'effet.
Niveaux de maturité: Les étiquettes des workflows partagés : à tes risques et périls, recommandé (relu), et officiel (maintenu, de niveau production).
OpenTelemetry (OTel): Un standard ouvert pour envoyer les métriques, les logs et les traces d'un programme vers le collecteur de ton choix. Les tools d'agents s'en servent pour rapporter les tokens, le coût et les appels de tools de chaque exécution.
Output schema: La définition écrite et précise des champs et des types d'un résultat, posée avant d'écrire le prompt.
pass@k (au moins une fois): La part des tâches qu'un agent réussit au moins une fois en k essais. Elle montre si l'agent sait faire une tâche, pas s'il la fait à chaque fois.
pass^k (à chaque fois): La part des tâches qu'un agent réussit à chacun de ses k essais. Elle baisse quand k augmente, et elle compte surtout là où les gens attendent le même résultat à chaque fois.
Plafond de budget: Une condition d'arrêt qui pose une limite dure en tours, en tokens ou en appels de tools.
Plafond de tentatives: Une limite au nombre de fois où un agent peut réessayer après l'échec d'un contrôle, par exemple deux passages en CI. Une fois la limite atteinte, l'exécution s'arrête et le branch revient à une personne, avec la sortie en échec.
Plan de maintenance: Un court document qui nomme le responsable, un remplaçant, le rythme de relecture, les modes de défaillance connus et la façon de tester un changement.
Poids de la réponse: Les tokens de sortie coûtent en général 3 à 5 fois plus cher que ceux d'entrée, donc un modèle bavard par défaut multiplie vite la dépense.
Prêt pour la production: Un workflow testé sur de vraies entrées, avec ses modes de défaillance et ses points de contrôle humains écrits dans le brief, documenté, confié à un responsable, et suivi pour repérer le drift.
Principe d'or: Une règle tranchée et mécanique sur ce à quoi le code doit toujours ressembler, écrite dans le repository, pour qu'un agent planifié puisse trouver les écarts et ouvrir de petites pull requests pour les corriger.
Pull request: Un paquet de commits soumis à relecture avant d'être fusionné.
Pull requests empilées: Une série de petites pull requests dont chacune repose sur la précédente, pour qu'un gros travail se relise un changement autonome à la fois. Chacune doit laisser le système en état de marche une fois mergée.
Ralph loop: Une façon de faire tourner un coding agent sans surveillance : un script lui envoie encore et encore le même prompt, le même fichier de plan et les mêmes specs. Chaque itération démarre avec un context vierge, traite un élément, lance les contrôles et fait un commit.
Rebase: Rejouer les commits d'un branch par-dessus la dernière version du branch main. Faire un rebase juste avant les contrôles finaux garantit que les contrôles testent le code qui sera réellement fusionné.
Recall: À quel point le modèle applique vraiment une règle donnée. Les règles enterrées au milieu d'un long context passent à la trappe.
Red/green TDD: Le développement piloté par les tests : écrire un test, le lancer et le regarder échouer (rouge), puis changer le code jusqu'à ce qu'il passe (vert). Le voir échouer d'abord montre que le test vérifie le changement, et pas quelque chose qui marchait déjà. Avec un coding agent, demander du red/green TDD suffit en général.
Règle de la deuxième fois: Le jour où tu te vois refaire le même travail une deuxième fois, construis-le comme un agent, pour que la troisième fois il tourne tout seul.
Règle des 50 entrées: Teste un agent sur 50 vraies entrées différentes avant de le laisser tourner sans surveillance. Classe chaque défaillance.
Relecture en context vierge: Une relecture par un modèle qui reçoit le travail fini, sa définition de fini et les sources, mais pas la conversation ni le raisonnement qui l'ont produit. Il peut ouvrir des fichiers et lancer les contrôles.
Repository (repo): Un dossier de projet doté d'une mémoire. Il contient les fichiers, les tests et le journal de chaque changement, si bien que rien n'est jamais vraiment perdu.
Résultat vérifié: Un changement qui a été mergé et déployé, et qui n'a demandé ni retour en arrière, ni hotfix, ni correctif de suivi. Compter ces changements, plutôt que les pull requests ouvertes ou les lignes générées, montre ce que le travail avec des coding agents a vraiment livré.
Satisfaction (scénarios): Le score de StrongDM pour les scénarios réservés : sur toutes les exécutions de tous les scénarios, la part qui satisferait probablement l'utilisateur. Il remplace un simple réussi ou échoué quand un logiciel qui contient un modèle ne se comporte pas toujours de la même façon.
Scénario réservé: Une user story de bout en bout, stockée hors du code, qui contrôle un logiciel par ce qu'un utilisateur peut observer. Les agents ne la voient jamais : ils ne peuvent donc ni la réécrire, ni écrire du code qui ne sert qu'à la faire passer.
Scope judge: Un modèle qui ne lit qu'un élément de travail et le diff qu'un agent a produit pour lui, et qui oppose son veto aux modifications qui dépassent l'élément. Il intervient après les contrôles de build et de tests. Suis son taux de veto et vérifie à la main un échantillon de ses verdicts.
Shift left: Avancer un contrôle aussi tôt qu'il peut tourner, comme un lint à chaque push plutôt qu'en CI ou en relecture, pour qu'un échec apparaisse là où il coûte le moins cher à corriger.
Site d'appel: Un endroit du code où une fonction donnée est appelée. Avant une mise à jour ou un renommage, lister chaque site d'appel, tests et scripts compris, montre la taille du changement et ce qu'il faut vérifier.
Skill: Un paquet d'instructions et de documents de référence qui apprend à un assistant à bien faire un travail précis, réutilisable dans toutes les conversations suivantes.
SKILL.md: Le seul fichier obligatoire d'un skill : un frontmatter YAML en haut, avec le nom et la description, puis la procédure dans le corps.
Stop hook: Un hook qui s'exécute chaque fois que l'agent finit de répondre et qui peut le renvoyer au travail, par exemple tant qu'un test échoue encore. Il lui faut une clause de garde, pour qu'un contrôle qui ne peut jamais passer mette fin à l'exécution au lieu de tourner en boucle.
Symlink: Un fichier raccourci qui pointe vers un autre fichier, pour qu'un seul exemplaire réel apparaisse à plusieurs endroits.
Système de référence: Le seul endroit où un fait vit officiellement, et vers lequel pointe toute autre mention. Dans une base de code, une doc versionnée dans le repository peut être le système de référence pour l'architecture, les décisions et les règles métier.
Tableau de fiabilité: Un tableau qui regroupe les réponses d'un modèle par probabilité et montre à quelle fréquence chaque groupe avait raison. Il te dit si 0,8 veut vraiment dire environ 80 % sur tes données.
Templates à variables: Les briefs de production sont des templates à variables nommées, ce qui les rend inspectables, versionnables et duplicables.
Terminal (shell): La fenêtre de texte où tu tapes des commandes au lieu de cliquer sur des boutons. C'est là que vivent les coding agents.
Test d'objectif: Une condition d'arrêt que l'agent exécute au lieu de l'affirmer : le build passe, ou l'endpoint renvoie 200.
Test de reproduction: Un test écrit pour échouer à cause d'un bug signalé, avant que quiconque le corrige. Il doit échouer pour la raison même qui fait voir le bug aux utilisateurs, pas à cause d'une faute de frappe ou d'une configuration manquante, pour que son passage au vert montre ensuite que le correctif fonctionne.
Test manuel agentique: Faire utiliser à un coding agent son propre changement comme le ferait une personne : appeler une fonction en ligne de commande, une API avec curl ou une page dans un vrai navigateur, en gardant un journal de chaque commande et de sa sortie. Il peut trouver ce que des tests qui passent ne voient pas.
Test suite: Les autocontrôles d'un projet, lancés par une seule commande qui annonce réussi ou échoué.
Trace: L'enregistrement d'une exécution sous forme d'arbre d'étapes chronométrées appelées spans : l'exécution à la racine, et chaque appel au modèle et chaque appel de tool en dessous. Elle montre où sont passés le temps et les tokens, ce qui a échoué et pourquoi l'exécution s'est arrêtée.
Tranches de décision: Deux seuils qui répartissent les réponses d'un modèle de décision en trois issues : agir seul, faire confirmer par une personne, ou escalader vers une personne. Tu les fixes à partir de tes propres éléments étiquetés et de ce que coûte chaque erreur.
Triggers: La façon dont un agent démarre : selon un calendrier, à la demande, ou sur événement, par exemple une nouvelle ligne dans une base.
Tripwire: Dans un SDK d'agents, le signal qu'envoie un guardrail quand son contrôle échoue. L'exécution s'arrête, et ton code décide de la suite, par exemple dire à l'utilisateur que sa demande ne peut pas être traitée.
Usine logicielle: Un système où de nombreux AI agents prennent des éléments de travail dans une file et les transforment en modifications vérifiées, avec des personnes aux points de contrôle que tu choisis. L'agent n'est qu'une étape ; la file, les environnements isolés, les contrôles et les validations font que ses modifications peuvent être fusionnées sans risque.
Verifier: Un contrôle qu'un agent peut lancer mais ne maîtrise pas, comme un build ou une exécution des tests, et qui rend compte en quelques lignes. Dans une usine, les verifiers tournent avant l'ouverture d'une pull request, et un verifier en échec l'empêche de s'ouvrir.
Verrou de tâche: Une réservation posée sur un élément de travail, comme un petit fichier qu'un agent committe dans un repository partagé avant de commencer, pour que les autres agents choisissent autre chose. Des verrous gardés trop longtemps ou jamais libérés ralentissent tout le monde.
Vibe coding: Fabriquer quelque chose en décrivant ce que tu veux avec des mots simples et en laissant l'IA écrire le code, en pilotant au feeling.
Workflow: Un système où un modèle et des tools suivent des étapes que tu as fixées à l'avance. Plus simple, moins cher et plus facile à tester qu'un agent : prends-en un dès que tu connais les étapes.
Worktree: Une deuxième copie de travail du même repository, dans son propre dossier et sur son propre branch, pour que deux chantiers ne se marchent jamais sur les pieds.
YAML: Des réglages écrits en lignes étiquetées, du genre name: pdf-export. Lis-le comme un formulaire, pas comme du code.

Risques et sécurité

Actions toujours validées par un humain: Ce qui demande toujours un feu vert humain : l'argent, la santé, la sécurité, les contrats, les termes juridiques, les démarches administratives et le statut légal.
Adversarial testing: Nourrir volontairement un agent d'entrées piégeuses, contradictoires, incomplètes ou malveillantes pendant les tests, pour trouver où il casse.
Adversarial verification: Séparer la fabrication du jugement. Une passe crée, une autre attaque avec pour consigne de réfuter, et seul ce qui survit part en ligne.
AI slop: Du texte ou des images sortis à la chaîne par l'IA, sans le moindre effort. Exactement ce qu'un bon prompting évite.
Aucune avancée: Une défaillance de boucle : l'agent retente la même action qui échoue. Garde la trace de ce qui a été essayé et plafonne les tentatives.
Audit logs: Le relevé de chaque appel de tool MCP, avec l'horodatage, l'appelant, les scopes et le résultat. C'est là que tu vas voir ce que l'IA a fait.
Biais d'automatisation: La tendance à se fier, ou à trop se fier, à ce que produit un système automatisé. L'AI Act européen le nomme, et un taux de correction proche de zéro en est un signe avant-coureur.
Biais d'autopréférence: La tendance d'un agent à juger son propre travail avec trop d'indulgence quand on lui demande de le vérifier ou de le noter. La parade : un relecteur qui n'a pas fait le travail.
Blast radius: L'étendue des systèmes qu'un agent peut toucher si quelque chose tourne mal. Un agent connecté demande des points de contrôle plus serrés.
Caractères Unicode cachés: Des caractères qui n'occupent aucun espace visible, comme les liants sans chasse et les marques de texte bidirectionnel. Ils peuvent cacher dans un fichier une instruction qu'une personne qui le lit ne voit pas, mais qu'un modèle lit.
Confidence calibration: Faire noter à l'IA sa propre confiance, haute, moyenne ou basse, avec une justification, pour savoir quels résultats méritent une relecture.
Confinement: Limiter ce qu'un agent peut atteindre, quoi qu'il décide : une sandbox, un accès réseau coupé ou limité à une liste, et des identifiants hors de sa portée. Le confinement tient quand personne ne regarde, ce que les validations ne peuvent pas faire.
Contrôle imposé: Une limite que le tool applique quoi que décide le modèle, comme une règle de permission, un hook, une sandbox ou une appli non connectée. Contrairement à une instruction, le modèle ne peut pas la sauter.
Contrôle par échantillon: Prélever une part des résultats d'un workflow, 10 % par exemple, et les relire toi-même.
Deny rule: Une règle de permission qui bloque un tool, une commande ou un chemin quoi que décide le modèle, comme Read(./.env) dans Claude Code. Les deny rules sont vérifiées en premier : une allow rule ne peut donc pas y faire exception.
Drift: Quand les résultats d'un modèle se dégradent doucement parce que la forme des entrées a changé. C'est silencieux, et ça ne se voit qu'en regardant beaucoup de résultats.
Drift (loop): Une défaillance de boucle : l'agent oublie l'objectif et se met à optimiser une sous-tâche. Redonne l'objectif en fin de context.
Excès de zèle: Un agent qui fait un pas en apparence utile au-delà de ce que tu as demandé ou de ce que tu validerais, comme se servir d'un identifiant qu'il a trouvé. Limite-le avec des contrôles que le tool impose.
Exfiltration: Faire sortir des données vers quelqu'un qui ne devrait pas les avoir. Pour un agent, tout moyen de communiquer vers l'extérieur peut servir : un e-mail, un message, une requête web, et même un lien ou l'adresse d'une image.
Fatigue des validations: Ce qui arrive quand les gens voient tellement de demandes de validation qu'ils cessent de les lire. Les validations continuent, mais elles ne sont plus un contrôle. Demande moins, montre exactement ce qui va se passer, et confine le travail courant.
Faux avec aplomb: Une réponse qui a l'air sûre d'elle mais qui est fausse de façon subtile, sur le même ton que les réponses justes.
Guardrails: Les règles et les vérifications qui empêchent l'IA de faire des choses risquées.
Hallucination: Quand un assistant affirme une chose fausse avec un aplomb total. Toujours bon à vérifier.
Hallucination de package: Un package logiciel suggéré par un modèle et qui n'existe pas. N'importe qui peut enregistrer le nom inventé et y mettre du code malveillant : vérifie donc chaque nouveau package avant de le garder.
HITL gate: L'agent s'arrête et une personne relit avant qu'il agisse. Obligatoire pour les actions irréversibles ou peu sûres.
Human-in-the-loop (HITL): Une personne relit ou valide le résultat de l'IA avant toute action, surtout sur les étapes réglementées, irréversibles ou à fort impact.
Hygiène des données: Les habitudes de manipulation des informations privées avec l'IA. Laisse les données sensibles là où elles vivent au lieu de les coller dans un tool que tu ne contrôles pas.
Jailbreak: Un prompt fabriqué pour contourner les guardrails de sécurité d'une IA. N'essaie pas : ces guardrails te protègent, toi et les autres.
Lethal trifecta: Le nom que donne Simon Willison à un agent qui a accès à des données privées, voit du contenu non fiable et peut faire sortir des données. Avec les trois, un attaquant peut le piéger pour qu'il fasse fuiter les données. Retire au moins un des trois ingrédients.
Liste d'autorisation réseau: La liste des hôtes que l'exécution d'un agent peut joindre, comme ton registre de paquets. Tout le reste est bloqué, ce qui limite les endroits où un agent désorienté ou manipulé peut envoyer des données.
Mauvais arrêt: Une défaillance de boucle : l'agent s'arrête trop tôt, ou ne s'arrête jamais. La parade, c'est un test d'arrêt explicite.
Mise en pause automatique: Un disjoncteur qui arrête un agent quand l'exactitude relevée sur un échantillon passe sous un seuil fixé, jusqu'à ce qu'un humain le réactive.
Modèle du fromage suisse: Une image tirée de l'ingénierie de la sécurité : chaque couche de contrôles a des trous, mais des couches dont les trous ne sont pas au même endroit laissent passer peu d'erreurs. Aucun contrôle à lui seul n'attrape tout : empiles-en plusieurs.
Moindre privilège: Ne donner à un agent, à une personne ou à un programme que les accès dont sa tâche a besoin, et rien qui survive à la tâche. Pour un agent sans surveillance, cela veut dire un seul repository, un petit ensemble de tools et des identifiants qui expirent avec l'exécution.
Niveau de risque d'une action: Un niveau faible, moyen ou élevé attribué à une action qu'un agent peut faire, d'après quatre questions : écrit-elle, peut-on l'annuler, de qui utilise-t-elle les accès, et y a-t-il de l'argent en jeu ? Chaque niveau correspond à allow, ask ou deny.
Paresse agentique: Quand un agent s'arrête au milieu d'une longue tâche en plusieurs parties et annonce tout le travail comme fait. La parade : un contrôle que l'agent doit lancer avant de s'arrêter.
Procédure d'escalade: Le chemin prévu pour un cas signalé : qui est prévenu, comment, et avec quel contexte. Chaque point de contrôle humain a besoin du sien.
Prompt injection: Des instructions malveillantes cachées dans un contenu que l'IA va lire, pour détourner ce qu'elle fait.
Prompt injection indirect: Un prompt injection qui arrive dans un contenu que lit l'agent, comme une page web, un e-mail, un fichier partagé ou le résultat d'un tool, plutôt que dans ce que tape l'utilisateur.
Proxy d'identifiants: Un service hors de la sandbox d'un agent qui détient une vraie clé et l'ajoute aux requêtes sortantes vers les domaines autorisés. Le code à l'intérieur de la sandbox ne voit jamais qu'une valeur factice : une exécution détournée n'a donc aucune clé à voler.
Push protection: Un contrôle de GitHub qui bloque un push contenant un mot de passe, une clé ou un token avant qu'il atteigne le repository, au lieu de t'alerter après coup.
Red-teaming: De l'adversarial testing avec un objectif d'attaquant : tu attaques exprès ta propre configuration réelle, par exemple en essayant de lui faire fuiter des données, pour voir quelles défenses tiennent. Pour un agent, ça veut souvent dire glisser une instruction inoffensive dans quelque chose qu'il lit.
Règle des deux pour les agents: La règle de conception de Meta contre le prompt injection : dans une même session, un agent devrait réunir au plus deux de ces trois propriétés : une entrée non fiable, un accès à des systèmes sensibles ou à des données privées, et le pouvoir de modifier un état ou de communiquer vers l'extérieur. Avec les trois, il lui faut une personne ou un autre contrôle fiable.
Règle intangible: Ne colle jamais de coordonnées bancaires, d'identifiants, de numéros de pièce d'identité, ni rien de privé qui ne t'appartienne pas, dans un tool d'IA généraliste.
Revocation: Retirer les scopes d'une connexion MCP quand un workflow est mis hors service, pour que les connexions dormantes ne s'accumulent pas.
Reward hacking: Réussir un contrôle sans faire ce que le contrôle devait prouver, par exemple supprimer un test qui échoue ou écrire du code qui ne marche que pour l'entrée du test. Protège les contrôles contre les modifications, et garde-en quelques-uns là où l'agent ne peut pas les voir.
Scopes: Les autorisations par action qu'un serveur MCP expose, par exemple read_employees séparé de update_employee. N'accorde que le minimum.
Seuil de confiance: Un niveau en dessous duquel l'agent s'arrête et passe la main au lieu d'agir.
Slopsquatting: Enregistrer un nom de package que les modèles d'IA ont tendance à inventer, pour que du code qui suit la suggestion d'un modèle installe le package de l'attaquant. Le nom vient du typosquatting, où des attaquants enregistrent des noms de packages mal orthographiés.
Supervision: Garder un agent sous contrôle en faisant valider chaque action par une personne avant qu'elle s'exécute. Ça ne marche que tant que cette personne reste attentive et comprend ce qu'elle valide : le travail qui tourne pendant que personne ne regarde demande donc du confinement.
Test de substitution: Changer un détail qui ne devrait pas compter, comme un nom ou un lieu, et refaire passer l'élément. Si la réponse bouge plus que le bruit normal, c'est que la décision s'appuie sur ce détail.
Workspace trust: Le contrôle que fait un coding agent avant d'utiliser les propres réglages d'un dossier, comme des hooks versionnés dans un repository : il te demande si tu fais confiance au dossier. Les exécutions scriptées peuvent sauter la question et traiter le dossier comme fiable.

Tools et assistants

Agent cloud: Un coding agent qui tourne sur les machines d'un fournisseur plutôt que sur les tiennes. Tu lui confies une tâche, il travaille dans son propre environnement préparé, et il rend un branch ou une pull request qu'une personne relit.
Agent intégré à l'espace de travail: Un agent qui vit dans un tool comme Notion, et qui lit et écrit ses pages et ses bases.
AI agent: Un brief enregistré qui fait tourner un travail récurrent tout seul, selon un calendrier, à la demande ou sur événement.
Approval policy: Dans Codex, le réglage qui décide quand l'agent s'arrête pour demander avant d'aller au-delà de sa sandbox, comme on-request ou never. Le mode de sandbox fixe ce que les commandes peuvent techniquement faire.
Artifacts: Une fonction de Claude qui génère du code, des documents, des slides et des résultats interactifs dans un panneau latéral modifiable.
Assistant enregistré et réutilisable: Un assistant personnalisé que tu configures une fois et que tu réutilises, comme un Custom GPT, un Gem ou un Claude Project.
Assistant IA: Ton tool de chat indépendant : ChatGPT, Gemini, Claude ou Grok. Il réagit, tu demandes et il répond.
Assistant intégré à l'appli: De l'IA intégrée à une appli que tu utilises déjà, comme Gmail, Notion ou Word. Elle agit sur la page ouverte.
ChatGPT: L'assistant d'OpenAI, gratuit sur chatgpt.com. Un touche-à-tout fiable, avec la plus grande communauté d'utilisateurs.
Checkpoint (instantané des fichiers): Un instantané de tes fichiers qu'un tool de développement prend avant que l'agent les modifie, pour que tu puisses revenir sur ses dernières étapes. Il sert à se rattraper vite au sein d'une conversation ; certains tools ne voient pas les changements faits par des commandes shell, alors fais aussi des commits dans git.
Claude: L'assistant d'Anthropic, gratuit sur claude.ai. Fort sur l'écriture longue, l'analyse de gros documents et les raisonnements difficiles.
Claude Projects: Des espaces de travail Claude qui durent, avec des documents de référence dont Claude se souvient dans toutes les conversations.
Co-pilot: De l'IA qui travaille à côté de toi dans un tool, en suggérant au fil de l'eau pendant que tu gardes la main.
Connectors: Les liens qui permettent à Claude de se brancher à des tools comme Drive, Gmail, Slack, GitHub et Linear, avec ton autorisation.
Custom GPTs: Les assistants enregistrés et réutilisables de ChatGPT, que tu configures une fois et que tu réutilises ensuite.
Deep Research: Un mode qui mène une enquête étendue sur de nombreuses sources, pendant plusieurs minutes, et rend un rapport écrit et sourcé.
Gemini: L'assistant de Google, gratuit sur gemini.google.com. Le plus fort quand l'entrée est volumineuse, mélangée ou visuelle, et il tourne dans Google Workspace.
Gems: Les assistants personnalisés enregistrés et réutilisables de Gemini, que tu configures une fois et que tu réutilises ensuite.
Grok: L'assistant de xAI, gratuit sur grok.com. Branché sur X et sur le web en direct, le plus fort sur l'actualité.
Instructions du projet: Des instructions permanentes que tu fixes une fois dans un projet ChatGPT ou Claude. Chaque chat du projet les reçoit, avec les fichiers du projet, mais ce sont toujours des demandes que le modèle peut sauter.
Permission mode: Un réglage de coding agent qui décide quelles actions s'exécutent sans te demander d'abord, de la simple lecture jusqu'à tout. Les règles de permission s'ajoutent par-dessus, et une deny rule bloque quand même dans tous les modes.
Plan mode: Un mode de coding agent dans lequel l'agent lit le code et propose un plan, mais ne change rien tant que tu ne l'as pas validé. Il sépare le fait de décider quoi faire du fait de le faire.
Plateforme d'automatisation: Un tool sans code, Zapier ou Make, qui recopie des données d'une appli à l'autre selon un calendrier.
Plugin: Un paquet qui installe d'un coup plusieurs pièces d'une configuration d'agent, comme des skills, des hooks et des connexions à des serveurs. Un plugin peut exécuter du code avec tes propres permissions : lis ce qu'il contient avant de l'installer.
Relecture de code par l'IA: La relecture d'une pull request ou d'un diff par un modèle d'IA. Ses remarques sont des pistes à vérifier dans le code, pas des validations, et elle ne remplace ni les tests ni la relecture d'une personne.

Travailler avec l'IA

AI-pilled: Conquis par l'IA. Dès que ça marche sur une tâche, tu te mets à y penser pour tout le reste. Ça se dit avec un clin d'œil.
Aisance avec l'IA: La capacité de travailler avec l'IA, de construire dessus et de penser à ses côtés. La compétence la plus rentable de la décennie.
Atrophie des compétences: Perdre une compétence que tu ne pratiques plus parce qu'un tool fait le travail. Avec les coding agents, le débogage est la principale inquiétude : dans un essai, c'est là que l'écart était le plus grand, et c'est la compétence qu'il te faut pour vérifier ce qu'un agent te rend.
Cinq niveaux d'autonomie: Le modèle de Dan Shapiro sur la part du code qu'une équipe confie à l'IA, du niveau 0, où une personne écrit chaque ligne, au niveau 5, l'usine dans le noir. C'est le modèle d'une seule personne, utile comme vocabulaire commun, et une même équipe peut se situer à plusieurs niveaux à la fois.
Désormais, n'importe qui peut créer: Quiconque construit un workflow avec l'IA est un créateur, quel que soit son intitulé de poste.
Dette de compréhension: L'écart qui se creuse entre la quantité de code qu'une équipe a mise en ligne et la part que quelqu'un dans l'équipe comprend. Elle s'accumule sans bruit tant que les tests restent au vert, et se voit quand quelque chose casse. On parle aussi de dette cognitive.
État d'esprit 100x: Le nouveau rythme : les mois deviennent des jours, les jours des heures. Quand le coût est divisé par cent, des choses nouvelles deviennent possibles.
Exemple de référence: Le morceau de code existant que tu désignes comme l'exemple à suivre pour un pattern, comme un nouvel endpoint ou un test. Les coding agents copient ce qu'ils trouvent : désigner le meilleur exemple oriente ce qu'ils copient.
Le travail doit disparaître: L'état d'esprit qui veut que l'IA efface des catégories entières de travail, en supprimant carrément des tâches.
Limite de travail en cours: Un plafond sur le nombre de tâches commencées et pas encore mergées. Pour des coding agents en parallèle, fixe-le selon le nombre de changements que tu peux relire et intégrer, pas selon le nombre d'agents que tu peux lancer, et relis ce qui attend avant d'en lancer d'autres.
Lisibilité pour l'agent: Le fait que le savoir dont un agent a besoin se trouve à un endroit qu'il peut ouvrir pendant qu'il tourne. Une décision qui ne vit que dans une réunion, un fil de chat ou la tête de quelqu'un est illisible : pour l'agent, elle n'existe pas.
Loi de Goodhart: Le constat qu'un chiffre cesse d'être une bonne mesure dès que les gens sont récompensés pour lui. Fixe comme objectif le nombre de pull requests ouvertes, et tu obtiens plus de pull requests, qu'elles vaillent quelque chose ou non.
Note de passation: Une courte note qui permet à une nouvelle session de reprendre une tâche : l'objectif dans ses termes d'origine, les règles qui doivent tenir, ce qui est fait et comment ça a été vérifié, ce qui vient ensuite et ce qui n'a pas marché.
Paradoxe de la supervision: Le problème suivant : superviser un AI agent demande justement les compétences que le fait de s'y fier peut affaiblir. L'étude d'Anthropic sur ses propres ingénieurs emploie le terme pour le code : vérifier le code d'un agent demande les compétences de programmation que tu pratiques moins dès qu'il écrit le code à ta place.
Réapprendre à apprendre: La méta-compétence qui consiste à continuer d'apprendre à mesure que les anciennes expertises s'automatisent. Le nouveau rempart.
Recoupement: Passe la même question importante dans deux tools et compare. S'ils sont d'accord, ta confiance monte. S'ils divergent, tu as mis le doigt sur quelque chose à creuser.
Réflexe IA d'abord: Passer 30 secondes, sur chaque nouvelle tâche, à se demander comment l'IA pourrait aider, avant de la faire à la main.
Règle des 80 %: Commence par ton assistant IA, pour tout. Le tool intégré à l'appli est un raccourci bien pratique dont tu peux te passer.
Tri: Répartir le travail entrant pour que chaque élément aille au bon endroit. Dans une usine, chaque élément va à un agent, à une personne ou retourne à son auteur, et chaque décision consigne une raison et un niveau de confiance.
Usine dans le noir: Le niveau le plus élevé des cinq niveaux d'autonomie de Dan Shapiro : les specs entrent, le logiciel sort, et personne n'écrit ni ne relit le code. Le nom vient des usines entièrement tenues par des robots, où personne ne travaille.