Comment créer votre première boucle IA en 2026

Deux des ingénieurs en IA les plus seniors au monde ont dit la même chose le mois dernier.

Peter Steinberger, créateur d'OpenClaw, désormais chez OpenAI :

« Vous ne devriez plus écrire de prompts pour des agents de codage. Vous devriez concevoir des boucles qui font les prompts à votre place. »

Boris Cherny, responsable de Claude Code chez Anthropic :

« Je ne fais plus de prompts pour Claude. J'ai des boucles qui tournent, qui font les prompts pour Claude et décident quoi faire. Mon travail, c'est d'écrire des boucles. »

La plupart des gens ont lu ça et se sont demandé : qu'est-ce que ça signifie concrètement ?

Et surtout : comment en construire une ?

Cet article vous explique exactement comment faire.

Pas de théorie sans code. Pas de code sans contexte. Des vraies étapes. Des vraies commandes. Copiez et exécutez.

Slate orchestrant GPT-5.6, Claude et des sous-agents spécialisés sur une tâche de migration réelle. Le modèle est devenu plus intelligent. Le changement le plus important, c'est que des outils comme Slate peuvent enfin garder ces modèles occupés en continu, au lieu d'attendre des prompts humains.

La façon dont la plupart des gens utilisent l'IA est déjà obsolète

Écrire un prompt. Attendre. Lire le résultat. Corriger manuellement. Écrire un autre prompt.

C'est vous qui êtes la boucle.

Chaque étape passe par vous. L'IA attend. Vous décidez. L'IA attend à nouveau.

Dès que vous vous arrêtez, tout s'arrête.

Les développeurs qui avancent le plus vite en 2026 n'écrivent pas de meilleurs prompts.

Ils construisent des systèmes qui font les prompts à leur place.

Le point de levier a changé.

Passer de « écrire des prompts » → à « concevoir des boucles ».

Qu'est-ce qui a changé avec GPT-5.6 ?

GPT-5.6 ne change pas le besoin de boucles.

Il augmente leur valeur.

Plus le modèle est performant, plus il devient coûteux de le laisser inactif entre les prompts.

Dans les workflows en terminal, GPT-5.6 est nettement meilleur pour :

→ comprendre de grandes bases de code

→ maintenir la cohérence de l'implémentation

→ suivre des plans en plusieurs étapes

→ se remettre des tentatives échouées

→ agir comme un vérificateur strict

Le résultat n'est pas un « meilleur prompting ».

C'est moins d'interventions humaines par tâche.

Ce qu'est réellement une boucle

Définition simple :

Un prompt répond une fois et s'arrête.

Une boucle continue de travailler jusqu'à ce que le travail soit réellement terminé.

Pas jusqu'à ce qu'elle génère une réponse.

Jusqu'à ce qu'elle atteigne un résultat vérifié.

Tout agent d'IA sérieux exécute le même cycle sous-jacent :

→ Découvrir — que faut-il faire ?

→ Exécuter — faire le travail

→ Vérifier — est-ce que ça a réellement fonctionné ?

→ Itérer — pas fini ? corriger et recommencer

→ Arrêter — condition remplie, ou limite stricte atteinte

Claude Code. Cursor. Codex.

En dessous, ils exécutent tous cette boucle.

La différence entre un prompt et une boucle n'est pas le modèle.

C'est de savoir si quelque chose vérifie le travail et continue jusqu'à ce qu'il soit validé.

Le test des 4 conditions — exécutez ceci avant de construire quoi que ce soit

La plupart des boucles échouent ici.

Une boucle ne mérite son coût de mise en place que lorsque les 4 conditions sont réunies.

Si une seule manque, la boucle coûte plus qu'elle ne rapporte.

1. La tâche se répète. Au moins une fois par semaine. Une tâche unique est toujours mieux servie par un bon prompt.

2. La vérification est automatisée. Quelque chose doit pouvoir faire échouer le travail sans que vous soyez dans la pièce. Tests. Linters. Builds. Vérifications de type. Pas de barrière = l'agent note son propre devoir.

