Cursus IA Loop Engineering
Arrête de surveiller ton agent de code en permanence. Conçois des boucles qui s'auto-corrigent, vérifient leur propre travail, s'arrêtent au bon moment et tournent sans toi — sans cramer des tokens.
Why This Instead of a Traditional Degree?
Piloter ton agent à la main
- Tu restes devant ton agent et tu le relances dès qu'il cale
- Il s'arrête une étape trop tôt — ou continue 40 étapes après la fin, en cramant des tokens
- Quand ça dérape, tu relis toute la trace en devinant ce qui s'est passé
- Il te rend un travail cassé avec aplomb et le déclare terminé
- Impossible de le laisser seul cinq minutes, encore moins toute la nuit
Cursus IA Loop Engineering
- Conçois la boucle une fois ; elle se relance toute seule jusqu'à ce que le travail soit vraiment fini
- Une logique d'arrêt qui stoppe à la bonne étape, à chaque exécution
- La boucle critique et corrige ses propres erreurs avant même que tu les voies
- Elle lance ses propres tests et refuse de sortir tant que c'est rouge
- Tu lui fais confiance pour tourner sans toi — toute la nuit, jusqu'à un résultat vérifié
What You'll Learn
- Construire et instrumenter une boucle ReAct mono-agent qui itère sur une vraie tâche de code et expose son raisonnement, ses actions et son coût à chaque étape.
- Mettre en place une logique d'arrêt — nombre d'étapes max, plafond de budget, seuils de confiance, détection de point fixe — qui stoppe la boucle au bon moment.
- Mettre en place une sous-boucle d'auto-correction (générer → critiquer → réviser) et savoir juger quand la réflexion aide… ou gaspille des itérations.
- Intégrer la vérification au cœur de la boucle pour que l'agent valide son propre travail avec des tests, des linters et des contrôles avant de sortir.
- Distinguer les modes d'échec d'une boucle — oscillation, agitation stérile, arrêt prématuré, dérive sémantique, fausse réussite — à partir des signaux étape par étape d'une trace.
- Examiner les signaux étape par étape d'une boucle pour déterminer si elle converge, stagne ou dérive.
- Justifier le compromis coût–qualité–itérations d'une boucle, en décidant où couper des étapes, changer de niveau de modèle ou sortir plus tôt.
- Concevoir et livrer une boucle autonome de qualité production, durcie, qui tourne sans surveillance jusqu'à un résultat vérifié.
Programme
Orientation — du prompt à la boucle
Situe le loop engineering dans la progression prompt → contexte → boucle → harness, installe ton labo de boucles dans Claude Code, et regarde ta première boucle itérer toute seule jusqu'à un résultat.
- Pourquoi la boucle est la nouvelle unité de travail
- Ton labo de boucles : installer Claude Code
- Première victoire — regarde une boucle itérer
Anatomie d'une boucle qui marche
Démonte la boucle une itération à la fois — ce que le modèle voit à chaque tour, ce que chaque tour coûte, à quel moment les itérations supplémentaires cessent d'aider — et construis une vraie boucle ReAct instrumentée sur une tâche de code.
- Les quatre temps : agir, observer, décider, recommencer
- Construis ta première vraie boucle
- Coût par itération : ce que chaque tour coûte vraiment
- Saturation sémantique : quand itérer encore n'apporte plus rien
- Lire une trace comme un ingénieur
Arrêt et convergence
Apprends à ta boucle quand s'arrêter. Arrêts durs (nombre d'étapes max, plafonds de budget), arrêts souples (seuils de confiance, détection de point fixe), et la frontière entre quitter trop tôt et partir en vrille.
- Le problème de l'arrêt
- Arrêts durs : nombre d'étapes max et plafonds de budget
- Arrêts souples : confiance et détection de point fixe
- Intègre la logique d'arrêt dans ta boucle
- Révision cumulative : tout jusqu'à l'arrêt
Réflexion et auto-correction
Construis des boucles qui repèrent et corrigent leurs propres erreurs. Générer → critiquer → réviser, retour interne ou validé par un outil, et le piège de la sur-réflexion où la critique ne fait que cramer des itérations.
- Des boucles qui se critiquent elles-mêmes
- Retour interne ou validé par un outil
- Le piège de la sur-réflexion
- Construis une sous-boucle d'auto-correction
- Synthèse du module : une réflexion qui rapporte
La vérification dans la boucle
Arrête de croire l'agent sur parole. Branche une vraie vérification — tests, linters, contrôles de types — dans la boucle pour qu'elle valide son propre travail avant de sortir, avec retour arrière quand un contrôle échoue.
- Fais confiance, mais vérifie chaque étape
- De vrais garde-fous : tests, linters, types
- Contrôle déterministe ou stochastique
- Retour arrière et score de confiance
- Construis une boucle qui se vérifie elle-même
Modes d'échec et débogage
Nomme chaque façon dont une boucle casse — oscillation, agitation stérile, dérive, fausse réussite — instrumente la boucle avec des signaux étape par étape, et apprends à diagnostiquer et réparer chaque échec à partir de sa trace.
- La taxonomie des échecs de boucle
- Instrumenter la boucle : voir à l'intérieur
- Diagnostiquer les échecs à partir des signaux
- Casse-la exprès, puis répare-la
- Révision cumulative : réflexion, vérification, échecs
Coût et contrôle
Fais du coût une contrainte de conception à part entière. Stratégies de sortie anticipée, budgets d'itérations, niveau de modèle par étape et mise en cache — réduire la facture d'une boucle sans perdre le résultat.
- Le vrai prix d'une boucle
- Sortie anticipée et budgets d'itérations
- Niveau de modèle par étape et mise en cache
- Règle le compromis coût–qualité
Des boucles qui tournent pendant que tu dors
Franchis le seuil de l'autonomie. Points de reprise, redémarrage et progression durable ; composer arrêt, correction, vérification, garde-fous et budgets en une boucle à qui tu fais confiance sans surveillance — et savoir quand passer la main à un harness.
- Le seuil de l'autonomie
- Points de reprise, redémarrage et progression durable
- Compose la boucle de confiance qui tourne sans surveillance
- Quand passer la main à un harness
Projet final — Concevoir une boucle autonome de qualité production
Conçois, construis, instrumente et durcis une vraie boucle autonome de bout en bout — en intégrant arrêt, auto-correction, vérification, garde-fous et contrôle du coût — et prouve qu'elle tourne sans surveillance jusqu'à un résultat vérifié.
- Le brief et ton document de conception de boucle
- Construire, instrumenter, durcir
- Prouve qu'elle tourne sans surveillance
Cursus IA Loop Engineering
Atteste que tu sais concevoir la boucle autonome d'un agent de bout en bout — arrêt, auto-correction, vérification, diagnostic des échecs, contrôle du coût et fonctionnement sans surveillance — et en livrer une qui tourne jusqu'à un résultat vérifié.
Ta boîte à outils IA
Le loop engineering ne dépend d'aucun outil précis, mais tu vas t'entraîner sur un vrai agent de code. Tout ce qu'on voit ici marche dans Claude Code ; les schémas se transposent à Cursor, à l'API brute ou à ton propre harness.
Tu peux faire tout le cursus avec un abonnement Claude Pro à environ 20 €/mois, plus quelques euros de crédits API pour les exercices programmatiques. Aucun outil d'observabilité payant n'est nécessaire.
About This Degree
À propos de ce cursus
Tous les cours sur les agents t’apprennent à démarrer un agent. Presque aucun ne t’apprend à rendre sa boucle fiable. C’est là qu’est le vrai trou. Tu as sûrement déjà vu un agent de code caler en plein milieu, crier victoire sur du code cassé, ou s’acharner quarante étapes après le moment où c’était fini — et tu es resté là à le relancer à la main, parce que la boucle n’avait pas été conçue pour faire mieux. La « boucle » — le cycle où l’agent agit, observe le résultat, décide de la suite et recommence jusqu’à ce que le travail soit fait — c’est la vraie unité de travail de l’IA agentique, et c’est la seule chose que les cours sautent. Ce cursus ne parle de rien d’autre.
Tu construis une seule boucle, et elle grandit avec toi. Au module 1, ce n’est qu’une boucle ReAct toute simple qui corrige un test en échec. Au module 2, elle s’arrête à la bonne étape au lieu de la valeur par défaut. Au module 3, elle critique et répare ses propres erreurs ; au module 4, elle lance ta suite de tests et refuse de sortir tant que c’est rouge. Le module 5 la durcit contre les façons dont une boucle casse — oscillation, agitation stérile, dérive, fausse réussite — grâce à des signaux que tu apprends à lire dans la trace. Le module 6 réduit son coût sans perdre le résultat, et le module 7 lui fait franchir le seuil de l’autonomie pour qu’elle tourne sans surveillance, avec des points de reprise et un redémarrage possible. Le projet final, c’est cette boucle, terminée : qualité production, documentée, et prouvée capable de tourner pendant que tu dors.
Ce que tu deviens, c’est un loop engineer — la personne qui peut donner un objectif à un agent et lui faire vraiment confiance pour aller au bout. Pas parce que le modèle est devenu plus malin, mais parce que tu as conçu le cycle autour de lui : où il s’arrête, comment il se vérifie, ce qu’il fait quand une étape échoue, et ce que ça coûte. C’est la compétence qui prend de la valeur quand les modèles s’améliorent, au lieu d’être effacée par eux. À la fin, « laisse l’agent gérer ça cette nuit » cesse d’être un pari et devient quelque chose que tu as conçu.
Prerequisites
C'est un cursus avancé et 100 % pratique. Il part du principe que tu connais déjà ReAct, la réflexion et l'usage d'outils comme concepts — ces cours posent les bases pour qu'on puisse sauter l'introduction et passer directement à l'ingénierie de la boucle elle-même.
