Claude Code pendant la nuit : le loop engineering et Ralph Loop en 2026

Documentation de référence Ailoot : ailoot.ai/docs/.

Qu’est-ce que le loop engineering avec Claude Code ?#

Sa deuxième déclaration donne une idée de l’ampleur :

Ces déclarations révèlent un nouveau rôle d’ingénieur : vous êtes l’architecte des boucles, pas un opérateur au clavier.

La suppression des citations issues de sources non officielles empêche de conserver cette attribution et ce résumé de l’approche.

Faites-le une fois aujourd’hui, et chaque jour les prospects se multiplient, les articles sont publiés automatiquement, le bot traite les échanges et le rapport de métriques arrive sur votre bureau à 9 h. Vous le construisez une fois, puis il fonctionne tous les jours sans vous.

Si vous ouvrez encore Claude Code, écrivez un prompt, attendez, lisez le résultat et écrivez un autre prompt, vous passez à côté du plus grand changement de 2026. Les modèles sont désormais assez puissants pour travailler en boucle sans supervision.

En quoi Ralph Loop diffère d’une requête Claude Code classique#

Au cœur de cette technique se trouve une simple boucle bash autour d’un agent :

Le code d’origine qui a lancé toute la vague :

while :; do cat PROMPT.md | claude-code ; done

Un prompt dans un fichier, avec une boucle infinie autour. Et le commentaire le plus franc de l’auteur :

Anthropic a intégré cette même logique dans le plugin ralph-loop et dans les commandes /loop, /goal et /batch de Claude Code. Elles sont disponibles directement dans le terminal, sans scripts. Le simple fait qu’Anthropic ait publié un plugin permettant de relancer les prompts à l’infini a déclenché un débat dans GitHub Issue #23084 : est-ce équitable pour le modèle ? Le débat est ouvert ; le plugin fonctionne.

Trois commandes intégrées à Claude Code : /loop, /goal, /batch#

/goal est la commande qui ressemble le plus à Ralph Loop. En coulisses, un modèle évaluateur (Haiku par défaut) vérifie à chaque tour si l’objectif est atteint. Si ce n’est pas le cas, l’itération suivante inclut une indication précise sur ce qu’il faut corriger. Si c’est le cas, la boucle s’arrête. J’ai présenté /goal en détail dans le guide sur l’exécution autonome de Claude Code pendant la nuit avec /goal, qui comprend des scénarios prêts à l’emploi pour 14 heures de travail.

/batch est une commande rare, mais puissante. Si vous devez effectuer le même changement dans plus de 100 fichiers (migration d’API, remplacement de composants, renommage), /batch envoie chaque fichier à un sous-agent distinct, dans son propre git worktree. Les changements n’entrent pas en conflit, car chaque agent travaille dans une copie isolée. Pour en savoir plus sur les sous-agents, consultez le guide sur les sous-agents imbriqués.

Dans la description de cette approche par l’auteur, cela s’appelle simplement :

Limites strictes de /loop et /goal :

• Une tâche s’exécute tant que Claude Code reste ouvert. Fermez le terminal et la boucle s’arrête. Pour un cycle nocturne sérieux, utilisez un serveur distant ou votre propre wrapper shell.
• La durée de vie maximale d’une tâche récurrente est de 7 jours (après quoi elle est automatiquement supprimée pour éviter que des boucles oubliées continuent de tourner).
• Jusqu’à 50 tâches simultanées dans une session.

Vous voulez mettre en place un système qui rende Claude fiable ? Ralph Loop n’en est qu’un élément. Il est utile de prendre en compte les trois composants : clone IA + Second Brain + Context Engineering. Ensemble, ils transforment Claude, d’un « assistant qui hallucine », en un outil auquel vous pouvez confier une tâche avant de vaquer à vos occupations.

Comment lancer votre première boucle autonome en 5 minutes#

5 étapes :

1. Ouvrez le projet dans Claude Code

   Dans le terminal, accédez à la racine du projet et exécutez claude. Attendez que Claude lise CLAUDE.md et indexe le dépôt.