3. Votre budget de tokens peut absorber le gaspillage. Les boucles relisent le contexte complet à chaque itération. Elles réessayent, explorent, brûlent des tokens, que l'exécution livre quelque chose ou non. C'est le coût dont personne ne parle.

4. « Fini » est objectif. Un test qui réussit ou échoue. Un build qui compile ou non. Pas « quand ça a l'air bon ». Si « fini » nécessite un avis humain, gardez-le en manuel.

Toutes les 4 remplies → construisez la boucle.

Une seule manquante → utilisez un prompt à la place.

La version honnête : la plupart des développeurs n'ont pas encore besoin de boucles lourdes. Ce dont tout le monde peut profiter, c'est d'une boucle simple. Nous allons en construire une dans un instant.

Installer Slate

Slate est un agent de codage IA conçu exactement pour cela — exécuter de longues tâches parallèles en plusieurs étapes dans votre terminal.

Construit par RandomLabs. Le premier agent conçu spécifiquement pour l'orchestration en essaim.

Ce qui le rend différent de Claude Code ou Cursor :

→ Sélectionne automatiquement le bon modèle pour chaque étape. Planifier avec Claude, chercher avec un autre, exécuter avec Codex — Slate décide.

→ Exécute des sous-agents parallèles simultanément sur votre base de code

→ Gère son propre contexte sur de longues sessions de plusieurs heures

→ Travaille avec vous — pas seulement pour vous

Installez-le en une ligne :

1npm i -g @randomlabs/slate

Naviguez vers votre projet et démarrez-le :

1cd /chemin/vers/votre/projet
2slate

Cela ouvre le TUI de Slate — une interface terminal où vous lui donnez des tâches et le regardez travailler.

Étape 1 — Configurer votre espace de travail

Avant que Slate puisse exécuter des boucles sur votre projet, il doit comprendre votre base de code.

Créez un fichier AGENTS.md à la racine de votre projet. C'est le contexte que Slate lit au début de chaque session.

1# AGENTS.md
2
3## Ce que fait cette base de code
4[Description du projet en un paragraphe]
5
6## Architecture
7- src/api/ — Routes API Express
8- src/services/ — Logique métier
9- src/db/ — Modèles de base de données (PostgreSQL via Prisma)
10- tests/ — Suite de tests Jest
11
12## Commandes clés
13- npm test — exécuter la suite de tests complète
14- npm run build — Compilation TypeScript
15- npm run lint — Vérification ESLint
16- npm run typecheck — tsc --noEmit
17
18## Règles
19- Ne jamais modifier src/billing/ ou src/auth/ sans approbation humaine
20- Toujours exécuter les tests avant de marquer une tâche comme terminée
21- Utiliser le modèle de gestion d'erreurs existant dans src/utils/errors.ts
22
23## Environnement
24- .env.slate contient toutes les variables d'environnement nécessaires à Slate

Slate lit ce fichier automatiquement au démarrage — pas besoin de le coller à chaque session.

Ajoutez vos répertoires de travail dans Slate :

1/workspace add ./src
2/workspace add ./tests
3/workspace list

Ou référencez des fichiers spécifiques en ligne en utilisant les mentions @ :

1Veuillez examiner @src/api/routes.ts et suggérer des améliorations

Étape 2 — Configurer Slate

Créez slate.json à la racine de votre projet pour contrôler le comportement de Slate.

1{
2  "$schema": "https://randomlabs.ai/config.json",
3  "permission": {
4    "*": "allow",
5    "bash": "ask"
6  },
7  "models": {
8    "main": { "default": "anthropic/claude-opus-4.6" },
9    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
10    "search": { "default": "anthropic/claude-haiku-4.5" },
11    "reasoning": { "default": "openai/gpt-5.6" }
12  }
13}

Ce que ça fait :

→ "*": "allow" — Slate peut lire et écrire des fichiers sans demander à chaque fois

