Parcours · LLM & Agents
LLM & architecture agentique
219 leçons : L'IA au travail, 10 leçons sans code pour tous les métiers, une introduction (mindset, AGENTS.md, hooks, skills), un parcours technique (tokens, RAG, fine-tuning, agents), puis Build With AI, 97 leçons pour développer avec l'IA (skills, MCP, boucles d'agent, automatisation, évaluations, sécurité), tout inclus dès l'offre Essentiel.
- leçons
- 219
- sans code
- 10
- Build With AI
- 97
Ce parcours compte pour plusieurs certifications
Toutes les certifications- Build With AI (Fondamentaux)30 leçons
- Build With AI (Avancé)34 leçons
- Build With AI (Expert)33 leçons
- IA au travail (Fondamentaux)10 leçons
- IA au travail (Avancé)32 leçons
Chaque niveau demande des leçons de plusieurs parcours, puis un examen final corrigé sur nos serveurs. Le diagnostic et le plan de révision sont ouverts sans abonnement.
Certification Central Campus : ni diplôme d'État, ni certification professionnelle enregistrée au répertoire national.
Sans code, pour tous les métiers
L'IA au travail, sans code
Pour tous les métiers, sans une ligne de code : ce que fait un assistant d'IA, rédiger une demande, vérifier une réponse, protéger les données, rédaction, synthèse, tableur, usage en équipe et cadre européen.
1 module · 10 leçons
L'IA au travail, sans code
Dix leçons pour utiliser un assistant d'IA dans son métier : comprendre ce qu'il fait, rédiger, vérifier, protéger les données, cas concrets et cadre européen.
10 leçons
Ce que fait un assistant d'IA, et ce qu'il ne fait pas
Un texte prédit mot après mot, une fenêtre de lecture limitée, des réglages, et trois façons de s'en servir : conversation, recherche dans vos documents, agent.
Ouvrir la leçonLimites : inventions, connaissances datées et biais
Pourquoi un assistant invente des faits, ignore l'actualité ou reproduit des stéréotypes, et comment repérer les demandes qui augmentent ces risques.
Voir les offresRédiger une demande claire, puis l'améliorer
Rôle, contexte, consigne, format et contraintes : une demande se rédige comme une commande précise, puis s'améliore en disant exactement ce qui ne va pas.
Voir les offresVérifier une réponse avant de s'en servir
Sources primaires, citations, chiffres recalculés, causes non étayées : une méthode pour décider quoi vérifier, et comment, quand on ne peut pas tout vérifier.
Voir les offresDonnées confidentielles : ce qu'on ne colle pas
Données personnelles, secrets d'affaires, identifiants : ce qui ne va que dans un outil validé, ce qu'on anonymise vraiment, et les documents piégés qui contiennent des consignes cachées.
Voir les offresCas métier : rédiger et reformuler
Courriels, courriers, réponse à un usager mécontent, traduction : ce qu'il faut fournir à l'assistant, et ce qu'on relit toujours avant d'envoyer.
Voir les offresCas métier : synthèse de documents et réunions
Résumer un rapport pour un public précis, comparer des offres, préparer une réunion et en tirer un compte rendu : décisions, actions, responsables, échéances.
Voir les offresCas métier : tableur et chiffres
Préparer un tableau pour l'assistant, obtenir une formule expliquée, la tester sur un cas connu, et relire un graphique avant de le diffuser.
Voir les offresUsage responsable en équipe
Une charte d'une page : outils autorisés, données interdites, relecture, transparence, droits d'auteur, décisions qui restent humaines, et que faire en cas d'erreur.
Voir les offresCe que dit le cadre européen, dans les grandes lignes
Le règlement européen sur l'IA classe les usages par niveau de risque ; le RGPD continue de s'appliquer aux données personnelles. Ce que cela change pour un utilisateur au travail.
Voir les offresPour bien démarrer
Introduction & usage
Mindset, pratique agentique (AGENTS.md, hooks, skills) et choix de modèles.
10 modules · 67 leçons
Réinventer l'usage des LLMs
Passer du copier-coller à l'orchestration : cadrer une demande, vérifier la réponse, itérer, et structurer un prompt avec exemples, balises et format de sortie.
5 leçons
Orchestrer, pas copier-coller
Ce qu'un assistant d'IA fait vraiment, et la posture qui en tire parti : cadrer le problème, relire, tester, comprendre ce qu'on rend.
Voir les offresVérifier ce que l'IA produit
Toute réponse d'IA est une hypothèse : faire expliciter les suppositions, tester sur un petit jeu de données connu, et savoir quoi vérifier en priorité.
Voir les offresStructurer le contexte
Rôle, objectif, contexte, contraintes, format : un prompt se rédige comme un cahier des charges, avec ce que l'IA ne peut pas deviner.
Voir les offresItérer comme un ingénieur
Premier jet, écart nommé, correction ciblée, synthèse : améliorer une réponse en disant précisément ce qui ne va pas, et savoir quand repartir de zéro.
Voir les offresExemples, balises et format de sortie
Montrer plutôt que décrire : exemples bien choisis, balises qui séparent consignes et données, format de sortie explicite, et rôle du prompt système face au message.
Voir les offresPratique : cartographier l'espace agent
Chat, plan et agent, couches d'instructions, consultatif ou déterministe, fichiers du dépôt, fenêtre de contexte et coût : les repères avant d'écrire un AGENTS.md.
6 leçons
Chat, Plan ou Agent
Choisir le mode selon la tâche : comprendre (chat), décider (plan) ou exécuter (agent), et savoir quand reprendre la main.
Voir les offresLes quatre couches d'instructions
Instructions personnelles, AGENTS.md, règles de projet, skills : qui les lit, quand elles sont chargées, et comment éviter les contradictions.
Voir les offresConsultatif ou déterministe
Le modèle peut ignorer un fichier markdown ; une permission, un hook ou un bac à sable s'appliquent sans lui demander son avis.
Voir les offresLa carte des fichiers agentiques
Où vivent AGENTS.md, CLAUDE.md, règles, hooks, skills, fichiers ignorés et réglages, et ce qui se versionne ou non.
Voir les offresCe que l'agent voit vraiment
Instructions, fichiers mentionnés, sorties d'outils, historique, compaction : la fenêtre de contexte se gère comme un budget.
Voir les offresCoût, jetons et choix du modèle
Relier gamme de modèle, effort de raisonnement et volume de contexte au coût d'une session, avec un calcul sur tarifs fictifs.
Voir les offresPratique : AGENTS.md & CLAUDE.md
Écrire le socle d'instructions du dépôt : court par budget d'équipe, fait de renvois, partagé entre outils, sans recopier le linter ni les secrets.
8 leçons
À quoi sert AGENTS.md
Le fichier d'instructions partagé par les agents de code : ce qu'il contient, ce qu'il ne contient pas, et comment Claude Code le lit.
Voir les offresÉcrire court : un budget d'équipe
Pourquoi la longueur d'AGENTS.md se gère comme un budget : texte relu à chaque tour, attention diluée, consignes noyées.
Voir les offresLes sections utiles
Outils, commandes ciblées, pièges du dépôt, interdits : le squelette d'un AGENTS.md qui sert à chaque tâche.
Voir les offresPointer, ne pas copier
AGENTS.md renvoie vers la documentation, les fichiers exemples et les skills : il ne devient pas un wiki qui vieillit.
Voir les offresMonorepo : des AGENTS.md imbriqués
La racine porte le commun, chaque paquet ses commandes et ses pièges : l'enfant précise le parent, il ne le recopie pas.
Voir les offresCLAUDE.md et AGENTS.md
Importer le socle avec @AGENTS.md, garder CLAUDE.md minuscule, mettre les permissions dans settings.json.
Voir les offresLes anti-patterns d'AGENTS.md
Roman de 400 lignes, secrets, rôle théâtral, liste de cinquante interdits : reconnaître les erreurs et leur trouver la bonne place.
Voir les offresAtelier : l'AGENTS.md d'un mini-projet
Rédiger le fichier complet de Réserva, avec CLAUDE.md et la liste des mécanismes à brancher : un livrable prêt à versionner.
Voir les offresPratique : rules Cursor
Règles personnelles, de projet et d'équipe, en-tête .mdc et équivalent Claude Code, règles par domaine, .cursorignore et ses limites, conflits : des règles chargées au bon moment.
6 leçons
Règles personnelles ou règles de projet
Ce qui voyage avec votre compte, ce qui se clone avec le dépôt, et ce que l'équipe impose : le test du clone.
Voir les offresL'en-tête des règles Cursor
alwaysApply, globs et description : les quatre types de règles .mdc, et l'équivalent paths de Claude Code.
Voir les offresDes règles par domaine
Découper par zone du code : authentification, Prisma, routes, textes d'interface ; une règle, un périmètre, des chemins réels.
Voir les offres.cursorignore : ce que l'agent ne voit pas
Exclure secrets, données et artefacts, connaître les exclusions par défaut et la limite du terminal : l'absence vaut mieux qu'un « jamais ».
Voir les offresConflits de règles
Deux règles toujours appliquées qui se contredisent, globs trop larges, règle personnelle oubliée : diagnostiquer et réparer.
Voir les offresAtelier : trois règles pour Réserva
Livrer prisma.mdc, routes-api.mdc et interdits.mdc complets, versionnables tels quels, et les signaler dans AGENTS.md.
Voir les offresPratique : hooks
Les garde-fous déterministes de l'agent : événements Cursor et Claude Code, contrat JSON, git, secrets, formatage, fin de tour et politique d'échec.
10 leçons
Pourquoi un hook
Quand une consigne markdown ne suffit plus : un petit programme branché sur le cycle de vie de l'agent, qui autorise, refuse ou relance, quoi qu'en pense le modèle.
Voir les offresLes événements de hook dans Cursor
beforeShellExecution, beforeReadFile, beforeSubmitPrompt, beforeMCPExecution, afterFileEdit, stop, sessionStart : à chaque besoin son événement, et ce que chacun peut bloquer.
Voir les offresLes événements de hook dans Claude Code
PreToolUse par outil, PostToolUse, UserPromptSubmit, Stop qui relance l'agent, SessionStart, PreCompact, SubagentStop : la carte Claude Code et sa correspondance avec Cursor.
Voir les offresLe contrat d'un hook : entrée, sortie, code de retour
JSON sur l'entrée standard, un seul objet JSON sur la sortie standard, journal sur l'erreur standard, et un code de retour qui compte : le protocole commun aux deux outils.
Voir les offresEncadrer git
Lecture seule autorisée, commit et push soumis à confirmation, réécriture d'historique refusée : la politique git de Réserva et son matcher.
Voir les offresProtéger les secrets
Refuser la lecture de .env, arrêter une clé collée dans le prompt, et savoir qu'un secret envoyé se révoque : trois couches et un réflexe.
Voir les offresFormater après chaque modification
afterFileEdit ou PostToolUse : formater le seul fichier modifié, vite, sans bloquer, avec la configuration de l'équipe.
Voir les offresLe hook de fin de tour
Avant que l'agent annonce « terminé » : le relancer une seule fois avec une vérification ciblée, des fichiers nommés et la question du hors-périmètre.
Voir les offresFail-closed ou fail-open
Si le hook plante, dépasse son délai ou renvoie n'importe quoi, l'action passe-t-elle ? Par défaut, oui : savoir le changer là où c'est nécessaire.
Voir les offresAtelier : un garde git pour deux outils
Livrer un script garde-git partagé, son branchement Cursor et Claude Code, le filet de permissions et une série de tests reproductibles.
Voir les offresPratique : skills
Expertise à la demande : ranger une consigne, anatomie d'un SKILL.md, chargement progressif, emplacements, audit et atelier d'écriture.
7 leçons
Skill, règle ou AGENTS.md
Ranger chaque consigne au bon endroit : toujours vraie (AGENTS.md), vraie pour certains fichiers (règle ciblée), procédure d'une tâche (skill) ou demande ponctuelle (prompt).
Voir les offresAnatomie d'un SKILL.md
En-tête YAML (name et description obligatoires), corps en procédure numérotée, pièges connus, et dossiers scripts, references et assets lus à la demande.
Voir les offresQuand l'agent charge un skill
Chargement en trois temps (description, corps, ressources), descriptions qui se chevauchent, et disable-model-invocation pour les skills à déclencher à la main.
Voir les offresSkills du projet, personnels ou installés
Où l'outil découvre les skills (dépôt, dossier personnel, plugins), lequel l'emporte en cas de doublon, ce qui se versionne et ce qui s'audite.
Voir les offresSkill tuteur : corriger sans donner la solution
Encoder une posture de tuteur dans un skill : diagnostic, règle en jeu, indice gradué, jamais la requête corrigée par défaut.
Voir les offresAuditer un skill dangereux
Les signaux d'alerte d'un SKILL.md ou de ses scripts : consignes qui contournent vos règles, git, réseau, secrets, exécution distante.
Voir les offresAtelier : le skill « ajouter un champ Prisma »
Écrire de bout en bout un skill de projet : description, procédure testable, pièges réels (migration, client généré, données existantes) et vérification.
Voir les offresPratique : MCP, CLI et permissions
Outils, ressources et prompts MCP, liste d'hôtes autorisés, permissions deny / ask / allow, bac à sable, commande comme preuve, politique d'exécution.
6 leçons
MCP : outils, ressources et prompts
Les trois primitives d'un serveur MCP, qui les déclenche, les deux transports (stdio et Streamable HTTP) et où ranger la configuration et les secrets.
Voir les offresListe d'hôtes autorisés pour la sortie réseau
Pourquoi un agent ne doit joindre que des domaines nommés, comment le configurer, et pourquoi un outil HTTP générique est un trou.
Voir les offresPermissions : refuser, demander, autoriser
Les règles deny, ask et allow de Claude Code, leur ordre d'évaluation, leur syntaxe et leurs limites ; l'équivalent dans Cursor.
Voir les offresBac à sable du shell
Ce que le système d'exploitation bloque encore après les permissions : écritures hors du projet, réseau, et les réglages de Claude Code et de Cursor.
Voir les offresLa commande comme preuve
Lint, types, tests, build : l'agent n'a pas fini tant qu'il n'a pas exécuté la vérification adaptée et montré son résultat.
Voir les offresAtelier : la politique d'exécution d'un projet
Assembler permissions, bac à sable et hooks en une matrice cohérente d'une page, puis la tester par trois essais.
Voir les offresPratique : conduire une session
Brief, mode plan, contexte ciblé, sous-agents, dérive du périmètre, revue de diff et commit humain : le métier de celui qui pilote l'agent.
8 leçons
Le brief de tâche
Transformer une envie (« améliore la liste ») en ticket exécutable : objectif, hors périmètre, fichiers, contraintes, critère de fin et vérification.
Voir les offresLe mode plan
Faire proposer l'approche (étapes, fichiers, risques) sans rien modifier, la valider en partie ou la refuser, puis seulement passer à l'exécution.
Voir les offresUn contexte ciblé
Donner à l'agent les trois bons fichiers plutôt que tout le dépôt : la cible, un exemple à imiter, le contrat ; compléter par une recherche ciblée.
Voir les offresSous-agents : explorer sans encombrer
Confier une exploration large à un sous-agent qui rend un rapport court, garder un seul agent qui modifie, et ne paralléliser que sur des zones disjointes.
Voir les offresBoucles et dérive du périmètre
Arrêter l'agent après deux échecs identiques, repérer les modifications hors brief même « utiles », et revenir au mode question ou plan au lieu d'insister.
Voir les offresLa revue de diff
Relire le diff réel par ordre de risque (données, sécurité, logique, textes, style), repérer les contournements et refuser un diff trop gros.
Voir les offresGit : l'humain signe
L'agent prépare le diff et propose un message ; l'humain relit, committe et pousse. Ce qui est interdit à l'agent, et pourquoi les points de restauration ne remplacent pas git.
Voir les offresAtelier : une session de bout en bout
Enchaîner brief, plan, contexte ciblé, exécution, vérification de fin, revue du diff et commit humain sur une tâche de Réserva, avec un incident de dérive à traiter.
Voir les offresPratique : équipe, sécurité, production
Injection de consigne par le dépôt, ce qu'on versionne, accueil d'un nouveau développeur, tâches étalons, agents asynchrones et charte d'une page.
6 leçons
L'injection de consigne par le dépôt
README, ticket collé, commentaire ou skill tiers : l'agent lit un texte hostile comme une consigne. Repérer les vecteurs et casser la combinaison dangereuse par des mécanismes.
Voir les offresCe qu'on versionne, ce qu'on garde pour soi
Instructions, règles, hooks, skills et réglages d'équipe dans git ; secrets, réglages personnels et historiques de conversation hors de git.
Voir les offresAccueillir un nouveau développeur
Un clone doit suffire à cadrer l'agent : installation humaine d'un côté, garde-fous de l'agent de l'autre, et trois tests le premier jour.
Voir les offresÉvaluer son agent avec des tâches étalons
Cinq tâches étalons rejouées après chaque changement de configuration : réussir le métier, échouer aux interdits, mesurer sur plusieurs essais.
Voir les offresAgents asynchrones et agents dans le cloud
Quand l'agent travaille sans vous (mode non interactif, agent cloud, revue automatique de PR), la configuration versionnée et la revue de la PR remplacent votre doigt sur le bouton.
Voir les offresCharte d'une page pour une équipe de développement
Une page qui fixe l'autonomie de l'agent, les interdits, les rôles (qui relit, qui fusionne, qui modifie les skills) et les fichiers qui font foi, sans recopier ces fichiers.
Voir les offresCartographie des modèles IA
Choisir un modèle ou un outil par critères : rapide, équilibré ou de raisonnement, entrées acceptées, hébergement, intégration et coût par tâche.
5 leçons
Panorama : choisir un modèle par critères
Familles rapides, équilibrées ou de raisonnement, entrées acceptées, hébergement, modèles ouverts et coût par tâche : une grille qui survit aux nouvelles versions.
Voir les offresQuand choisir Claude, et comment le cadrer
Les gammes Claude (Haiku, Sonnet, Opus, Fable), la réflexion réglable et l'agent Claude Code : quand ce choix se justifie, et le prompt système qui l'encadre.
Voir les offresQuand choisir GPT (OpenAI)
Des modèles GPT au raisonnement intégré et réglable, des sorties structurées, des outils intégrés, des GPT personnalisés et Codex : ce qui oriente vers OpenAI.
Voir les offresOutils de code : complétion, IDE, terminal, cloud
Complétion, agent d'éditeur, agent en ligne de commande, agent cloud asynchrone : choisir l'outil de code selon la tâche et le niveau d'autonomie qu'on lui accorde.
Voir les offresIA pour l'interface : de la maquette à la spécification
Générer une interface avec v0, Figma Make ou des artifacts, puis passer du prototype jetable à une spécification que l'équipe peut intégrer et relire.
Voir les offresInclus dès l'offre Essentiel
Technique IA (LLM, RAG, agents)
Tokens, embeddings, RAG, fine-tuning, agents et stack MCP : comprendre les modèles pour les intégrer.
8 modules · 45 leçons
Parcours technique
Tokens, RAG et agents s'ouvrent dès l'offre Essentiel
8 modules et 45 leçons pour passer de l'usage des modèles à leur intégration : embeddings, chunking, pipelines RAG, fine-tuning, agents et outillage. L'offre Essentiel est à 12,99 € / mois.
- Fondamentaux des LLM7
- Embeddings & RAG8
- Fine-tuning & stratégies6
- IA agentique6
- Skills, MCP & CLI6
- Pipelines de production4
- Spécialisation & architecture personnelle5
- Approfondissement & intelligence pratique3
Fondamentaux des LLM
Prédiction du jeton suivant, tokenisation, fenêtre de contexte, échantillonnage, modèles de raisonnement, entrées multimodales et hallucinations : comprendre le moteur avant de l'orchestrer.
7 leçons
Comment fonctionne un LLM
Prédire le jeton suivant, distinguer entraînement et inférence, et comprendre pourquoi le modèle n'interroge aucune base de faits.
Voir les offresJetons et tokenisation
Découpage BPE, ratio mots-jetons en français, coût d'entrée et de sortie, historique renvoyé à chaque tour.
Voir les offresFenêtre de contexte en profondeur
Budget partagé entre entrée et sortie, historique qui grossit, compaction : simuler une conversation tour par tour.
Voir les offresTempérature, top-p et longueur de sortie
Calculer soi-même un softmax à température et un filtre top-p, et savoir quand ces réglages n'existent pas.
Voir les offresModèles de raisonnement et effort
Calcul au moment de l'inférence, jetons de raisonnement facturés, niveau d'effort : choisir l'effort minimal qui atteint la qualité voulue.
Voir les offresImages, PDF et audio en entrée
Comment une page devient des jetons, lecture de texte contre compréhension visuelle, tableaux et graphiques, confidentialité et recoupement.
Voir les offresLimites et hallucinations
Pourquoi le modèle produit du plausible faux, et comment poser des conditions de refus observables plutôt qu'un seuil de confiance imaginaire.
Voir les offresEmbeddings & RAG
Vecteurs sémantiques, découpage des documents, recherche vectorielle et hybride, pipeline RAG, évaluation et variantes avancées.
8 leçons
Embeddings : vecteurs sémantiques
Ce qu'est un embedding, comment se lit une similarité cosinus, et pourquoi la négation et les homonymes piègent la recherche sémantique.
Voir les offresDécouper les documents : taille, chevauchement, titres
Découper un cours en morceaux indexables sans franchir un titre, avec chevauchement, et préfixer chaque morceau de son titre de section.
Voir les offresBases vectorielles et recherche des plus proches voisins
Recherche exhaustive par cosinus, index approximatifs (HNSW, IVF), filtres par métadonnée avant ou après le classement, et choix entre pgvector, Qdrant, Chroma et services gérés.
Voir les offresRecherche hybride, fusion RRF et reranking
Combiner BM25 et recherche vectorielle, fusionner les classements par rang réciproque, puis reclasser les meilleurs candidats avec un cross-encoder.
Voir les offresPipeline RAG : récupérer, filtrer, assembler, citer
Les étapes hors ligne et en ligne d'un RAG, le seuil d'abstention, l'assemblage du prompt avec sources numérotées et la réponse sans appel au modèle quand rien ne passe le seuil.
Voir les offresÉvaluer un RAG : rappel, MRR, fidélité
Mesurer la récupération (recall@k, MRR) séparément de la génération (fidélité aux sources, citations, abstention) sur un jeu de référence annoté.
Voir les offresRAG avancé : contextuel, graphe, agentique
Retrieval contextuel, GraphRAG, RAG agentique et contexte long avec cache : ce que chaque variante corrige, ce qu'elle coûte, et quand le RAG classique suffit.
Voir les offresRAG ou contexte long avec cache
Comparer, chiffres à l'appui, un RAG et un contexte long avec cache de préfixe : fraîcheur, coût par requête, citations, taille du corpus.
Voir les offresFine-tuning & stratégies
Choisir le bon levier (prompt, RAG, sorties structurées, fine-tuning), préparer un jeu d'entraînement, dimensionner LoRA, comprendre le post-entraînement et faire tourner un modèle ouvert.
6 leçons
Prompt, RAG, sorties structurées ou fine-tuning ?
Le cadre de décision complet : quel levier pour quel problème, dans quel ordre les essayer, et pourquoi le fine-tuning arrive en dernier.
Voir les offresFine-tuning supervisé : le jeu de données d'abord
Ce qu'apprend un fine-tuning supervisé, le format conversationnel JSONL, et les contrôles qui évitent d'entraîner sur des données cassées.
Voir les offresQuand fine-tuner, et quand s'abstenir
Les signaux qui justifient un fine-tuning, ceux qui l'interdisent, et le coût total : données, évaluation, réentraînement à chaque nouveau modèle de base.
Voir les offresLoRA : dimensionner et déployer des adaptateurs
Ce qu'entraîne LoRA, combien de paramètres selon le rang et les matrices ciblées, QLoRA, et le service de plusieurs adaptateurs sur un même modèle de base.
Voir les offresPost-entraînement et alignement
Du modèle pré-entraîné à l'assistant : fine-tuning supervisé, RLHF et RLAIF, DPO, apprentissage par renforcement à récompenses vérifiables, distillation. Ce que chaque étape change, et ce qu'elle ne change pas.
Voir les offresModèles ouverts, quantification et inférence locale
Poids ouverts et licences, quantification, moteurs d'inférence, hébergement souverain contre API : estimer la mémoire nécessaire et choisir le modèle qui tient sur un GPU.
Voir les offresIA agentique
Ce qui fait d'un modèle un agent : la boucle, les outils, le raisonnement, la mémoire et les garde-fous, puis la carte complète du parcours technique.
6 leçons
IA agentique : de la réponse à l'action
Assistant, workflow ou agent : qui décide de l'étape suivante, et combien d'autonomie accorder selon le coût d'une erreur.
Voir les offresAppel d'outils (function calling)
Le modèle n'exécute rien : il émet un appel structuré que votre code valide et exécute. Écrire le contrat d'un outil sûr.
Voir les offresRaisonner, agir, observer : ReAct et planification
La boucle percevoir, décider, agir, observer comme modèle mental, le raisonnement natif des modèles de 2026 et l'art de découper une tâche.
Voir les offresLa mémoire d'un agent
Contexte de travail, compaction, notes persistantes, instructions de projet et recherche : où ranger chaque information pour qu'elle serve au bon moment.
Voir les offresGarde-fous et validation humaine
Permissions, approbations, bac à sable, plafonds et hooks : choisir le bon garde-fou selon le risque, et savoir lesquels sont vraiment contraignants.
Voir les offresLa carte du parcours technique
Modèle, contexte, RAG, outils, agent, évaluation : une seule carte pour situer chaque notion et diagnostiquer où un système échoue.
Voir les offresSkills, MCP & CLI
Étendre un agent : skills pour l'expertise, MCP pour les outils et les données, ligne de commande pour la preuve, instructions et permissions pour le cadre.
6 leçons
C'est quoi un skill ?
Un dossier, un SKILL.md avec un en-tête name et description, un corps chargé seulement quand la tâche se présente.
Voir les offresC'est quoi MCP ?
Le Model Context Protocol : hôtes, clients et serveurs, outils, ressources et prompts, transports, autorisation et gouvernance ouverte.
Voir les offresLa ligne de commande : la preuve par l'exécution
Pourquoi un agent passe par le terminal, quelles commandes lui confier, et comment lui faire enchaîner lint, tests et build avec arrêt au premier échec.
Voir les offresInstructions de projet : AGENTS.md et règles
Ce que l'agent doit savoir à chaque session : où l'écrire, comment le garder court, et ce qui n'y a pas sa place.
Voir les offresGarde-fous d'un dépôt : permissions et hooks
Écrire les règles refuser, demander, autoriser d'un assistant de code, comprendre leur ordre d'évaluation et leurs limites.
Voir les offresComposer la pile : quel mécanisme pour quel besoin
Règle, skill, MCP, ligne de commande, hook ou permission : choisir le bon mécanisme pour chaque besoin d'un projet réel.
Voir les offresPipelines de production
Enchaîner maquette, spécification, plan, implémentation et revue : des chaînes reproductibles où chaque étape produit un livrable vérifiable, quel que soit l'outil.
4 leçons
De la maquette au code : la passation
Ce qu'un agent de code doit recevoir pour implémenter un composant sans deviner : propriétés, états, accessibilité, fichiers, hors périmètre, critère d'arrêt.
Voir les offresLa chaîne complète vue d'en haut
Spécification, plan, implémentation, revue : ce que produit chaque étape, quel contrôle la ferme et où remonter quand un défaut apparaît.
Voir les offresPipeline data : relire le code d'analyse généré
De la question métier au chiffre fiable : relire un script d'analyse produit par une IA, y trouver un filtre inversé et une fuite de données, puis corriger.
Voir les offresFaire écrire des tests utiles
Obtenir d'un assistant des tests qui vérifient un comportement observable (codes HTTP, effets) plutôt que l'implémentation, et une documentation qui explique le pourquoi.
Voir les offresSpécialisation & architecture personnelle
Appliquer les LLM à SQL et MERISE, au développement, à la data et à la recherche, puis rédiger votre fiche d'architecture IA personnelle.
5 leçons
SQL et MERISE avec un LLM
Enchaîner MCD, MLD et requêtes avec un assistant, un artefact à la fois, et valider chaque requête par son exécution plutôt que par sa lecture.
Voir les offresDéveloppement fullstack : découper en tâches bornées
Une fonctionnalité bout en bout (schéma, API, interface) confiée à un agent en tâches courtes, chacune avec ses fichiers cibles et son critère d'arrêt.
Voir les offresData science et ML : l'IA code, vous contrôlez
Faire écrire un pipeline d'apprentissage reproductible et sans fuite de données, puis vérifier soi-même le découpage, les métriques et la graine aléatoire.
Voir les offresRecherche approfondie et vérification des sources
Utiliser un mode de recherche approfondie pour une question technique, puis vérifier que chaque source existe, dit bien ce qu'on lui attribue et est à jour.
Voir les offresProjet de synthèse : votre fiche d'architecture IA
Rédiger la fiche qui fixe, pour vos usages réels, le modèle, le contexte, le choix RAG ou non, les outils, les garde-fous, l'évaluation et le budget.
Voir les offresApprofondissement & intelligence pratique
Apprendre avec l'IA sans lui déléguer l'apprentissage, construire le contexte d'une demande, et rester intègre dans ses travaux et livrables.
3 leçons
Charge cognitive : apprendre avec l'IA sans déléguer l'apprentissage
Ce qui se passe dans la mémoire de travail quand l'IA fait l'effort à votre place, et comment construire une séance qui garde l'effort utile.
Voir les offresConstruire le contexte d'une demande
Quoi joindre, quoi résumer, quoi exclure : composer le contexte d'une demande à un assistant de code dans un budget de jetons.
Voir les offresIntégrité académique et professionnelle
Déclarer son usage de l'IA, respecter la propriété intellectuelle, repérer les biais : rester l'auteur responsable de ce qu'on rend.
Voir les offresInclus dès l'offre Essentiel
Build With AI
Développer avec l'IA, de l'instruction de projet à l'équipe outillée : skills, outils et MCP, boucles d'agent, automatisation, CI, évaluations, sécurité et coûts. Chaque leçon se valide par du code exécuté, un fichier contrôlé ou un questionnaire corrigé.
14 modules · 97 leçons
Build With AI s'ouvre dès l'offre Essentiel, avec le parcours technique. Voir les offres
Niveau Fondamentaux
Instructions de projet, skills, outils d'un agent et première boucle d'agent codée à la main. 4 modules · 30 leçons
Instructions de projet qui tiennent la route
Écrire un AGENTS.md interopérable et exécutable, résoudre la précédence dans un monorepo, puis tester les instructions et détecter leur dérive comme du code.
7 leçons
AGENTS.md, un standard ouvert
Ce que fixe le format AGENTS.md, qui le porte, et comment servir plusieurs assistants de code avec un seul fichier source.
Voir les offresRésoudre la précédence des fichiers imbriqués
Calculer quels AGENTS.md s'appliquent à un fichier modifié dans un monorepo, et lequel fait foi en cas de conflit.
Voir les offresDes commandes que l'agent peut exécuter
Écrire des commandes copiables telles quelles, avec répertoire, résultat attendu et durée, en séparant vérification rapide et suite complète.
Voir les offresInterdits : du texte au garde-fou
Écrire chaque interdit avec sa raison et le mécanisme déterministe qui l'applique : le texte informe, le garde-fou contraint.
Voir les offresTester ses instructions
Écrire un vérificateur d'AGENTS.md : scénarios de couverture, contradictions toujours ou jamais, budget de lignes, verdict pour la CI.
Voir les offresDétecter la dérive des instructions
Confronter les commandes et chemins cités par AGENTS.md au dépôt réel pour repérer en CI les références mortes.
Voir les offresAtelier : l'AGENTS.md complet d'un service
Rédiger l'AGENTS.md d'un service d'API Python fictif : court, exécutable, sans secret, interdits reliés à leurs garde-fous.
Voir les offresSkills : concevoir, outiller, distribuer
Écrire un SKILL.md conforme à la spécification ouverte, exploiter le chargement progressif, mesurer le déclenchement et auditer un skill avant de le diffuser.
8 leçons
La spécification SKILL.md
Un dossier, un SKILL.md, deux champs obligatoires et quatre facultatifs : la norme ouverte des skills, règle par règle.
Voir les offresÉcrire un validateur de skill
Transformer chaque règle de la spécification en contrôle automatique, à lancer en local comme en intégration continue.
Voir les offresLa description, un déclencheur
L'agent ne lit que la description pour décider : verbes, objets, mots de l'utilisateur et exclusions font la différence.
Voir les offresChargement progressif et budget de contexte
Métadonnées au démarrage, corps à l'activation, ressources à la demande : chiffrer ce que coûtent vraiment vos skills.
Voir les offresScripts, références et modèles
scripts/, references/, assets/ : déplacer le déterministe dans du code, le détail dans des fichiers lus à la demande.
Voir les offresTester le déclenchement d'un skill
Traiter la description comme un classifieur : requêtes étiquetées, précision, rappel, et choix de version mesuré.
Voir les offresSécurité et distribution des skills
Un skill s'exécute avec vos droits : auditer un skill tiers avant de l'installer et diffuser les vôtres proprement.
Voir les offresAtelier : un skill outillé de bout en bout
Assembler un skill complet : en-tête conforme, quand l'utiliser ou non, étapes, script, référence et critère de fin.
Voir les offresConcevoir les outils d'un agent
Écrire le contrat d'un outil (nom, description, schémas, résultats, erreurs, annotations, état) pour qu'un agent l'utilise juste du premier coup.
7 leçons
Un outil est un contrat
Nom, description, schéma : c'est tout ce que le modèle sait d'un outil. Les règles de nommage MCP et une description qui guide le choix.
Voir les offresÉcrire le schéma d'entrée
JSON Schema 2020-12 pour les arguments : propriétés décrites, required, enum, entiers, additionalProperties à false.
Voir les offresGranularité : peu d'outils, bien choisis
Recopier une API point par point coûte du contexte et des appels. Concevoir des outils orientés tâche et mesurer la différence.
Voir les offresRésultats et erreurs exploitables
content, structuredContent et outputSchema ; erreur de protocole contre erreur d'exécution ; messages qui font avancer, pagination.
Voir les offresAnnotations et effets de bord
readOnlyHint, destructiveHint, idempotentHint, openWorldHint : valeurs par défaut, sens exact, confiance et politique de confirmation.
Voir les offresOutils avec état : poignées explicites
Sans session de protocole, l'état passe par une poignée opaque en argument : autorisation à chaque appel, durée de vie, erreur d'expiration.
Voir les offresAtelier : la boîte à outils d'un agent de support
Trois outils pour un agent de support : chercher, lire, rembourser. Schémas stricts, sortie structurée, annotations et confirmation.
Voir les offresCoder une boucle d'agent
Écrire en Python la boucle modèle, outils, résultats, la tester sans modèle, puis la borner : tours, budget, répétitions, sorties validées, approbation.
8 leçons
Anatomie de la boucle
Messages, demandes d'outils, résultats rattachés à leur identifiant, nouveau tour : le squelette de tout agent, écrit en Python.
Voir les offresUn faux modèle pour tester sans modèle
Remplacer le modèle par un double déterministe, à règles ou scripté, pour tester en CI les chemins difficiles de la boucle.
Voir les offresRouter les appels d'outils
Registre nom vers fonction, validation des arguments, outil inconnu et exceptions transformées en erreurs lisibles renvoyées au modèle.
Voir les offresConditions d'arrêt et budgets
Nombre maximal de tours, budget de jetons, détection de répétition et motif d'arrêt explicite, journalisé et remonté à l'utilisateur.
Voir les offresAppels parallèles et ordre des résultats
Plusieurs outils demandés dans un tour : les exécuter en parallèle quand ils sont indépendants et rattacher chaque résultat à sa demande.
Voir les offresValider une sortie structurée
Exiger un JSON conforme à un schéma, le valider, renvoyer l'erreur précise au modèle et borner le nombre de tentatives.
Voir les offresL'humain dans la boucle
Lecture automatique, écriture soumise à accord, destruction refusée hors liste blanche : coder les points d'approbation et leurs messages.
Voir les offresAtelier : un mini assistant de code
Assembler la boucle complète : trois outils sur un système de fichiers en mémoire, faux modèle qui corrige un bug, garde-fous et bilan.
Voir les offresNiveau Avancé
MCP en profondeur, contexte et mémoire, automatisations, IA dans la CI, spécifications et tests. 5 modules · 34 leçons
MCP en profondeur
Lire et écrire les messages MCP, coder un serveur simulé, maîtriser la révision 2026-07-28 sans état, l'autorisation OAuth et l'audit d'un serveur tiers.
8 leçons
Hôte, client, serveur
Les trois rôles de MCP, les primitives du serveur et qui les contrôle, et ce qui change côté client dans la révision 2026-07-28.
Voir les offresLire et écrire des messages JSON-RPC
Requêtes, réponses et erreurs MCP champ par champ : tools/list paginé, tools/call, resultType et métadonnées _meta de la révision 2026-07-28.
Voir les offresTransports : stdio et HTTP
stdio pour un serveur local, Streamable HTTP pour un serveur partagé : règles de chaque transport, en-têtes Mcp-Method et Mcp-Name, et pièges de sécurité.
Voir les offresÉcrire un serveur d'outils simulé
Le cœur d'un serveur MCP en Python pur : aiguillage des méthodes, liste d'outils triée, erreurs JSON-RPC et résultats isError.
Voir les offresRessources et prompts
Exposer du contenu par URI et des modèles de message : resources/read, modèles d'URI RFC 6570, prompts/get, et quand préférer une ressource à un outil.
Voir les offresUn protocole sans état : la révision 2026-07-28
Fin d'initialize et des sessions, _meta sur chaque requête, server/discover, requêtes multi-allers-retours avec requestState, tâches en extension.
Voir les offresAutoriser l'accès à un serveur distant
OAuth pour un serveur MCP distant : métadonnées de ressource protégée, audience et portées, métadonnées client, vérification de iss, jeton hors du modèle.
Voir les offresAuditer un serveur avant de le brancher
Provenance, version épinglée, lecture des définitions d'outils, permissions et réseau, puis surveillance des mises à jour par empreintes.
Voir les offresIngénierie du contexte et mémoire
Budgéter le contexte, charger juste à temps, compacter sans perdre les décisions, tenir une mémoire sur fichiers et mener une tâche longue sur plusieurs sessions.
6 leçons
Le contexte, une ressource finie
Consignes, outils, instructions, historique, résultats d'outils : mesurer chaque poste du contexte et fixer des seuils d'alerte.
Voir les offresCharger juste à temps
Garder des références légères et lire au besoin : un outil de lecture paginée, borné, qui dit comment obtenir la suite.
Voir les offresCompaction : résumer sans perdre
Compacter un historique trop long : garder décisions et prochaines étapes, effacer les anciens résultats d'outils, garder les derniers tours.
Voir les offresMémoire persistante : notes et fichiers d'état
La mémoire durable d'un agent vit hors du contexte : fichier de progression, tâches structurées, git. Faits vérifiés, jamais de secrets.
Voir les offresIsoler le contexte avec des sous-agents
Un sous-agent explore dans son propre contexte et ne renvoie qu'un résumé borné : quand c'est rentable, et quel contrat de retour fixer.
Voir les offresTâches longues sur plusieurs sessions
Mener une tâche de plusieurs heures : état structuré, une fonctionnalité par session, test de bout en bout avant de cocher, passation.
Voir les offresAutomatiser : hooks, déclencheurs, tâches planifiées
Écrire des hooks testables, lancer un agent sans interface sur un événement ou une planification, et rendre l'automatisation idempotente, verrouillée et capable de reprendre.
7 leçons
Un hook est un programme
Écrire un hook comme une fonction pure : un événement JSON en entrée, une décision motivée en sortie, des tests, un refus par défaut.
Voir les offresHook de vérification après modification
Après chaque écriture, planifier la vérification la moins chère qui a du sens, sans doublon, avec un plafond et sans relance en boucle.
Voir les offresLe mode non interactif
Lancer un assistant de code sans interface : consigne en argument, permissions restreintes, flux JSON lisible par un script, code de sortie fiable.
Voir les offresDéclencheurs : événements et webhooks
Déclencher un agent sur un événement : vérifier la signature HMAC du corps brut, dédoublonner par livraison, filtrer avant de dépenser.
Voir les offresTâches planifiées
Planifier un agent en cron à 5 champs avec un fuseau explicite, et éviter chevauchements, rattrapages ratés et rapports que personne ne lit.
Voir les offresIdempotence, verrous et reprises
Une automatisation finit par tourner deux fois : clés d'idempotence, verrou à expiration, reprises à attente exponentielle et journal des actions.
Voir les offresAtelier : la chaîne de garde d'une session
Rejouer une session d'agent enregistrée à travers trois gardes : refus avant outil, vérification après écriture, contrôle de fin de session.
Voir les offresL'IA dans la CI et la revue de code
Placer des agents dans la chaîne de livraison sans leur confier la fusion : workflows au moindre privilège, revue utile, gates déterministes et budget.
7 leçons
Où placer un agent dans la chaîne
Revue, tri, diagnostic, dépendances, documentation : ce qu'un agent fait bien en CI, et ce qui reste une décision humaine.
Voir les offresUn workflow CI au moindre privilège
Permissions déclarées, secrets à l'étape, bon déclencheur, délai, concurrence et actions épinglées par empreinte.
Voir les offresConcevoir une revue automatique utile
Lignes modifiées seulement, seuil de confiance, dédoublonnage, plafond de commentaires et mesure du taux de commentaires suivis d'effet.
Voir les offresContenu de PR non fiable
Titre, description, branche et code d'une PR sont des entrées hostiles possibles : séparer l'analyse sans droits de la publication.
Voir les offresRéparer une CI cassée avec un agent
Boucle bornée, première erreur, brief extrait des journaux, interdiction de toucher aux tests, correctif en PR séparée.
Voir les offresGates et contrôles obligatoires
La fusion dépend de contrôles déterministes, d'une approbation humaine valide et des propriétaires des fichiers sensibles.
Voir les offresBudget et quotas de l'automatisation
Déclenchement sélectif, cache, modèle adapté et plafond quotidien qui coupe proprement : maîtriser le coût des agents en CI.
Voir les offresSpécifications et tests pilotés avec un agent
Écrire une spec exploitable par un agent, piloter le test d'abord, tracer exigences, tâches et tests, et empêcher l'agent de contourner les tests.
6 leçons
Écrire une spécification pour un agent
Exigences numérotées, critères « Étant donné, Quand, Alors », hors périmètre et questions ouvertes : une spec qu'un agent peut suivre.
Voir les offresDécouper en tâches vérifiables
Des tâches petites, ordonnées, chacune avec sa vérification, et une matrice qui relie exigences, tâches et tests.
Voir les offresRouge, vert, refactorisation avec un agent
Tests d'abord, échec vérifié, tests figés après relecture, puis implémentation jusqu'au vert et refactorisation sous protection.
Voir les offresEmpêcher l'agent de tricher avec les tests
Assertion affaiblie, test sauté, cas codé en dur : repérer les contournements dans un diff et les rendre impossibles.
Voir les offresCode existant : tests de caractérisation d'abord
Figer le comportement actuel, bugs compris, avant de confier une refactorisation à un agent ; corriger un bug est une autre tâche.
Voir les offresAtelier : de la spécification au plan de tests
À partir d'une spec de quatre exigences, rédiger le plan de tests que l'agent devra rendre verts : critères, cas limites et commande.
Voir les offresNiveau Expert
Orchestration multi-agents, évaluation, sécurité, coûts et observabilité, industrialisation en équipe. 5 modules · 33 leçons
Orchestration multi-agents
Choisir un motif d'orchestration, coder routeur, répartition et passation, contenir les défaillances et chiffrer le coût réel.
6 leçons
Les motifs d'orchestration
Chaîne, routage, parallélisation, orchestrateur et évaluateur : cinq motifs, et l'agent unique comme point de départ.
Voir les offresÉcrire un routeur
Classer une demande par règles pondérées, l'envoyer au bon spécialiste, prévoir un repli et journaliser pour évaluer.
Voir les offresRépartir puis fusionner
Découper en sous-tâches indépendantes, isoler l'espace d'écriture de chaque travailleur, puis fusionner en détectant les conflits.
Voir les offresContrats de passation entre agents
Une passation est un message structuré, validé par un schéma et authentifié : objectif, contraintes, format de retour, fin, budget.
Voir les offresDéfaillances en cascade
Empêcher l'erreur d'un agent de contaminer les suivants : validation entre étapes, budgets, disjoncteur et dégradation explicite.
Voir les offresQuand le multi-agents ne vaut pas le coût
Chiffrer jetons, latence et coordination d'un orchestrateur avec travailleurs, et décider sur une règle écrite à l'avance.
Voir les offresÉvaluer un agent
Construire une évaluation d'agent avec des correcteurs en code et des juges calibrés, mesurer la fiabilité (pass@k, pass^k), contrôler la trajectoire et bloquer les régressions en CI.
7 leçons
Anatomie d'une évaluation
Tâche, essai, transcription, correcteur, résultat : le vocabulaire d'une évaluation d'agent, et la différence entre capacité et régression.
Voir les offresCorrecteurs déterministes
Tests sur le résultat, état final vérifié, comparaison normalisée et contraintes vérifiables : le correcteur en code, rapide, gratuit et reproductible.
Voir les offresÉcrire la grille d'un juge
Critères atomiques, échelle courte avec exemples ancrés, raisonnement avant la note, sortie JSON, et parades aux biais connus des juges.
Voir les offresCalibrer un juge contre l'humain
Comparer les notes du juge à des annotations humaines : accord brut, kappa de Cohen, matrice de confusion, puis corriger la grille là où il diverge.
Voir les offresNon-déterminisme : pass@k et pass^k
Un agent ne réussit pas toujours la même tâche : mesurer « au moins une fois sur k » (pass@k) et « à chaque fois sur k » (pass^k) à partir de n essais.
Voir les offresÉvaluer la trajectoire
Lire avant d'écrire, jamais d'outil destructeur, au plus N étapes, confirmation avant envoi : vérifier les exigences sur le chemin sans figer le reste.
Voir les offresSuite de régression et seuils en CI
Jeu de référence versionné, rejoué à chaque changement de consigne, de skill ou de modèle, et seuils qui tolèrent le bruit mais bloquent les régressions.
Voir les offresSécuriser un système agentique
Modéliser les menaces d'un agent avec le Top 10 OWASP agentique, casser la combinaison qui permet l'exfiltration, défendre en couches, puis protéger secrets, bac à sable et dépendances, et savoir réagir à un incident.
8 leçons
Le modèle de menace d'un agent
Actifs, frontières de confiance et sources non fiables, puis les dix risques ASI01 à ASI10 du Top 10 OWASP des applications agentiques.
Voir les offresDonnées privées, contenu non fiable, sortie : la combinaison à casser
Un agent qui cumule données privées, contenu non fiable et sortie externe peut exfiltrer. Retirer au moins une des trois capacités pour la tâche.
Voir les offresRepérer une injection de consigne
Injection directe ou indirecte, cachée dans un commentaire, du texte invisible, un encodage ou une fausse autorité : apprendre à la lire dans un document.
Voir les offresDéfenses en profondeur
Aucun filtre n'arrête toutes les injections : séparation des privilèges, sorties contraintes, liste de domaines, confirmation fidèle, marquage et audit.
Voir les offresSecrets et identités d'agent
Le secret reste hors du contexte du modèle, l'agent a sa propre identité à jetons courts, et journaux et sorties sont masqués avant stockage.
Voir les offresBac à sable et permissions
Conteneur ou machine virtuelle, fichiers limités au projet, réseau filtré, utilisateur sans privilèges, limites de ressources et de durée.
Voir les offresChaîne d'approvisionnement : paquets, serveurs, skills
Paquets inventés ou mal orthographiés, versions non épinglées, serveurs MCP et skills tiers : vérifier provenance, âge, empreinte et mises à jour.
Voir les offresRéagir à un incident d'agent
Détecter, contenir, conserver les traces, analyser la trajectoire, corriger, ajouter le cas au jeu de régression, et écrire un post-mortem sans coupable.
Voir les offresCoûts, latence et observabilité
Chiffrer le coût réel d'une session d'agent, le réduire par le cache et le routage, tenir un budget de latence, tracer chaque étape et poser des plafonds qui coupent proprement.
6 leçons
Compter ce que coûte une tâche
Une session d'agent relit tout son historique à chaque tour : décomposer le coût par poste et voir l'entrée grossir tour après tour.
Voir les offresMise en cache du préfixe
Un préfixe déjà vu se facture moins cher : construire des requêtes stables en tête, variables à la fin, et repérer ce qui casse le cache.
Voir les offresChoisir le modèle par tâche
Petit modèle pour classer, extraire et résumer, grand modèle pour planifier, escalade sur échec vérifié : chiffrer avant de généraliser.
Voir les offresTenir un budget de latence
Délai du premier jeton, débit, outils et attente humaine : trouver le chemin critique et agir sur l'étape qui fait vraiment gagner.
Voir les offresTracer un agent
Une trace par tâche, un span par agent, appel de modèle et outil, aux conventions GenAI d'OpenTelemetry, contexte propagé jusqu'au serveur MCP.
Voir les offresPlafonds, alertes et coupe-circuit
Plafonds par tâche, par utilisateur et par jour, alerte avant la coupure, coupure propre, et un tableau de bord centré sur le coût par tâche réussie.
Voir les offresIndustrialiser en équipe
Relire le code d'un agent, tracer les contributions, gouverner skills et politique d'usage, mesurer l'effet réel et documenter l'architecture complète.
6 leçons
Relire du code produit par un agent
Comprendre avant d'approuver : tests qui ne testent rien, dépendances inutiles, doublons, entrées non validées et PR trop longues.
Voir les offresTraçabilité : qui a écrit quoi
Trailers de commit, description de PR qui dit la consigne et les vérifications : des traces pour auditer et mesurer, une responsabilité humaine.
Voir les offresUne bibliothèque partagée de skills
Un dépôt commun de skills : propriétaire, versions sémantiques, revue obligatoire, tests en CI, dépréciation annoncée et versions déclarées par projet.
Voir les offresPolitique d'usage : données, outils, autonomie
Une page qui dit quelles données vont où, quels outils sont approuvés, quelle autonomie par environnement, quelle revue et qui prévenir.
Voir les offresMesurer l'effet réel
Délai de cycle, taux de fusion, retours en arrière, incidents, temps de revue : mesurer avant et après, et éviter les pièges classiques.
Voir les offresProjet de synthèse : l'architecture d'un système Build With AI
Documenter de bout en bout le système de développement assisté d'une équipe : instructions, skills, outils, CI, évaluation, sécurité, coûts.
Voir les offres