Comment faire fonctionner Claude en pilotage automatique en 14 étapes : /loop, Routines et la stack d'automatisation complète.

Vous payez 20 à 200 $/mois pour Claude et vous l'utilisez comme une version payante de ChatGPT. 9 utilisateurs sur 10 n'ont jamais configuré d'automatisation qui fonctionne sans qu'ils aient à cliquer sur des boutons.

Pas de /loop, pas de tâches planifiées, pas de Routines, pas de déclencheurs. L'outil censé fonctionner pendant que vous dormez attend toujours que vous tapiez. Voici le plan en 14 étapes pour maîtriser la pile d'automatisation complète - et récupérer des heures dans votre semaine.

Suivez mon Substack pour obtenir de l'alpha IA fraîche :

movez.substack.com

Claude Code a discrètement déployé toute une pile d'automatisation au cours des trois derniers mois. /loop est sorti.

Auto Mode est arrivé le 24 mars. Cloud Routines a été ouvert en aperçu de recherche le 14 avril. D'ici mai 2026, le tableau est complet : trois couches d'automatisation qui vont de votre terminal au cloud d'Anthropic, chacune gagnant sa place en supprimant une raison différente pour vous de superviser.

Voici le plan en 14 étapes pour les trois couches - chaque détail vérifié par rapport à la documentation officielle sur code.claude.com/docs en date de juin 2026. L'arc est simple : maîtrisez la boucle manuelle, rendez-la persistante après les redémarrages, poussez-la vers le cloud où votre ordinateur portable n'a pas d'importance.

14 étapes. 3 niveaux. Un seul Claude qui travaille pendant que vous dormez.

01. La commande /loop. Explicite et langage naturel, les deux fonctionnent.

Le moyen le plus rapide de faire faire quoi que ce soit à Claude Code selon un planning. Dans n'importe quelle session, exécutez /loop <intervalle> <invite>.

Sous le capot, cela appelle trois outils natifs : CronCreate, CronList, CronDelete. Les intervalles utilisent un nombre plus une unité : m pour les minutes, h pour les heures, d pour les jours. Le minimum est d'une minute - 30s est arrondi à la minute supérieure.

1> /loop 1m say hello
2
3▲ Claude
4  CronCreate(*/1 * * * * : say hello)
5✓ Planifié c21d95a0 (Toutes les minutes)
6  - Tâche : say hello
7  - Cadence : Toutes les 1 minute (*/1 * * * *)
8  - ID de tâche : c21d95a0
9  - Durée : Les tâches récurrentes expirent automatiquement après 7 jours
10  - Annuler à tout moment : CronDelete c21d95a0

Vous n'avez en fait pas du tout besoin de taper /loop. Claude comprend tout aussi bien les plannings en langage naturel :

• toutes les 10 minutes, vérifie le statut du déploiement
• tous les jours de semaine à 7h, résume les commits de la nuit
• à 18h30 aujourd'hui, publie une mise à jour de statut sur Slack

Les heures utilisent le fuseau horaire de la machine locale, pas UTC. Toute commande slash disponible dans Claude Code peut être placée dans un /loop - y compris /run, /review, et même un autre /loop si vous vous sentez aventureux.

02. Les vraies expressions cron pour de vrais plannings.

L'outil CronCreate accepte les expressions cron standard à 5 champs : minute heure jour-du-mois mois jour-de-la-semaine. Tous les champs prennent en charge les jokers (\), les valeurs uniques (5), les pas (\/15), les plages (1-5) et les listes séparées par des virgules (1,15,30). Le jour de la semaine utilise 0 ou 7 pour dimanche jusqu'à 6 pour samedi.

Ce qui n'est PAS pris en charge : la syntaxe étendue comme L (dernier jour), W (jour de semaine), ?, ou les alias de noms comme MON ou JAN. Lorsque le jour-du-mois et le jour-de-la-semaine sont tous deux contraints, une date correspond si l'un ou l'autre champ correspond - sémantique vixie-cron standard.

Les motifs cron qui valent la peine d'être mémorisés :