→ "bash": "ask" — Slate demande avant d'exécuter des commandes shell (gardez ça jusqu'à ce que vous ayez confiance)

→ Configuration des modèles — modèle rapide et bon marché pour la recherche, modèle coûteux pour le raisonnement principal

Pour les exécutions CI ou automatisées où vous ne voulez aucune invite :

1slate run "Exécutez la suite de tests et corrigez tous les échecs" --dangerously-skip-permissions --output-format stream-json

Étape 3 — Votre première tâche (pas encore une boucle)

Avant de construire une boucle, assurez-vous qu'une seule exécution manuelle est fiable.

C'est l'étape la plus souvent ignorée. Et la raison pour laquelle la plupart des boucles échouent en production.

Donnez une vraie tâche à Slate :

1Veuillez examiner l'architecture de l'ensemble de ma base de code.
2Créez un fichier ARCH.md avec :
3- la structure actuelle
4- les dépendances entre les modules
5- 3 choses à améliorer
6Regardez d'abord @src/, puis @tests/

Regardez Slate travailler. Il va :

1. Rechercher dans vos fichiers
2. Comprendre l'architecture
3. Rédiger le fichier ARCH.md
4. Le vérifier par rapport à votre demande avant de s'arrêter

C'est déjà une mini-boucle — il vérifie sa propre sortie avant de terminer.

Pour une tâche plus longue :

1Hé Slate, analyse ma base de code pour le flux d'authentification,
2puis fais un plan pour ajouter le support OAuth2.
3Assure-toi de regarder @src/auth/ et @src/api/routes.ts

Slate renvoie un plan. Vous itérez dessus :

1Non, n'ajoute pas une nouvelle classe de fournisseur d'authentification.
2Fais en sorte qu'il suive le même modèle que l'ApiKeyAuth existant dans src/auth/api-key.ts

Approuvez le plan. Slate exécute de manière autonome.

Étape 4 — Créer une compétence (rendre la boucle réutilisable)

Une compétence (Skill) est la façon dont vous arrêtez de réexpliquer votre projet à chaque session.

Écrivez-la une fois. Slate la lit à chaque exécution pertinente.

Créez la structure de dossiers :

1mkdir -p .slate/skills/ci-triage
2touch .slate/skills/ci-triage/SKILL.md

Écrivez la compétence :

1---
2name: "ci-triage"
3description: "Classer les échecs CI par cause racine et rédiger des correctifs pour les plus simples."
4---
5
6# Compétence de Triage CI
7
8## Ce que je fais
9Quand une exécution CI échoue, je :
101. Lis la sortie des tests
112. Classe l'échec : problème d'env / test instable / vrai bug / mise à jour de dépendance / infra
123. Rédige des correctifs pour les bugs et les problèmes de dépendance
134. Escalade les problèmes d'env et d'infra aux humains
14
15## Règles de classification
16- env : secret manquant, mauvaise variable d'env → signaler à un humain
17- instable : réussit au réessai sans changement de code → réessayer une fois, puis créer un ticket
18- bug : échec déterministe lié à un commit récent → rédiger un correctif
19- dépendance : échec lié à un changement de version → rédiger une PR de rollback
20- infra : timeout, OOM, problème de runner → escalader immédiatement
21
22## Modèles de correctifs
23- Échecs de tests d'auth → vérifier src/auth/middleware.ts en premier
24- Échecs de tests de base de données → vérifier que la migration a été exécutée dans l'environnement CI
25- Échecs E2E → vérifier les sélecteurs UI par rapport au dernier snapshot
26
27## Ne jamais faire
28- Désactiver des tests qui échouent
29- Modifier la configuration CI sans demander
30- Toucher à src/billing/ ou src/payments/
31
32## État
33Mettre à jour STATE.md après chaque exécution :
34- Fichiers vérifiés
35- Classifications effectuées
36- PRs ouvertes
37- Éléments escaladés

Listez les compétences disponibles dans Slate :

1/skills

Activez-en une manuellement :

1@ci-triage veuillez trier les tests qui échouent aujourd'hui

