Table of Contents

Retour au cours pratique sur les flux de travail avec l’IA

Une boucle d’objectif répète le travail jusqu’à ce qu’un résultat défini réussisse un contrôle ou qu’une règle d’arrêt se déclenche. Une boucle utile lit l’état actuel, effectue une action limitée, vérifie le résultat et consigne ce qui s’est passé. Une consigne ouverte comme « continuez d’essayer » ne définit aucune règle d’achèvement fiable.

Objectif d’apprentissage : vous exécuterez une boucle de laboratoire bornée avec un contrôle connu pour échouer et consignerez la décision d’arrêt.

Points clés

  • Objectif : un résultat décrit en termes observables.
  • État : les fichiers, résultats, erreurs et révision du code source actuels.
  • Contrôle : un test ou une revue lié à l’objectif.
  • Budget de nouvelles tentatives : le nombre maximal d’essais autorisés pour un échec.
  • Règle d’arrêt : une condition qui impose de terminer ou de demander une décision humaine.

Avant de commencer

Prérequis : le dossier de tâche , le rapport de vérification et la leçon sur la délégation . Prévoyez 45 minutes. La difficulté est intermédiaire. Utilisez une nouvelle copie du laboratoire synthétique afin de connaître à l’avance le premier contrôle qui échouera.

Rédiger le contrat de boucle

Pour la demande de filtre par statut, définissez le contrat avant toute nouvelle tentative :

Objectif : prendre en charge --status open|done sans modifier la sortie par défaut.
Source : docs/requirements.md, révision 1.
Fichiers autorisés : task_report.py et tests ciblés.
Vérifications : tests unitaires, comptes 4/2/2, valeur invalide avec un code de sortie non nul.
Budget de nouvelles tentatives : deux modifications au maximum après le premier essai.
Arrêt immédiat : conflit avec la source, modification inattendue d’un fichier, exposition d’un secret,
ou échec initial sans rapport avec cette demande.
Transmission : signaler le diff final, les commandes, les résultats, les essais et le problème non résolu.

Le budget est une règle de la tâche, pas une valeur par défaut du produit. Deux nouvelles tentatives suffisent pour diagnostiquer une petite tâche de laboratoire sans masquer des échecs répétés. Une tâche de production exige son propre choix en matière de risque et de revue.

Utiliser un tableau d’état

ÉtapeÉtat à consignerDécision
LireRévision du code source et résultat initialArrêter si l’état de départ diffère
AgirFichiers modifiés et action effectuéeRejeter les changements hors périmètre
ContrôlerTest exact et résultat manuelAccepter ou diagnostiquer
RéessayerCause de l’échec et nouvelle hypothèseContinuer uniquement dans la limite du budget
TransférerÉtat final et prochain responsableArrêter après réussite ou blocage

Consignez chaque tentative, pas seulement le dernier message. Un test qui réussit après trois modifications non consignées n’explique pas les changements. Tenez un journal bref de l’échec, de l’hypothèse révisée et des nouveaux éléments de preuve.

Examiner un échec

Exemple de première tentative : l’agent ajoute le filtrage et les tests. open affiche 2, mais --status invalid affiche 0 et se termine normalement. L’exigence demande un code de sortie non nul pour une valeur invalide. Marquez le contrôle comme échoué.

Diagnostic : inspectez la validation des arguments. L’agent a traité une valeur inconnue comme un résultat vide au lieu de la signaler comme erreur. Demandez une correction limitée qui valide les valeurs acceptées avant le comptage. Relancez le cas invalide et tous les contrôles précédents.

Essai 1 : le statut invalide a réussi, donc l’acceptation a échoué.
Cause trouvée : aucune validation des valeurs acceptées.
Demande pour l’essai 2 : rejeter les valeurs non prises en charge et conserver les comptes 4/2/2.
Preuves requises : exécution complète des tests et code de sortie de la commande invalide.

Résultat attendu à la deuxième tentative : une erreur claire et un code de sortie non nul pour invalid, sans changement des comptes valides. Si la deuxième tentative échoue encore, ne faites la dernière tentative qu’après avoir identifié une nouvelle cause. Répéter la même demande ne constitue pas un diagnostic.

Gérer les résultats ambigus

Un processus qui s’arrête sans résultat n’a pas réussi. Si un outil expire après une éventuelle écriture, inspectez les fichiers et l’état de Git avant de le relancer. Si un service connecté signale un résultat inconnu, lisez son état actuel avant de répéter une action externe. Hors du laboratoire, les envois, publications ou écritures en double présentent un risque réel.

Arrêtez-vous pour demander une revue humaine si l’exigence contredit une autre source approuvée, si une autorisation bloque l’action, si le budget de nouvelles tentatives est épuisé ou si l’action demandée dépasse une limite de publication. Le transfert indique l’état exact et la décision en attente.