1# Motifs Cron qui valent leur pesant d'or
2
3# toutes les 5 minutes (uniquement pendant les heures ouvrables)
4*/5 9-17 * * 1-5
5
6# tous les jours de semaine à 7h
70 7 * * 1-5
8
9# le premier du mois à 9h
100 9 1 * *
11
12# toutes les 15 minutes
13*/15 * * * *
14
15# toutes les nuits à 2h30
1630 2 * * *
17
18# tous les vendredis à 16h
190 16 * * 5
20
21# toutes les 6 heures, à l'heure pile
220 */6 * * *

03. Expiration automatique et conditions d'arrêt

Quatre contraintes strictes qui déterminent si /loop est le bon outil pour le travail. Mémorisez-les ou perdez du temps à les découvrir plus tard :

• Expiration automatique de 7 jours. Toute tâche récurrente se supprime automatiquement 7 jours après sa création. La tâche s'exécute une dernière fois, puis se supprime. Cela limite la durée pendant laquelle une boucle oubliée peut fonctionner. Si vous avez besoin qu'elle dure plus longtemps, annulez-la et recréez-la avant la date limite - ou utilisez les Routines (étape 10).
• Maximum de 50 tâches par session. Amplement suffisant pour les workflows individuels. Si vous construisez quelque chose de plus élaboré, comptez vos tâches ; vous n'aurez pas d'avertissement avant d'atteindre le mur.
• Pas d'exécution de rattrapage. Si une tâche est due pendant que Claude est occupé sur une requête de longue durée, elle s'exécute une fois lorsque Claude devient inactif, pas une fois par intervalle manqué. Une boucle de 5 minutes qui tombe pendant un refactoring de 20 minutes produit une seule exécution après, pas quatre.
• Limitée à la session. Fermer le terminal annule tout. Redémarrer Claude Code efface toutes les tâches planifiées. Il n'y a pas de persistance entre les sessions - c'est à cela que servent le Niveau 2 et le Niveau 3.

Pour lister et annuler des tâches en cours de session, demandez simplement en langage naturel - Claude achemine vers CronList et CronDelete :

1> afficher les tâches cron en cours
2
3▲ CronList()
4   ID         TÂCHE                     CADENCE
5   c21d95a0   say hello                 Toutes les 1 minute
6   8f3aa412   vérifier statut déploiement Toutes les 10 minutes
7   bb7c0d91   résumé matinal            0 7 * * 1-5
8
9> supprimer la vérification du statut de déploiement
10
11▲ CronDelete(8f3aa412)
12✓ Annulé. 2 tâches restantes.

Pour les environnements CI ou les serveurs partagés où la planification en arrière-plan n'est pas souhaitable, définissez CLAUDE_CODE_DISABLE_CRON=1 dans votre environnement. Les outils cron et /loop deviennent indisponibles, et toutes les tâches déjà planifiées cessent de s'exécuter.

C'est la bonne décision pour tout environnement où l'utilisateur qui exécute Claude n'est pas l'utilisateur qui possède le planning.

04. Associer /loop avec /goal

Un /loop seul demande à Claude de faire quelque chose de manière répétée. Un /loop associé à /goal demande à Claude de faire quelque chose de manière répétée jusqu'à ce qu'une condition spécifique soit remplie - et de continuer à boucler au-delà des déclarations intermédiaires de « assez fait ».

Cette association résout la paresse agentique au sein d'une tâche récurrente. Sans /goal, une boucle pourrait traiter 20 des 50 éléments qu'elle est censée gérer et qualifier le reste de « traité ». Avec /goal, la condition d'arrêt est explicite et appliquée :

1Un /loop seul demande à Claude de faire quelque chose de manière répétée.
2Un /loop associé à /goal demande à Claude de faire quelque chose de manière répétée jusqu'à ce qu'une condition spécifique soit remplie — et de continuer à boucler au-delà des déclarations intermédiaires de « assez fait ».
3
4Cette association résout la paresse agentique au sein d'une tâche récurrente.
5Sans /goal, une boucle pourrait traiter 20 des 50 éléments qu'elle est censée gérer et qualifier le reste de « traité ». Avec /goal, la condition d'arrêt est explicite et appliquée :