Ou Slate active automatiquement les compétences lorsqu'il décide qu'elles sont pertinentes pour la tâche en cours.

Étape 5 — Ajouter un état (la mémoire de la boucle)

L'agent oublie.

Le fichier, non.

Créez STATE.md à la racine de votre projet :

1# État de la Boucle — Triage CI
2
3## Dernière exécution
42026-06-28 03:30 UTC — 7 échecs classifiés, 3 correctifs rédigés, 4 escaladés
5
6## En cours
7- claude/fix-auth-token-refresh — tests passent en local, en attente CI
8- claude/fix-flaky-payment-webhook — modèle de réessai appliqué, surveillance en cours
9
10## Terminé
11- claude/bump-axios-1.7.4 → fusionné (CI verte)
12- claude/lint-fix-pass-june-28 → fusionné
13
14## Escaladé aux humains
15- src/billing/refund.ts — tests échouent de 3 manières, cause racine peu claire
16- ci/staging-runner — timeouts infra, pas un problème de code
17
18## Leçons apprises
19- 2026-06-27 : PowerShell rencontre un problème TLS 1.2 sur ce runner Windows. Utiliser bash.
20- 2026-06-26 : tests/e2e/checkout nécessite le secret webhook Stripe dans l'env. Ignorer si manquant.

Dites à Slate de l'utiliser au début de chaque session en l'ajoutant à AGENTS.md :

1## Début de session
2Toujours lire STATE.md en premier. Reprendre là où la dernière exécution s'est arrêtée.
3Mettre à jour STATE.md à la fin de chaque exécution avec ce qui a été fait et ce qui vient ensuite.

Sans état : chaque exécution part de zéro.

Avec état : chaque exécution reprend et s'appuie sur la précédente.

Étape 6 — Construire la boucle réelle

Maintenant vous avez :

→ Espace de travail configuré (AGENTS.md)

→ Configuration définie (slate.json)

→ Une exécution manuelle fiable prouvée

→ Une compétence écrite (ci-triage)

→ Un fichier d'état créé (STATE.md)

Il est temps de l'intégrer dans une vraie boucle.

Option A : Boucle de fichier de file d'attente (la plus simple)

Créez loop.md :

1Lire STATE.md pour comprendre ce qui a déjà été essayé.
2
3Exécuter la compétence de triage CI sur tous les tests qui échouent dans la dernière build.
4
5Pour chaque échec :
6- Le classer en utilisant les règles de la compétence ci-triage
7- Rédiger un correctif pour les bugs et les problèmes de dépendance
8- Escalader les problèmes d'env et d'infra
9
10Exécuter les correctifs. Vérifier si les tests passent.
11Si les tests passent → ouvrir une PR.
12Si les tests échouent encore → enregistrer dans STATE.md et s'arrêter.
13
14Mettre à jour STATE.md avec tout ce qui a été fait lors de cette exécution.
15
16Arrêt strict : 8 tentatives maximum. À la limite, signaler l'état actuel.

Exécutez-la :

1slate --queue loop.md

Slate lit le fichier de file d'attente et exécute chaque bloc comme un message mis en file d'attente.

Option B : Boucle headless/CI (automatisée)

Exécutez de manière non interactive dans une GitHub Action ou un cron job :

1slate run "$(cat loop.md)" --output-format stream-json --dangerously-skip-permissions

Dans un workflow GitHub Actions :

1name: Boucle de Triage CI
2on:
3  workflow_run:
4    workflows: ["CI"]
5    types: [completed]
6
7jobs:
8  triage:
9    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
10    runs-on: ubuntu-latest
11    steps:
12      - uses: actions/checkout@v4
13
14      - name: Installer Slate
15        run: npm i -g @randomlabs/slate
16
17      - name: Exécuter la boucle de triage
18        env:
19          SLATE_API_KEY: ${{ secrets.SLATE_API_KEY }}
20        run: |
21          slate run "$(cat loop.md)" \
22            --output-format stream-json \
23            --dangerously-skip-permissions \
24            --workspace ./src \
25            --workspace ./tests