2. Définissez un objectif et une condition d’arrêt

   L’objectif indique ce qu’il faut faire. La condition d’arrêt indique à Claude comment savoir que le travail est terminé. Idéalement, il s’agit d’une commande qui renvoie 0 ou 1. Exemple : « Objectif : les 23 tests dans tests/api/*.test.ts doivent réussir. Arrête-toi lorsque pnpm test renvoie le code de sortie 0. »

3. Lancez /goal

   Commande :

   /goal Tous les tests dans tests/api/*.test.ts doivent réussir. Exécute pnpm test, lis les erreurs, corrige-les et relance la commande. Arrête-toi lorsque le code de sortie = 0. Maximum 20 itérations.
   

   Claude lance la boucle : exécute les tests, constate un échec, ouvre le fichier, corrige le problème et relance les tests.

4. Fixez une limite de budget

   Dans un onglet en arrière-plan, utilisez /usage pour surveiller la consommation. Définissez une limite de tokens ou d’argent pour la journée afin de ne pas épuiser tout votre solde dans une seule boucle. Plus de détails dans le guide sur la façon d’éviter d’épuiser les limites de Claude Code.

5. Vaquer à vos occupations

   Revenez dans 30 minutes. Si la tâche est simple, le message indiquera déjà « DONE, tous les tests passent ». Si elle est plus complexe, lisez le compte rendu : « arrêt à l’itération 20, raison X ». Corrigez à la main ce que la boucle n’a pas réussi à faire, puis relancez-la.

Schéma avec vérificateur : comment Claude vérifie son propre travail en boucle#

Il existe trois types de vérificateurs :

1. Technique (code de sortie) — le plus fiable. pnpm test, npm run lint, tsc --noEmit, playwright test. Ils renvoient 0 ou 1, sans interprétation nécessaire. /goal fonctionne aussi de cette façon : en coulisses, il utilise le modèle évaluateur Haiku qui vérifie à chaque tour si la condition est remplie (jusqu’à 4000 caractères).

2. Modèle évaluateur — un second modèle examine le résultat du premier et le note selon une grille d’évaluation. C’est utile pour les tâches sans vérification formelle (« Le style d’écriture est-il bon ? » « Le design correspond-il à la marque ? »). Chez Anthropic, cela s’appelle Claude Code Review : un mode dans lequel un agent de relecture distinct recherche les erreurs de logique, les cas limites et les problèmes de sécurité dans le travail de l’agent principal. Selon les données internes d’Anthropic, il détecte 84 % des problèmes sur les grandes PR (contre 16 % avec l’approche de référence).

3. Vérification personnalisée — un script shell que vous écrivez vous-même. « Si les logs ne contiennent pas le mot ERROR, c’est terminé. » « Si le fichier output.json existe et peut être analysé, c’est terminé. » « Si la page /pricing renvoie le statut 200, c’est terminé. »

Dans l’approche de l’auteur, les compétences comprennent une étape contradictoire distincte pour Claude après chaque phase. Voici un modèle de prompt que j’insère dans CLAUDE.md ou dans une commande :

Trouve 10 raisons pour lesquelles ce projet aurait pu complètement dérailler. 
Mets-toi dans la situation où quelque chose a mal tourné. 
Je peux repasser cette histoire en revue de nombreuses fois – 
avant de la publier.

L’erreur de débutant la plus fréquente est de lancer une boucle sans vérificateur. L’agent tourne en rond : il écrit du code, ne le vérifie pas, croit avoir terminé, passe à l’itération suivante et réécrit ce qu’il a déjà fait. Trois heures plus tard, c’est le chaos et la facture s’élève à 200 $.

La meilleure règle : écrivez d’abord le vérificateur, puis lancez la boucle. Si vous ne pouvez pas formuler la condition d’arrêt en une ligne, la tâche n’est pas prête à être automatisée.

Comment ne pas faire exploser son budget pendant la nuit : plafonds et conditions d’arrêt#

Trois freins indispensables pour toute boucle nocturne :

1. Limite d’itérations. --max-iterations 20. La boucle ne peut pas s’exécuter plus de N fois, même si le vérificateur ne se déclenche pas. Si la condition d’arrêt n’est pas atteinte après 20 itérations, la tâche est bloquée et nécessite une intervention humaine.

2. Limite de tokens ou d’argent. /usage limit 50 — pas plus de 50 $ par jour. À l’approche de la limite, la boucle s’arrête d’elle-même et envoie une alerte. Cela protège contre un scénario incontrôlé.

3. Contrôle de progression avec contrat explicite. La comparaison de HEAD ci-dessous détecte des commits, pas tous les changements. Utilisez-la seulement dans un worktree isolé où chaque itération modifiant le code crée un commit local de checkpoint avant comparaison. Des changements utiles non commités ne changent pas HEAD et peuvent sembler stagnants. Conservez aussi le résultat du vérificateur : un commit prouve un changement enregistré, pas une amélioration ou une réussite.

Voici une structure illustrative avec ces contrôles. Les lignes de coût et d’invocation de l’agent sont propres au lanceur, sans constituer une recette CLI vérifiée : confirmez leurs interfaces pour la version installée. Exigez un commit local de checkpoint pour chaque itération modifiant le code. Si des changements restent non commitées, arrêtez pour revue au lieu de conclure à l’absence de progrès.

#!/bin/bash
PROMPT="$1"
MAX_ITER=20
MAX_COST_USD=50
COMPLETION="DONE"
PREV_HASH=""
STAGNATION=0

for i in $(seq 1 $MAX_ITER); do
  # Money limit
  CURRENT_COST=$(claude usage --json | jq '.cost_usd')
  if (( $(echo "$CURRENT_COST > $MAX_COST_USD" | bc -l) )); then
    echo "STOP: budget cap $MAX_COST_USD reached"
    break
  fi

  # Run
  OUTPUT=$(claude code -p "$PROMPT" --auto-accept)

  # Completion check
  if echo "$OUTPUT" | grep -q "$COMPLETION"; then
    echo "STOP: completion signal"
    break
  fi

  # Progression des commits : chaque itération modifiant le code doit créer un checkpoint.
  # HEAD ne détecte pas les modifications utiles encore non commitées.
  CURRENT_HASH=$(git rev-parse HEAD 2>/dev/null)
  if [ "$CURRENT_HASH" = "$PREV_HASH" ]; then
    STAGNATION=$((STAGNATION + 1))
    if [ "$STAGNATION" -ge 3 ]; then
      echo "STOP: stagnation 3 iterations"
      break
    fi
  else
    STAGNATION=0
  fi
  PREV_HASH="$CURRENT_HASH"
done

Validez le contrôle avant extension : une modification sans commit est du travail non enregistré ; un checkpoint change HEAD ; seul le vérificateur distinct établit la réussite. Trois commits inchangés signifient aucune modification enregistrée sous ce contrat, sans prouver que tous les fichiers sont inchangés. Ensuite, vous pouvez ajouter une alerte Slack à l’arrêt, un rapport Telegram automatique le matin ou une notification push lorsque le budget atteint 80 %. Le principe reste le même : une boucle a besoin de freins, pas seulement d’un accélérateur.

5 scénarios de boucles nocturnes prêts à l’emploi#

Scénario 1 : Faire passer les tests en échec

/goal Il y a 47 tests en échec dans le répertoire tests/. Objectif : les faire tous réussir.
Exécute pnpm test, lis stderr, ouvre le fichier contenant l’erreur, corrige-la et relance pnpm test.
Arrête-toi lorsque le code de sortie est 0. Maximum 30 itérations.

Scénario 2 : Refactoring à grande échelle dans 200 fichiers

/batch Remplace l’ancien client API apiV1 par le nouveau apiV2 dans tous les fichiers sous src/**/*.ts.
Chaque fichier dispose de son propre worktree. Après le remplacement, exécute tsc --noEmit et corrige les erreurs éventuelles.
Fusionne les worktrees à la fin.