Les trois schémas où cette association prouve sa valeur :

• Débogage de tests instables. Reproduire, former des théories, les tester, jusqu'à ce que l'une d'elles tienne.
• Migrations de longue durée. Traiter les éléments, sauvegarder la progression, continuer jusqu'à ce que la file d'attente soit vide.
• Tri de type boîte de réception. Traiter les éléments en attente, continuer jusqu'à ce que rien de nouveau n'arrive pendant un cycle complet.

Quatre étapes et vous avez une boucle manuelle fonctionnelle. Maintenant, faites-la survivre à un redémarrage.

05. Tâches planifiées du Bureau.

L'application Claude Desktop a son propre planificateur, distinct du /loop du CLI. Créez des tâches planifiées à partir de Planning → Nouvelle tâche → Nouvelle tâche locale.

Vous définissez un nom, une invite, une fréquence, des autorisations et un dossier de travail. Chaque exécution démarre une nouvelle session Claude Code - aucun contexte partagé avec quoi que ce soit d'autre.

Ce que cette couche vous apporte que /loop n'offre pas :

• Survit aux redémarrages. Redémarrez votre machine, fermez tous les terminaux - les tâches s'exécutent toujours lorsque leur heure arrive.
• Contexte frais à chaque exécution. Aucun état accumulé des exécutions précédentes. Chaque tâche est essentiellement indépendante.
• Autorisations préconfigurées. Outils autorisés, dossier de travail, modèle, tout est verrouillé par tâche.

Ce qu'elle nécessite encore : votre machine doit être allumée. Si votre ordinateur portable est en veille lorsqu'une tâche est due, l'exécution est ignorée. Lorsque la machine se réveille ou que vous rouvrez Claude Desktop, il vérifie les 7 derniers jours pour les exécutions manquées, démarre une exécution de rattrapage pour l'heure manquée la plus récente et affiche une notification.

Pour empêcher la mise en veille, activez Garder l'ordinateur éveillé dans les Paramètres du Bureau sous Général. Fermer le couvercle de l'ordinateur portable déclenche toujours la mise en veille.

Les tâches planifiées du Bureau sont

macOS et Windows uniquement

. Les utilisateurs Linux ont deux options : (1) utiliser le /loop du CLI pour la planification limitée à la session, ou (2) configurer des tâches cron système exécutant claude -p <invite> en mode sans tête pour une planification persistante. Les Routines (étape 10) fonctionnent partout car elles s'exécutent dans le cloud.

06. Budgets de tokens et limites de débit.

La plus grande surprise sur un plan Pro : chaque exécution planifiée démarre une session Claude Code complète, et chaque session compte dans vos limites d'utilisation. Une boucle de 5 minutes fonctionnant 24 heures sur 24 représente 288 sessions.

Elles ne sont pas minuscules - chacune charge le contexte, appelle des outils, invoque éventuellement des sous-agents. Tenez-en compte avant de configurer quoi que ce soit d'ambitieux.

Trois habitudes qui maintiennent l'automatisation abordable :

• Définissez des budgets de tokens explicites dans l'invite. « Utilisez au maximum 5k tokens. Si vous ne pouvez pas terminer dans ce budget, sauvegardez la progression partielle et quittez proprement. » Cela plafonne chaque exécution individuellement.
• Faites correspondre le modèle à la tâche. Ne choisissez pas par défaut Opus pour tout. La plupart des automatisations fonctionnent bien sur Sonnet. Les explorations bon marché tournent sur Haiku. Le sélecteur de modèle dans la configuration de la tâche utilise par défaut celui du panneau - pas celui utilisé par vos sessions interactives. Définissez-le explicitement par tâche.
• Choisissez le bon plan pour le volume. Le plan Pro se resserre rapidement sous une automatisation lourde. Max offre 5 fois plus de marge ; Team et Enterprise encore plus. Si vous déployez une véritable automatisation, la mise à niveau se rembourse d'elle-même en évitant les limitations de débit un mardi à 15h.