Maintenant, chaque échec CI déclenche automatiquement la boucle de triage.

Aucun humain nécessaire jusqu'à l'escalade.

Étape 7 — Ajouter des sous-agents (la séparation créateur-vérificateur)

L'amélioration structurelle la plus importante pour toute boucle.

Ne laissez jamais le même agent noter son propre travail.

Le modèle qui a écrit le correctif est un correcteur trop indulgent.

Dans Slate, vous pouvez définir différents modèles pour différents rôles :

1{
2  "models": {
3    "main": { "default": "anthropic/claude-opus-4.6" },
4    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
5    "search": { "default": "anthropic/claude-haiku-4.5" }
6  }
7}

Ensuite, écrivez votre tâche pour que Slate utilise naturellement cette séparation :

1Veuillez corriger les tests d'authentification qui échouent.
2
3Étape 1 : Faites explorer src/auth/ par un agent de recherche pour comprendre l'implémentation actuelle.
4Étape 2 : Faites implémenter le correctif par un agent séparé, basé sur ce qui a été trouvé.
5Étape 3 : Faites vérifier le correctif par un troisième agent par rapport aux exigences originales du test —
6        cet agent NE doit PAS avoir vu l'implémentation.
7Étape 4 : N'ouvrez la PR que si le vérificateur approuve.

Slate orchestre les sous-agents automatiquement.

L'agent de recherche utilise un modèle rapide et bon marché. L'agent d'implémentation utilise un modèle plus puissant. Le vérificateur utilise un modèle strict sans accès au raisonnement du créateur.

Cette séparation est la raison pour laquelle Slate peut exécuter 5 sous-agents parallèles sur une seule tâche — chacun spécialisé, chacun isolé.

Étape 8 — Le modèle de boucle d'état (pour les tâches de longue durée)

Pour les tâches qui s'étendent sur des heures ou des jours, utilisez ce modèle dans votre prompt de tâche :

1Vous exécutez une boucle multi-session.
2
3OBJECTIF : Migrer toutes les routes Express vers le nouveau modèle ApiError.
4Suivre la progression dans STATE.md.
5
6DÉBUT DE CHAQUE SESSION :
71. Lire STATE.md
82. Trouver le premier élément incomplet dans « Routes restantes »
93. Faire uniquement cet élément
10
11FIN DE CHAQUE SESSION :
121. Déplacer les éléments terminés vers « Routes terminées » dans STATE.md
132. Enregistrer les éventuels blocages dans « Bloqueurs »
143. Mettre à jour l'horodatage de « Dernière exécution »
154. S'arrêter proprement
16
17Format STATE.md :
18---
19## Routes terminées
20- [x] /api/users (2026-06-27)
21- [x] /api/auth/login (2026-06-28)
22
23## Routes restantes
24- [ ] /api/payments/checkout
25- [ ] /api/payments/refund
26- [ ] /api/admin/users
27
28## Bloqueurs
29- /api/payments/refund — nécessite une révision humaine (touche à la logique de facturation)
30
31## Dernière exécution
322026-06-28 14:30 UTC
33---
34
35RÈGLES STRICTES :
36- Ne jamais toucher à src/billing/ sans approbation humaine
37- Toujours exécuter les tests après chaque migration de route
38- S'arrêter après avoir terminé UNE route par session

Exécutez ceci chaque matin :

1slate --continue "$(cat loop.md)"

--continue reprend la session la plus récente au lieu de recommencer à zéro.

Chaque jour, une route de plus. STATE.md suit tout.

La boucle reprend exactement là où elle s'est arrêtée.

Étape 9 — Commandes personnalisées pour vos boucles les plus utilisées

Ajoutez des commandes slash personnalisées à slate.json pour que vos boucles soient toujours à une touche :