Distinguer les boucles des moniteurs

Une boucle de modification s’exécute dans le cadre d’une tâche limitée et vérifie le résultat après chaque action. Un moniteur planifié se réveille plus tard pour examiner une condition. Un moniteur a besoin de sa propre fréquence, d’un seuil de changement, d’une règle de notification et d’une condition d’arrêt. Ne transformez pas la boucle de modification du laboratoire en tâche récurrente. La leçon suivante évalue les systèmes persistants avant leur activation.

Exécuter une boucle contrôlée

Commencez avec le laboratoire intact. Ses deux tests de base réussissent. Dans la nouvelle extraction, créez tests/test_loop_contract.py avec le contrôle ci-dessous. Ce fichier exprime une fonctionnalité souhaitée qui manque dans le projet de départ. Il ne fait pas partie de l’archive ZIP de départ maintenue.

"""One controlled failing check for the status-filter exercise."""

import subprocess
import sys
import unittest
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]


class LoopContractTests(unittest.TestCase):
    def test_open_status_count(self):
        result = subprocess.run(
            [sys.executable, str(ROOT / "task_report.py"),
             str(ROOT / "tasks.json"), "--status", "open"],
            capture_output=True, text=True, check=False,
        )
        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertEqual(result.stdout.strip(), "Total tasks: 2")


if __name__ == "__main__":
    unittest.main()

Exécutez python3 -m unittest discover -s tests -v. Les deux tests d’origine devraient réussir et le nouveau test contractuel devrait échouer, car le projet de départ ne gère pas --status. Consignez l’échec réel. Si vous avez initialisé Git comme indiqué dans la leçon 0, consignez aussi git status --short. Sinon, comparez les fichiers modifiés à une extraction intacte. Sous Windows, utilisez py -3 si votre configuration passe par le lanceur.

Fixez un budget de trois tentatives : la première modification et deux corrections au maximum. Donnez le contrat de boucle ci-dessus à votre agent et demandez une seule modification limitée. Après chaque tentative, inspectez les fichiers modifiés, relancez tous les tests et exécutez les commandes par défaut, open, done et valeur invalide. Consignez la cause de l’échec avant toute autre tentative. Arrêtez-vous après une réussite, un échec de référence sans rapport avec la demande, un changement hors périmètre ou le troisième échec.

Parcours d’étude : après avoir consigné le test rouge, appliquez la solution complète de la leçon 5 dans cette nouvelle copie. Relancez les mêmes contrôles et indiquez que la modification par l’agent n’a pas été exécutée. Conservez le test contractuel contrôlé. Ne l’affaiblissez pas et ne le supprimez pas pour le faire réussir.

TentativeÉtat et observationDécision
Avant la modificationLes deux tests de base réussissent et le nouveau contrôle open échoueContinuer avec une modification limitée
Après chaque modificationConsigner les tests exacts, les comptes, le code de sortie invalide et les fichiers modifiésAccepter, diagnostiquer ou arrêter
À la fin du budgetConsigner l’échec restant et le diff actuelTransférer sans nouvelle tentative

S’entraîner et vérifier

Votre livrable : le test contrôlé qui échoue, les résultats observés avant et après, un journal des tentatives et une décision finale d’acceptation ou d’arrêt. Si la première modification réussit, consignez une tentative. N’inventez pas un deuxième échec pour remplir le journal.

Contrôle de fin : le contrat nomme une source, un périmètre de fichiers, des contrôles observables, une limite de nouvelles tentatives, au moins une condition d’arrêt immédiat et un transfert. Votre journal contient le véritable test rouge, les résultats des contrôles ultérieurs et soit une réussite, soit un arrêt dû au budget. Une deuxième tentative nomme une nouvelle cause et diffère de la première.

Vérifier votre compréhension

  1. Question : que prouve le premier test contractuel rouge ? Réponse : le projet de départ n’a pas le filtre de statut demandé, comme le montre un test écrit avant la modification.
  2. Question : quand la boucle doit-elle s’arrêter même s’il reste des tentatives ? Réponse : en cas de changement hors périmètre, d’autorisation incertaine ou d’exigence contradictoire.

Dépannage

  • La boucle répète le même échec : arrêtez-vous et formulez une nouvelle hypothèse sur la cause.
  • Les contrôles s’affaiblissent : rétablissez les critères d’acceptation d’origine.
  • Résultat externe incertain : inspectez l’état actuel avant une nouvelle tentative.
  • Budget épuisé : transférez le journal d’échec au lieu de le masquer.

Étapes suivantes

Poursuivez avec l’optionnelle Évaluation des agents spécialisés ou passez directement au projet final du cours sur les flux de travail avec l’IA . Pour comparer les environnements d’exécution, consultez le guide des environnements d’agents .

Navigation du cours : Précédent : délégation d’agents , Plan du cours .