Scénario 3 : Surveillance de production pendant la nuit

/loop 30m Toutes les 30 minutes, vérifie https://your-app.example.com/api/health.
Si la réponse n’est pas 200, lis les logs, trouve la cause, corrige-la et redéploie.
Consigne chaque itération dans /tmp/night-monitor.log.

Scénario 4 : Importer un grand jeu de données avec déduplication

/goal Importe le fichier CSV /tmp/import.csv (12,000 lignes) dans la table clients.
Pour chaque ligne, vérifie si un doublon existe en utilisant l’adresse e-mail ; s’il n’y en a pas, insère-la ; s’il y en a un, mets-le à jour.
Consigne les conflits dans /tmp/conflicts.log. Arrête-toi lorsque la dernière ligne a été traitée.

Scénario 5 : Pipeline d’articles (configuration typique)

Pour un service en ligne ou une agence qui a régulièrement besoin d’articles SEO, le scénario est le suivant :

/loop 8h Toutes les 8 heures : ouvre le fichier de backlog des sujets dont le statut est 'queued'.
Si un sujet est disponible, exécute la compétence de rédaction d’un guide.
Publie sur dev. Remplace le statut par 'review'. Préviens la personne responsable dans Telegram.

Que fournir à chaque itération : CLAUDE.md et le Second Brain comme état#