1{
2  "command": {
3    "triage": {
4      "description": "Exécuter la boucle de triage CI",
5      "template": "Lire STATE.md. Exécuter la compétence ci-triage sur tous les tests qui échouent. Mettre à jour STATE.md une fois terminé.",
6      "agent": "build"
7    },
8    "review": {
9      "description": "Examiner un fichier pour vérifier son exactitude",
10      "template": "Examiner @$ARGUMENTS pour vérifier l'exactitude, les cas limites et la cohérence avec le code environnant."
11    },
12    "migrate": {
13      "description": "Migrer une route vers le modèle ApiError",
14      "template": "Lire STATE.md. Migrer la prochaine route incomplète vers le modèle ApiError. Exécuter les tests. Mettre à jour STATE.md."
15    }
16  }
17}

Maintenant, dans Slate :

1/triage
2/review src/api/payments.ts
3/migrate

Chacune exécute instantanément le prompt de votre boucle pré-écrite.

3 boucles complètes que vous pouvez exécuter aujourd'hui

Boucle 1 : Triage des échecs CI (celle que nous avons construite)

Quand : chaque échec CI Quoi : classifier → corriger les faciles → escalader les difficiles → ouvrir des PRs État : STATE.md Barrière : tests passent Temps de configuration : 30 minutes

1# déclencheur
2slate run "$(cat loop.md)" --dangerously-skip-permissions --output-format stream-json
3
4# ou dans GitHub Actions — voir Étape 6 ci-dessus

Boucle 2 : Briefing matinal

Quand : 7h tous les jours de semaine (cron job) Quoi : analyser les 24 dernières heures de commits, PRs et problèmes ouverts → écrire un briefing de 5 points → publier sur Slack

1# loop.md pour le briefing matinal
2cat > morning-brief-loop.md << 'EOF'
3Lire les dernières 24 heures de :
4- git log --since="24 hours ago" --oneline
5- PRs ouvertes en brouillon ou en révision
6- Problèmes GitHub ouverts ou mis à jour au cours des dernières 24h
7
8Écrire un briefing matinal :
9- 3 choses les plus importantes qui se sont produites
10- 2 choses qui nécessitent une attention aujourd'hui
11- 1 chose qui risque de bloquer quelqu'un
12
13Rester en dessous de 120 mots. Publier dans le canal Slack #engineering.
14EOF
15
16# exécuter selon un planning avec cron
170 7 * * 1-5 slate run "$(cat morning-brief-loop.md)" --dangerously-skip-permissions

Boucle 3 : Boucle de mise à jour des dépendances

Quand : tous les lundis Quoi : rechercher les packages obsolètes → tester la compatibilité → ouvrir des PRs pour les mises à jour sûres

1cat > deps-loop.md << 'EOF'
2Lire STATE.md.
3
4Exécuter : npm outdated
5
6Pour chaque package obsolète :
71. Vérifier si la mise à jour de version est majeure (rupture) ou mineure/correctif (sûre)
82. Pour mineure/correctif : mettre à jour le package, exécuter npm test
93. Si les tests passent : ouvrir une PR
104. Si les tests échouent : enregistrer dans STATE.md comme « nécessite une révision humaine »
115. Pour les mises à jour majeures : toujours escalader aux humains
12
13Règles strictes :
14- Ne jamais mettre à jour plus de 5 packages dans une seule boucle
15- Ne jamais mettre à jour les packages dans la section « peer dependencies »
16- Toujours exécuter la suite de tests complète après chaque mise à jour, pas seulement les tests connexes
17
18Mettre à jour STATE.md avec ce qui a été mis à jour et ce qui a été escaladé.
19EOF
20
21# exécuter tous les lundis
220 9 * * 1 slate run "$(cat deps-loop.md)" --dangerously-skip-permissions

Les modes d'échec qui coûtent de l'argent

Connaissez-les avant de planifier quoi que ce soit.

La boucle Ralph Wiggum

L'agent déclare la tâche terminée sur un travail à moitié fait.

Il sort prématurément. La boucle continue de dépenser. Silencieusement.

Correctif : condition d'arrêt stricte vérifiée par un modèle frais.

