Generative AI for Beginners, de Microsoft (en anglais dans l'original ; l'IA générative pour les débutants), est un cours gratuit, sous licence MIT, de 21 leçons, qui compte plus de 117 000 étoiles sur GitHub.[1] C'est un bon indicateur de ce que le marché entend aujourd'hui par « apprendre à construire avec l'IA ». Et c'est un bon cours. Un développeur qui le suit jusqu'au bout peut bâtir une application de clavardage, une recherche dans vos propres documents et un premier agent d'IA. Nous avons comparé chaque leçon à ce qu'il faut pour faire tourner cet agent sans que personne ne le surveille, et le côté droit de la carte est presque vide. Les évaluations, le coût et le moment de s'arrêter y apparaissent en passant, dans une liste de mesures ou une ligne d'un prompt d'exemple. Aucune leçon ne vous les fait construire. Pour un cours destiné aux débutants, c'est une portée raisonnable. C'est aussi la lacune que votre équipe doit encore franchir après la dernière leçon.
Si vous cherchez d'abord à décider de ce que votre équipe devrait apprendre, passez directement au tableau de décision.
Ce qu'est le cours.
La version 3 du cours compte 21 leçons plus une leçon d'installation. Chacune porte la mention Learn (« apprendre » : une leçon de concepts) ou Build (« construire » : un concept accompagné, dans la mesure du possible, d'exemples de code en Python et en TypeScript). Neuf des 21 sont des leçons Build, et plusieurs leçons Learn comportent aussi du code : la leçon 4 est accompagnée d'un carnet Jupyter, et les leçons 19 à 21 incluent des exemples exécutables. La séquence va de ce qu'est un grand modèle de langage (LLM), en passant par la rédaction de prompts (les consignes données au modèle), les applications de texte et de clavardage, la recherche par embeddings (une représentation numérique du sens d'un texte), la génération d'images, les outils à faible code et l'appel de fonctions, jusqu'à la génération augmentée par récupération (RAG), les modèles à code source ouvert et les petits modèles, avec une leçon sur les agents d'IA et une sur l'ajustement fin (fine-tuning).[1]
L'ordre est solide. L'ingénierie de prompts arrive aux leçons 4 et 5, avant toute application, et les agents à la leçon 17, après l'appel de fonctions et après le RAG. C'est la même gradation que nous défendons dans notre ordre de construction des agents en production : utilisez la brique la plus simple qui fonctionne, et gardez l'agent pour la fin.
Une chose à savoir avant de le confier à qui que ce soit : trois des quatre environnements d'exécution pris en charge sont ceux de Microsoft (Azure OpenAI, Microsoft Foundry Models et Foundry Local), le quatrième est l'API d'OpenAI, et les liens du cours portent une balise de suivi de campagne de Microsoft.[1] Le cours est gratuit ; les environnements infonuagiques vers lesquels il vous apprend à vous tourner sont facturés. Rien de caché là-dedans, mais la leçon 2, sur le choix d'un modèle, est rédigée par un fournisseur infonuagique et doit être lue comme telle.
La carte de couverture, leçon par leçon.
Nous avons lu chaque leçon en regard de quatre éléments dont un système a besoin avant de pouvoir tourner sans surveillance : des évaluations (un jeu fixe de cas réels que vous relancez à chaque changement, les « évals » des figures), le coût de chaque étape, une règle d'arrêt, et une supervision qui joint une personne. La première colonne indique les neuf leçons que le cours étiquette Build, le cœur de la couche de construction. Les quatre autres forment la couche de production.
Selon notre décompte, les évaluations sont nommées dans 10 leçons, le coût dans 10, une règle d'arrêt dans 1 et la supervision dans 5, et aucun des quatre éléments n'est construit dans une leçon.
Lisez d'abord la colonne de gauche. Les neuf leçons Build sont celles qui rendent un développeur productif : applications de texte et de clavardage, embeddings, génération d'images, outils à faible code, appel de fonctions, RAG, modèles à code source ouvert, un agent. C'est la couche de construction, et le cours la couvre bien.
Lisez ensuite le côté droit. Il n'est pas vide. La leçon 14, sur le cycle de vie de l'application, énumère les mesures à l'aune desquelles juger une application d'IA, « Quality, Harm, Honesty, Cost and Latency » (en anglais dans l'original ; qualité, préjudice, honnêteté, coût et latence), et recommande d'ajouter des « Monitoring and Alerts Systems » (en anglais dans l'original ; systèmes de supervision et d'alertes) au moment de la mise en production.[2] La leçon 15 énumère quatre mesures d'évaluation pour une application RAG. La leçon 6 prévient que « Tokens cost money » (en anglais dans l'original ; les jetons coûtent de l'argent). Ces éléments sont nommés. Ce que le cours ne fait jamais, c'est vous les faire bâtir : aucune leçon ne vous fait constituer un jeu d'évaluations et le relancer, mesurer ce que coûte une étape, ou plafonner la durée d'exécution d'un agent. Aucune leçon n'est consacrée aux évaluations, au coût ou au moment de s'arrêter ; la leçon 14 traite l'évaluation comme une étape du cycle de vie, en prose.
Couche de construction, couche de production.
Une façon utile de voir la lacune est d'imaginer deux couches. La couche de construction, c'est ce qui fait marcher une fonctionnalité d'IA une fois, devant vous. La couche de production, c'est ce qui lui permet de continuer à fonctionner quand vous n'êtes pas là : à une mise à jour du modèle, devant une entrée étrange, à la centième exécution de la nuit.
Trois de ces quatre lacunes sont celles qui coûtent de l'argent quand elles manquent. La supervision compte aussi, mais une alerte manquante aggrave généralement l'une des trois autres plutôt que de causer sa propre défaillance. Chacune des trois s'appuie sur l'une de nos notes de terrain, toutes des exemples illustratifs.
Première lacune : les évaluations.
Le cours dit d'évaluer. La leçon 3 affirme que « we should always evaluate the model's performance and outputs » (en anglais dans l'original ; nous devrions toujours évaluer la performance et les sorties du modèle), la leçon 14 énumère cinq mesures, la leçon 15 en énumère quatre.[2] Ce qu'il faut à une équipe en production est plus étroit et plus mécanique : un jeu fixe de cas réels tirés de votre propre travail, avec les réponses attendues, relancé automatiquement chaque fois que le prompt, le modèle ou les données changent. C'est ce jeu qui vous dit qu'un changement a cassé quelque chose avant que ce soit un client qui s'en aperçoive.
Sans lui, l'échec est silencieux. Le fournisseur du modèle publie une mise à jour, aucune erreur ne s'affiche, et la sortie devient plausible et légèrement fausse, d'une façon qui ne se manifeste que trois étapes plus loin. C'est le cas autour duquel est bâtie notre note sur la suite d'éval en six lignes, dont l'idée est que cette suite n'a pas à devenir un projet de recherche. Elle doit en revanche exister avant que le système tourne sans surveillance, et une liste de noms de mesures n'en est pas une. Ce qui s'en rapproche le plus dans le cours, c'est le renvoi de la leçon 14 vers un atelier externe facultatif qui comporte une étape d'évaluation par lots.
Deuxième lacune : le coût de chaque étape.
Le coût apparaît dans dix leçons, toujours à l'échelle d'un modèle, d'un jeton ou d'un budget : un modèle coûte moins cher qu'un autre, les modèles à code source ouvert coûtent moins cher par jeton, « Tokens cost money, so where possible, we should try to be economical with the number of tokens we use. » (en anglais dans l'original ; les jetons coûtent de l'argent, alors, dans la mesure du possible, il faut tâcher d'être économe du nombre de jetons que nous utilisons).[2] C'est le bon réflexe. En production, l'unité qui compte est l'étape. La facture du fournisseur ventile la dépense, au mieux, par modèle ou par clé, et elle ne vous dit pas quelle étape dépense.
Notre note sur le coût par étape décortique un cas illustratif où une trace par étape a montré que 12 % des appels généraient 60 % de la facture, un portrait qu'aucune liste de prix ne révélerait. Ce qu'il faut à une équipe, c'est le coût consigné à chaque étape, trié par dépense plutôt que par volume, et un plafond par exécution. Rien de cela n'est difficile, et le cours n'en traite pas.
Troisième lacune : savoir quand s'arrêter.
C'est la lacune qui transforme un bogue en facture. La seule règle d'arrêt écrite dans le code du cours se trouve dans l'agent d'exemple de la leçon 17, dont les instructions se terminent par : « Reply TERMINATE when the task is done. » (en anglais dans l'original ; répondre TERMINATE quand la tâche est terminée).[3] (La leçon mentionne aussi qu'un mandataire de l'utilisateur, le « user proxy », peut donner une rétroaction qui poursuit ou arrête une tâche, sans montrer comment.) Cela fonctionne dans une démo. Mais cela laisse au modèle la décision de s'arrêter, alors que la défaillance qu'on veut éviter est justement un modèle qui ne décide jamais qu'il a terminé.
Notre post-mortem de la boucle emballée déroule une version illustrative de bout en bout : un agent pris dans une boucle de reprises sur une réponse d'outil ambiguë, un plafond d'étapes qui se réinitialisait à chaque nouvelle sous-tâche, aucune alerte de coût, et 24 847 appels d'API sur neuf heures, pour 3 218 $, avant que quelqu'un ne regarde. Une règle d'arrêt qui tient comporte trois éléments que le modèle ne peut pas contourner : un plafond d'étapes qui ne se réinitialise pas, un plafond de dépense par exécution, et un point où l'agent transfère la tâche à une personne avec ce qu'il a accompli. Notre note sur un planificateur qui sait quand abandonner traite du troisième.
- Rédigez le jeu d'évaluations avant que le système tourne sans surveillance.
Des cas réels tirés de votre propre travail, avec les réponses attendues, relancés à chaque changement de prompt, de modèle ou de données. Commencez petit ; le jeu grossit chaque fois que quelque chose passe entre les mailles du filet.
→ aucun changement n'est livré sans relance - Consignez le coût par étape, et plafonnez-le par exécution.
Enregistrez ce que dépense chaque étape, triez par dépense, et fixez un plafond par exécution qui arrête l'exécution quand il est franchi, pas un plafond qui envoie un courriel le lendemain matin.
→ vous pouvez nommer votre étape la plus coûteuse - Donnez à l'agent une règle d'arrêt qu'il ne peut pas négocier.
Un plafond d'étapes qui ne se réinitialise jamais, un plafond de dépense, et un transfert à une personne avec le travail partiel. Le modèle peut toujours dire qu'il a terminé ; il n'est simplement pas seul à décider.
→ chaque exécution se termine, d'une façon ou d'une autre
À quoi s'en servir, et à quoi non.
Pour un dirigeant d'entreprise qui hésite entre construire, acheter ou embaucher, le cours répond à une question plus étroite qu'il n'y paraît. Il dit ce que votre développeur peut apprendre gratuitement. Il ne dit pas si le résultat peut être laissé en marche.
| usage | verdict | pourquoi |
|---|---|---|
| un vocabulaire commun pour une équipe | bon choix | après le cours, tout le monde entend la même chose par RAG, embeddings, appel de fonctions et agent |
| un plan de cours pour cadrer la formation | bon choix | 21 sujets, gratuits et sous licence MIT ; choisissez les leçons utiles à chaque rôle et laissez le reste |
| les premières versions fonctionnelles d'un développeur | bon choix | neuf leçons Build avec des exemples en Python et en TypeScript, plus du code dans plusieurs leçons Learn, activement maintenus |
| une voie vers un système qui tourne sans surveillance | pas pour cela | la couche de production est nommée, jamais construite (fig 1) |
| un guide neutre pour choisir un modèle | pas pour cela | la leçon 2 présente d'autres fournisseurs, mais vous oriente vers Microsoft Foundry pour les comparer |
| une ressource en français pour une équipe québécoise | avec prudence | traduction automatique par un service automatisé, ce que la page française signale elle-même en recommandant une traduction humaine pour un usage critique ; français générique plutôt que québécois |
Sur la dernière rangée : le dépôt offre le cours dans environ 55 langues, dont le français, toutes générées par une GitHub Action (un flux de travail automatisé) et rafraîchies automatiquement.[1] La version française le dit elle-même : elle a été produite par un service de traduction automatique, le document original fait autorité, et pour l'information critique elle recommande une traduction professionnelle réalisée par un humain.[4] Elle est aussi rédigée en français générique, pas en français québécois. Pour quelqu'un qui lit pour soi, c'est correct. Ne la remettez pas à une équipe québécoise comme référence en français sans dire ce qu'elle est.
La réponse à « mon développeur devrait-il le suivre ? » est donc oui, puis prévoyez ce qui vient après. Le cours amène une équipe jusqu'à une première version qui fonctionne. Passer de là à quelque chose à quoi vous pouvez vous fier pendant la nuit, c'est la couche de production, et cela passe soit par plus de formation, bâtie sur vos propres systèmes, soit par une équipe qui l'a déjà fait.
Ce que cette note ne prétend pas.
Ce n'est pas une critique du cours. C'est un cours pour débutants, et son titre l'annonce. Laisser de côté la couche de production est une portée raisonnable pour un tel cours, et ce qu'il couvre, il le couvre avec soin.
Une lecture des README, pas de chaque fichier. La carte est bâtie à partir du README de chaque leçon. Les dossiers d'exemples de code, les vidéos liées et les ateliers externes vers lesquels les leçons renvoient n'ont pas été vérifiés ; si un exemple va plus loin que son README, la fig 1 le sous-estime.
Nos colonnes, nos jugements. Les quatre éléments de production sont ceux que notre propre ordre de construction place avant l'autonomie. La liste de quelqu'un d'autre dessinerait une autre carte. Là où une leçon ne fait que nommer un élément, nous avons marqué généreusement.
Du matériel de fournisseur, lu comme tel. Le cours est la description que Microsoft fait de lui-même. Le nombre d'étoiles date d'août 2026 et évolue avec le temps ; la liste des leçons est celle de la version 3 du cours.
Les exemples d'échec sont illustratifs. Les cas d'évaluations, de coût et de boucle emballée viennent de nos propres notes de terrain, des exemples construits pour montrer un mécanisme, pas des dossiers d'un mandat client.
Si votre équipe a terminé un cours comme celui-ci et que vous ne savez pas trop ce qui sépare sa première version d'un système que vous pouvez laisser tourner, décrivez-nous le flux de travail par le formulaire de contact. Nous vous répondrons gratuitement, par écrit, en vous disant laquelle des trois lacunes nous comblerions d'abord. Bâtir des évaluations, des contrôles de coût et des règles d'arrêt dans des systèmes d'IA fait partie de nos services en assistants et agents.