07. Configurer les autorisations pour les exécutions sans surveillance.

Par défaut, Claude Code demande une approbation avant d'exécuter une commande bash, d'écrire un fichier ou d'appeler une API externe.

C'est bien quand vous regardez. C'est un désastre quand personne n'est là. Trois schémas de configuration transforment la valeur par défaut en quelque chose qui peut réellement fonctionner sans surveillance :

• Pré-approuvez des outils spécifiques via settings.json - une liste blanche de commandes sûres et une liste noire de commandes interdites.
• Utilisez .claudeignore à la racine du projet pour bloquer l'accès aux identifiants, aux fichiers d'environnement et aux répertoires sensibles avant qu'une tâche non surveillée ne les touche.
• Activez la journalisation d'audit pour enregistrer chaque action autonome. Lisez-la le lendemain matin au lieu de faire confiance à l'exécution à l'aveugle.

1{
2  "permissions": {
3    "autoApprove": [
4      "Read(*)",
5      "Grep(*)",
6      "Bash(npm test)",
7      "Bash(pytest)",
8      "Bash(git status)",
9      "Bash(git diff*)",
10      "Bash(git log*)",
11      "WebFetch(domain:docs.python.org)"
12    ],
13    "deny": [
14      "Bash(rm -rf*)",
15      "Bash(git push*)",
16      "Bash(*--force*)",
17      "Bash(curl*)",
18      "Edit(.env*)",
19      "Edit(secrets/*)"
20    ]
21  },
22  "auditLog": true
23}

Le bon test pour savoir quoi auto-approuver : si cela tourne mal, combien coûte l'annulation ? Peu coûteux à annuler (un commentaire sur une PR en brouillon) - auto-approuver. Coûteux à annuler (un force-push vers main) - jamais.

Le juste milieu (créer une branche, ouvrir une PR) est acceptable à auto-approuver si vous avez également des journaux d'audit que vous lisez réellement.

08. Auto Mode - Autorisations classifiées par IA

Auto Mode est l'alternative à --dangerously-skip-permissions. Au lieu d'une approbation globale, un classificateur IA évalue chaque appel d'outil par rapport à la politique d'autorisation active et décide d'auto-approuver, de demander une confirmation ou de bloquer.

Anthropic a mesuré que les utilisateurs approuvent 93 % des demandes d'autorisation ; Auto Mode automatise les 93 % et maintient l'humain dans la boucle pour les 7 %.

Comment cela fonctionne en pratique :

• Trois niveaux. Permissif, Équilibré, Restrictif. Choisissez celui qui correspond à votre tolérance au risque pour le projet.
• Deux couches de défense. Une sonde d'injection d'invite côté serveur analyse les sorties des outils avant qu'elles n'entrent dans le contexte de Claude. Ensuite, un classificateur évalue chaque action proposée.
• Piste d'audit. Chaque décision autonome est enregistrée. Vous pouvez examiner ce qui a été approuvé et pourquoi après coup.