1CONDITION D'ARRÊT : Tous les tests dans tests/auth/ réussissent ET lint renvoie 0.
2Vérifier à l'aide d'une exécution de vérification séparée, pas du jugement de l'agent.
3Limite stricte : 8 itérations. À la limite : signaler l'état et s'arrêter.

Dérive de l'objectif

Lors de longues sessions, les contraintes initiales disparaissent.

« Ne jamais toucher à src/billing/ » du message 3 a disparu au message 47.

Correctif : ajoutez un VISION.md que Slate relit au début de chaque session.

1# VISION.md — À lire au début de chaque session
2
3## Objectif principal
4Migrer toutes les routes Express vers le modèle ApiError.
5
6## Contraintes strictes (ne jamais violer)
7- Ne jamais toucher à src/billing/ sans approbation humaine
8- Ne jamais désactiver des tests qui échouent
9- Toujours exécuter la suite de tests complète avant d'ouvrir une PR
10
11## Priorité actuelle
12Routes dans src/api/payments/ — à traiter avec une attention particulière

Biais d'auto-préférence

Le créateur note son propre travail. Il se donne toujours une note de passage.

Correctif : sous-agent vérificateur avec zéro accès au raisonnement du créateur.

Dites-le explicitement à Slate :

1L'agent vérificateur NE doit PAS voir le travail de l'agent d'implémentation.
2Il doit seulement voir : les exigences originales du test et la sortie du test.
3Si les tests passent → approuver. Si les tests échouent → rejeter. Aucun avis autrement.

Paresse agentique

La boucle appelle une tâche « assez bien terminée » à un achèvement partiel.

Surtout sur des critères de succès vagues.

Correctif : condition d'arrêt objective uniquement.

1TERMINÉ QUAND : npm test renvoie le code de sortie 0 ET npm run lint renvoie le code de sortie 0.
2Pas quand « les tests ont l'air bons. » Pas quand « la plupart des tests passent. »
3Code de sortie 0 sur les deux commandes. C'est le seul état « terminé ».

Les astuces spécifiques à Slate qui comptent

Quelques choses qui rendent Slate différent des autres agents en pratique.

Mettre des messages en file d'attente pendant qu'il travaille

Slate exécute une longue tâche. Vous pensez à quelque chose d'important.

Appuyez sur Tab pour mettre le message en file d'attente — il s'exécute après la fin de la tâche en cours, sans l'interrompre.