Trois couches de « mémoire » du projet transforment un prompt ponctuel en une boucle contrôlée :

1. CLAUDE.md — la constitution du projet. Ce qu’est le produit, quelle est la stack, quelles sont les règles et ce qui ne doit jamais être fait. Claude lit ce fichier au début de chaque session et de chaque itération de la boucle. Sans lui, Claude doit « rouvrir » le projet à chaque fois, ce qui consomme du contexte et augmente le risque d’hallucinations. Vous trouverez un modèle prêt à l’emploi et 6 règles dans le guide CLAUDE.md.

2. Second Brain — un dossier de connaissances métier : produit, public, objectifs, économie, marketing. Pas du code, mais du sens. Lorsque la boucle rédige un article ou cherche une réponse pour le support, elle consulte le Second Brain et répond en tenant compte du contexte du projet, plutôt qu’à partir de rien.

3. Context Engineering — ce que vous fournissez exactement à Claude à chaque itération. Ni tout le dossier Second Brain ni l’ensemble du dépôt, mais uniquement les éléments pertinents. Plan Mode aide : Claude détermine les fichiers nécessaires à la tâche et ne lit que ceux-là. Pour en savoir plus, consultez le guide Plan Mode.

Le principal principe opérationnel que j’ai dû faire entrer à coups d’erreurs :

Ces trois couches constituent les trois piliers de la méthode : clone IA (vous avez appris à Claude votre style et vos règles au moyen des compétences et de CLAUDE.md), Second Brain (le contexte métier dans des fichiers) et Context Engineering (ce que vous fournissez dans chaque requête). Sans ces trois éléments, la boucle devient un cycle sans fin dont la facture ne cesse d’augmenter.

Boucles autonomes : terminaux, sessions et agents en parallèle#

Que se passe-t-il dans chaque session ? Des tâches différentes : une boucle corrige des bugs, une autre écrit de nouvelles fonctionnalités, une troisième examine les PR de l’équipe, une quatrième optimise les performances et une cinquième prépare la documentation. Pas un seul agent généraliste de grande taille, mais des dizaines d’agents spécialisés, chacun avec sa compétence, son objectif et son vérificateur.

Le changement de perspective clé :

Pour un entrepreneur sans programmeurs, cela a une application concrète. Vous avez un compte Claude à 200 $/mois et un ordinateur portable ordinaire. Vous pouvez lancer 5 boucles en parallèle : support, articles, métriques, test d’un nouveau produit et surveillance des concurrents. Chacune tourne dans son propre onglet Claude Code. Le matin, vous lisez le résumé. C’est déjà la norme de travail à l’été 2026.

Quatre échecs fréquents des boucles autonomes#

Échec 1 : « boucle d’hallucination »

L’agent décide qu’il a terminé alors que le vérificateur ne s’est pas déclenché. Ou il n’y a aucun vérificateur. Trois heures plus tard, Claude dit : « Tout est terminé ! », mais les tests échouent, la page ne s’ouvre pas et rien ne fonctionne. Vous avez déjà dépensé 80 $ en itérations inutiles.

Solution : un vérificateur strict (le exit code de la commande), pas une vérification verbale.

Échec 2 : « budget épuisé pendant la nuit »

Sans plafond budgétaire, une boucle est une grenade sans goupille.

Solution : /usage limit ou un script externe utilisant claude usage --json pour arrêter la boucle lorsqu’elle atteint un seuil.

Échec 3 : « la boucle a perdu le contexte entre les itérations »

À l’itération 1, Claude a pris une décision d’architecture. À l’itération 7, il l’avait oubliée et a pris la décision opposée. Après 15 itérations, le code est un véritable fouillis.

Solution : une couche d’état avec CLAUDE.md et le dossier Second Brain. La boucle écrit chaque décision d’architecture dans un fichier qu’elle lit à l’itération suivante.

Échec 4 : « la condition d’arrêt est imprécise : la boucle tourne sans fin »

`/goal