Disponibilité du plan en mai 2026 : Max, Team, Enterprise et plans API (via l'API Anthropic). Pas encore disponible sur Pro, Bedrock, Vertex ou Foundry.

Consultez code.claude.com/docs/en/auto-mode avant de planifier en fonction de cela. Une fois activé, Auto Mode rejoint le cycle de modes Shift+Tab aux côtés de Accept Edits et Plan.

Auto Mode est encore en aperçu de recherche. La logique de décision du classificateur est en cours d'affinement et le comportement peut changer entre les versions.

Associez-le à .claudeignore et aux journaux d'audit - Anthropic recommande vivement les deux. Ne l'utilisez pas dans des environnements d'équipe partagés sans garanties supplémentaires.

09. Choisir le bon planificateur pour le travail.

Trois planificateurs, faciles à confondre. La règle de décision est une question : où cela doit-il s'exécuter et qui doit être éveillé pour cela ?

Le schéma cumulatif : commencez par /loop dans une session pour trouver ce qui fonctionne, puis passez aux tâches du Bureau pour une utilisation quotidienne, puis passez aux Routines lorsque vous voulez que cela fonctionne indépendamment de votre matériel.

Chaque niveau gagne sa place en supprimant une raison différente pour vous d'être présent.

10. Routines Cloud.

Publiées le 14 avril 2026 en aperçu de recherche. Les Routines sont des configurations Claude Code sauvegardées - une invite, des dépôts, des connecteurs, des autorisations - qui s'exécutent sur l'infrastructure cloud gérée par Anthropic sur un déclencheur.

Votre ordinateur portable peut être éteint. L'exécution a quand même lieu.

Disponible sur tous les plans payants (Pro, Max, Team, Enterprise). Créez-les sur claude.ai/code/routines ou avec /schedule dans le CLI. Le CLI crée uniquement des routines déclenchées par un planning ; pour ajouter des déclencheurs API ou GitHub, modifiez sur le web.

Ce que contient réellement une routine :

• Une invite autonome. La routine s'exécute de manière autonome sans questions de suivi, donc tout ce qui est ambigu devient un pile ou face à chaque exécution. Spécifiez quoi faire, à quoi ressemble le succès, où envoyer le résultat.
• Un ou plusieurs dépôts. Clonés au début de chaque exécution.
• Des connecteurs. Slack, Linear, Drive, GitHub, tout ce que vous avez connecté.
• Un environnement. Contrôle l'accès au réseau et les secrets. Par défaut, il est de Confiance - autorise les registres de paquets mais pas les appels sortants arbitraires.
• Un ou plusieurs déclencheurs. Planning, API, événement GitHub, ou toute combinaison.

Par défaut, les routines ne peuvent pousser que vers des branches préfixées par claude/. Une routine mal écrite ne peut pas accidentellement pousser vers main. Désactivez ceci uniquement si vous disposez d'un processus de révision en aval en lequel vous avez réellement confiance. La valeur par défaut existe pour une raison.

11. Routines déclenchées par un planning

Le déclencheur le plus courant et celui par lequel commencer. Définissez une cadence - horaire, quotidienne, jours de semaine, hebdomadaire, ou une heure future unique - et éloignez-vous.

1> /schedule weekdays at 7am
2  Objectif : récupérer les issues GitHub d'hier, classer par sévérité,
3  rédiger des correctifs pour tout « P0 » ou « P1 », ouvrir des PR en brouillon pour révision.
4  Publier un résumé dans #engineering sur Slack.
5
6▲ Claude
7  Création de la routine : morning-briefing
8  - déclencheur : planning (0 7 * * 1-5)
9  - dépôts : org/api, org/web
10  - connecteurs : github, slack
11  - environnement : Confiance
12✓ Active · première exécution lundi à 07h00 heure locale.
13  Voir sur claude.ai/code/routines

Trois schémas qui se rentabilisent rapidement :

• Briefing matinal. Récupérez les métriques et incidents d'hier, résumez les nouvelles issues GitHub, publiez un résumé sur Slack. À 8h, vous savez ce qui s'est passé pendant la nuit, sans rien ouvrir.
• Passage de révision de PR. Tous les jours de semaine à 9h, analysez les PR ouvertes qui vous sont assignées, laissez un commentaire de première révision avec des indicateurs de sécurité et de style. La révision humaine commence pré-nettoyée.
• Détection de dérive documentaire. Chaque semaine, analysez les changements de code et signalez toute documentation qui n'a pas été mise à jour en même temps. Ouvrez une PR en brouillon avec les corrections.

Les heures sont dans votre fuseau horaire local et converties automatiquement. Les exécutions peuvent commencer quelques minutes après l'heure prévue en raison de l'échelonnement - cohérent par routine.

12. Routines déclenchées par API

Un déclencheur API donne à une routine un point de terminaison HTTP unique et un jeton porteur. POSTez depuis n'importe où - systèmes d'alerte, pipelines de déploiement, outils de surveillance, vos propres applications - et la routine s'exécute. Un corps JSON optionnel devient un contexte unique ajouté à l'invite de la routine.

1# Déclencher une routine depuis n'importe où avec un accès HTTP
2curl -X POST https://api.anthropic.com/v1/claude_code/routines/$ROUTINE_ID/fire \
3  -H "Authorization: Bearer $ROUTINE_TOKEN" \
4  -H "anthropic-version: 2023-06-01" \
5  -H "anthropic-beta: experimental-cc-routine-2026-04-01" \
6  -H "Content-Type: application/json" \
7  -d '{"text": "Alerte Sentry SEN-4521 déclenchée en prod. Stack trace jointe."}'
8
9# La réponse inclut claude_code_session_id + URL pour regarder en direct

Deux détails opérationnels qui comptent :

• Le jeton n'est affiché qu'une seule fois à la création. Stockez-le immédiatement dans un coffre à secrets - vous ne pouvez pas le récupérer plus tard.
• Surveillez l'en-tête beta. Le point de terminaison /fire est livré sous experimental-cc-routine-2026-04-01. Les formes de requête et de réponse peuvent changer pendant l'aperçu. Anthropic garantit que les deux versions d'en-tête les plus récentes continuent de fonctionner - migrez pendant la fenêtre de dépréciation.

Ce que ce schéma de déclencheur débloque réellement : Claude devient un workflow appelable depuis n'importe quel système de votre pile.

CI échoue → déclenchez une routine pour enquêter et ouvrir une PR de correctif. Alerte PagerDuty → déclenchez une routine pour trier et publier le contexte initial.

Webhook Stripe → déclenchez une routine pour mettre à jour un tableau de bord interne.

13. Routines déclenchées par GitHub.

Le déclencheur GitHub connecte une routine au webhook de l'application GitHub Claude. Les événements pris en charge sont larges : pull request, push, issue, check run, workflow run, discussion, release, merge queue.

Chaque événement correspondant démarre une session indépendante - pas de réutilisation de session entre les événements.

Là où ce déclencheur prouve sa valeur :

• Événements d'ouverture de PR → la routine exécute un passage de révision de code, signale les problèmes de sécurité et de style, laisse un commentaire de premier passage. Les auteurs reçoivent des commentaires de pré-révision avant l'arrivée des réviseurs humains.
• Événements de création d'issue → la routine trie les nouvelles issues, applique des étiquettes, lie le code associé, rédige une première réponse. Le backlog reste propre sans que personne ne le gère manuellement.
• Événements d'exécution de workflow → la routine enquête sur les échecs CI, identifie les causes racines probables, ouvre une PR de correctif en brouillon. Les builds échoués cessent d'être une corvée manuelle.
• Événements de release → la routine rédige les notes de version, publie dans le journal des modifications, notifie les parties prenantes. Fini le « qui rédige le journal des modifications ce sprint ? »

Les filtres de pull request vous permettent de cibler précisément : auteur, titre, corps, branche de base, branche de tête, étiquettes, état du brouillon, état de fusion, depuis un fork.

Une routine qui ne se déclenche que sur les PR étiquetées needs-security-review contre main est à un filtre de distance.

14. Composer avec les Skills et les Workflows Dynamiques.

La dernière étape boucle la boucle avec tout ce que Claude Code a livré avant. Chaque couche d'automatisation devient plus puissante lorsque vous l'associez au reste de la pile.

• Skills dans les Routines. Un Skill est un fichier d'instructions réutilisable. Déposez votre Skill « PR review » ou « morning briefing » dans ~/.claude/skills/, puis pointez l'invite de la routine dessus : « Utilise le skill morning-briefing. » Le skill est votre recette réutilisable ; la routine est le déclencheur qui l'exécute.
• Workflows Dynamiques dans les Routines. Pour une automatisation complexe qui bénéficie de sous-agents parallèles - vérification approfondie, tournois, recherche en étoile - faites en sorte que l'invite de la routine invoque un workflow. Les Routines fournissent la planification ; les workflows fournissent la structure.
• Routines déclenchées par d'autres Routines. La sortie d'une routine (une PR ouverte, un message Slack, un changement d'étiquette) peut être le déclencheur d'une autre routine. La composition n'est pas une fonctionnalité que vous activez - c'est un schéma que vous configurez en pointant la sortie d'une routine vers le déclencheur d'une autre.
• Autorisations par routine, pas globales. Chaque routine porte sa propre configuration d'autorisations. La routine morning-briefing lit partout mais ne peut pas pousser. La routine auto-fix ne pousse que vers les branches claude/. La routine security-scan a la liste de refus maximisée. Traitez le fichier d'autorisations de chaque routine comme faisant partie de sa frontière de sécurité.

La pile entière à son apogée ressemble à ceci : Les Skills comme vos recettes, les Workflows Dynamiques comme l'orchestration, les Routines comme la couche de déclenchement, Auto Mode comme le classificateur d'autorisations, les Journaux d'audit comme votre révision matinale. Chaque étape de cet article configure une tranche de cette pile.

Vous n'avez pas besoin de tout cela dès le premier jour. Commencez par /loop. Passez au Bureau. Passez aux Routines. Associez avec les Skills. Ajoutez des Workflows lorsque la complexité l'exige.

Les habitudes qui gaspillent de l'argent sur l'automatisation Claude

• Ne jamais essayer /loop en premier lieu. Le niveau d'automatisation le plus simple ne coûte rien et vous l'ignorez depuis trois mois.
• Oublier l'expiration automatique de 7 jours. Configurez une boucle critique, éloignez-vous, demandez-vous une semaine plus tard pourquoi rien ne s'est passé.
• Utiliser /loop pour des tâches qui devraient survivre à votre terminal. Tout l'intérêt des Niveaux 2 et 3 est exactement ce cas - passez au niveau supérieur.
• Laisser les Automatisations choisir le modèle par défaut. Opus à chaque exécution alors que Sonnet ferait le même travail pour moins cher. Vérifiez le sélecteur de modèle par tâche.
• Pas de /goal sur les boucles qui devraient s'exécuter jusqu'à la fin. La boucle s'arrête à « assez traité » au lieu de la condition d'arrêt réelle.
• Approbation globale via --dangerously-skip-permissions. À une mauvaise invite d'un git push --force origin main. Utilisez Auto Mode ou une liste blanche.
• Invites de routine vagues. Une routine s'exécute de manière autonome sans suivi. Les invites ambiguës produisent un comportement de pile ou face à chaque exécution.
• Pas de journaux d'audit. « Faire confiance à l'automatisation » sans examiner ce qu'elle a fait, c'est ainsi que les échecs silencieux deviennent des incidents bruyants.
• Désactiver le préfixe de branche claude/. La valeur par défaut existe pour une raison. Ne la désactivez pas tant que votre processus de révision en aval n'est pas réellement solide.
• Exécuter des automatisations sur Pro. Une automatisation lourde atteint rapidement les limites de débit. Si vous déployez de vrais workflows, la mise à niveau vers Max se rembourse d'elle-même en évitant les blocages.

Conclusion : **

Claude ne cesse pas de fonctionner lorsque vous cessez de taper.

La pile d'automatisation a été livrée en pièces détachées pendant trois mois. /loop en mars. Auto Mode deux semaines plus tard. Routines en avril. Le tout est en ligne, documenté et disponible sur les plans que vous payez déjà.

La seule chose qui se dresse entre « Claude en tant que chatbot coûteux » et « Claude en tant que main-d'œuvre » est quatorze étapes de configuration.

La plupart des utilisateurs continueront à taper des invites manuellement et s'arrêteront là. C'est bien pour une utilisation occasionnelle et mauvais pour tout le reste. Le 1 % qui exécute une véritable automatisation a Claude qui trie les issues à 7h, qui rafraîchit les tableaux de bord toutes les heures, qui rédige des réponses Slack toutes les 10 minutes - tout cela pendant qu'ils dorment. Ils ont configuré la boucle manuelle, l'ont promue au Bureau, l'ont promue aux Routines.

Choisissez une étape que vous ne faisiez pas - probablement votre premier /loop dans le terminal - et ajoutez-la demain. Puis la suivante. La sortie de Claude suit la configuration de Claude. Configurez-le pour le pilotage automatique, et c'est ce que vous obtiendrez.