1[Slate travaille sur une tâche de migration...]
2
3Vous : En fait, assure-toi que le nouveau modèle gère aussi le cas où userId est nul
4[Tab — mis en file d'attente]
5
6[Slate termine l'étape en cours, puis lit votre message en file d'attente]

Orienter en cours d'exécution

Si Slate va dans la mauvaise direction, vous n'avez pas besoin de l'arrêter :

1[Slate est à mi-chemin de l'implémentation du correctif...]
2
3Vous : Attends — n'ajoute pas une nouvelle classe pour ça. Utilise le BaseError existant dans src/utils/errors.ts
4[Entrée — oriente immédiatement]
5
6Slate : Compris, je change d'approche pour utiliser BaseError...

Utilisez /enter-mode-next pour basculer entre les modes orienter / file d'attente / interrompre.Commandes shell directement

Exécutez des commandes dans la session Slate sans passer à un autre terminal :

1!npm test          # exécuter les tests et envoyer la sortie à Slate
2!git diff HEAD     # vérifier ce qui a changé
3!git status        # voir l'état actuel

Slate lit la sortie et l'utilise dans son action suivante.

Mode serveur pour les configurations en équipe

Exécutez Slate en tant que serveur et connectez-vous-y depuis plusieurs terminaux :

1# Terminal 1 — démarrer le serveur
2slate serve --port 7777
3
4# Terminal 2 — attacher le TUI
5slate attach http://localhost:7777 --dir /chemin/vers/projet

Utile pour la programmation en binôme avec Slate ou pour l'exécuter sur une machine distante.

La liste de vérification complète de configuration

Avant d'exécuter votre première vraie boucle :

1□ npm i -g @randomlabs/slate installé
2□ AGENTS.md créé avec l'aperçu du projet, les commandes, les règles
3□ slate.json créé avec les permissions et la configuration des modèles
4□ Une exécution manuelle terminée et vérifiée fiable
5□ SKILL.md écrit pour votre première tâche répétée
6□ STATE.md créé et référencé dans AGENTS.md
7□ loop.md écrit avec une condition d'arrêt explicite
8□ Limite stricte sur les itérations (8 max pour commencer)
9□ Le vérificateur N'est PAS le même agent que le créateur
10□ Barrière de révision humaine sur toute action irréversible (PRs, déploiements)

Cochez chaque case avant de planifier quoi que ce soit.

Sautez-en une et la boucle échoue silencieusement ou vous facture pour rien.

Pour plus d'inspiration sur les boucles

Une fois que vous avez compris le schéma, le goulot d'étranglement passe de « comment construire une boucle » à « quelle boucle construire ensuite ».

La Forward Future Loop Library, accessible à l'adresse signals.forwardfuture.com/loop-library, est un bon endroit pour parcourir des boucles réelles en fonctionnement, classées par catégories — contenu, ingénierie, opérations, recherche.

Quand vous voyez 20 boucles fonctionnelles au même endroit, vous arrêtez de penser en termes de requêtes ponctuelles.

La vérité qui dérange

Deux développeurs peuvent exécuter exactement la même boucle et obtenir des résultats opposés.

L'un l'utilise pour aller plus vite sur un travail qu'il maîtrise déjà profondément.

L'autre l'utilise pour éviter de comprendre le travail du tout.

La boucle ne fait pas la différence.

Vous, si.

La conception de boucles est plus difficile que le prompt engineering — pas plus facile.

Le but n'est pas que le travail soit devenu plus facile.

Le point de levier a bougé.

Construisez la boucle.

Mais construisez-la comme quelqu'un qui a l'intention de rester l'ingénieur.

Pas seulement la personne qui appuie sur le bouton « go ».

Et le nouveau GPT-5.6 ne remplace pas ce principe. Si quoi que ce soit, il le renforce.

La frontière n'est plus celui qui écrit le prompt le plus astucieux.

C'est celui qui conçoit les meilleurs systèmes autour de modèles de plus en plus performants.

Le récapitulatif en 60 secondes

Ce qu'est une boucle :

→ Prompt = question. Boucle = travail.

→ Découvrir → Exécuter → Vérifier → Itérer → Arrêter

Le test des 4 conditions :

→ La tâche se répète / La vérification est automatisée / Le budget absorbe le gaspillage / « Fait » est objectif

Les 5 étapes de configuration :

→ AGENTS.md → slate.json → un lancement manuel → SKILL.md → STATE.md

Puis enveloppez-la :

→ Fichier de file d'attente loop.md OU exécution slate sans tête dans l'IC

Les modes d'échec :

→ Ralph Wiggum (sortie précoce) / Dérive des objectifs (oublie les contraintes) / Biais d'auto-préférence (créateur = vérificateur) / Paresse agentique (assez bien)

L'avantage de Slate :

→ Sélection automatique du modèle par étape → Sous-agents parallèles avec isolation → Gestion des sessions longues → Votre boucle, votre conception

Si cela vous a été utile :

→ Republiez pour le partager avec tous les développeurs que vous connaissez

→ Suivez @sairahul1 pour plus de systèmes comme celui-ci

→ Mettez-le en favori — la liste de contrôle de configuration vaut à elle seule la peine d'être sauvegardée

Abonnez-vous à theaibuilders.co pour plus d'articles intéressants de ce type

J'écris sur l'IA, la création de produits et les systèmes qui tournent pendant que vous dormez.

Outils mentionnés :

→ Documentation Slate : docs.randomlabs.ai

→ Forward Future Loop Library : signals.forwardfuture.com/loop-library