Pourquoi votre flux de travail n'a pas changé malgré l'utilisation quotidienne de Claude Code
« Je me souviens avoir lancé /init. Mais je n'ai aucune idée de quand je l'ai mis à jour pour la dernière fois. »
Cela vous ressemble-t-il ? Vous avez installé Claude Code, passé les premiers jours à le configurer, et vous discutez avec lui quotidiennement. Pourtant, comparé à il y a trois mois, la structure de votre travail reste largement inchangée.
Ce n'est pas un problème d'utilisation ; c'est un problème de positionnement.
Si vous continuez à utiliser Claude Code comme un « outil qui répond quand on lui parle », vous finirez par taper les mêmes instructions chaque matin, obtenir des réponses similaires et les copier dans votre travail. Vous êtes peut-être plus efficace, mais la façon dont votre travail progresse n'a pas fondamentalement changé.
Le changement se produit lorsque vous commencez à considérer Claude Code comme une « cible de conception ». Qui sait quoi dans quel contexte ? Quelles tâches sont déléguées à qui ? Qu'est-ce qui bouge même en l'absence d'humain ? Lorsque vous commencez à penser à cela comme à une conception, Claude Code commence à se comporter de manière totalement différente.
Les 27 fonctionnalités publiées par @sairahul1 (https://x.com/sairahul1/status/2070428662080618607) listent systématiquement les fonctions qui doivent être utilisées dans cette perspective de conception. Swarm a interprété ces fonctions à travers le prisme de la conception d'agents et les a organisées dans un format applicable à des contextes métier réels.
Vingt-sept peut sembler beaucoup, mais il n'y a que trois principes fondamentaux. Nous expliquerons cette structure dans l'ordre à partir du chapitre suivant.
Les trois disciplines reliant les 27 fonctionnalités
En regardant les 27 fonctionnalités, elles peuvent sembler dispersées. Il y a des raccourcis, des paramètres de fichiers, la saisie vocale et l'exécution de tests. Cependant, une fois décodées, elles peuvent être organisées en groupes qui répondent à trois questions.
Discipline 1 : Conception du contexte (Fonctionnalités 1 à 5)
Créer un état où Claude sait « de quel projet il s'agit, dans quel but et ce qu'il comprend actuellement ». Si cela échoue, vous devez tout expliquer depuis le début à chaque fois.
Discipline 2 : Conception de la délégation (Fonctionnalités 6 à 14)
Confier structurellement des tâches et de l'autorité à Claude. Au lieu de dire « corrige le bug », vous organisez et transmettez « ce qui est cassé et quelles sont les contraintes », ce qui change la probabilité d'une résolution du premier coup.
Discipline 3 : Conception de l'autonomie (Fonctionnalités 15 à 27)
Concevoir un mécanisme où Claude peut continuer à avancer sans instructions humaines constantes.
Ces trois étapes sont également l'ordre dans lequel vous devez les utiliser. Si le contexte n'est pas défini, la délégation devient bâclée. Si la délégation n'est pas conçue, l'autonomie s'emballe.
Ce dont vous devez être conscient ici, c'est comment changer la structure du « moi qui donne des instructions à Claude chaque matin ». Si vous lancez les mêmes tâches dans le chat chaque matin, l'humain reste le sujet. Lorsque la conception passe à une structure qui fait bouger Claude, ce que vous faites le matin change.
Commençons par examiner les cinq fonctionnalités de la conception du contexte.
Les bases de la conception du contexte
L'objectif de la conception du contexte est de donner à Claude le « contexte de ce projet ». Sans contexte, chaque conversation part d'une page blanche.
La première chose à faire est de lancer `/init`.
Lorsque vous ouvrez un projet pour la première fois, exécutez-le en premier. Claude analyse la structure du code source, les dépendances et les commandes de construction pour générer automatiquement CLAUDE.md. Ce fichier devient le « plan directeur » du projet.
C'est là que beaucoup de gens s'arrêtent. Ils se souviennent d'avoir lancé /init, mais ne savent pas quand il a été mis à jour pour la dernière fois. S'il est laissé tel quel, le contenu de CLAUDE.md s'éloignera de la réalité à mesure que le projet évolue. En partant du principe d'une mise à jour hebdomadaire, Claude peut toujours évoluer dans le contexte le plus récent.
Ensuite, `/statusline` est utile à configurer.
Une ligne de statut apparaîtra en bas de l'écran. Vous pouvez visualiser ce qui s'exécute et quels processus sont actifs. Elle peut également être intégrée aux lignes de statut personnalisées dans Vim ou Neovim, ce qui vous permet de la configurer en fonction de votre environnement d'éditeur existant.
Le troisième est la saisie vocale.
Vous pouvez transmettre des exigences complexes en parlant à l'aide de ⌃⌘Espace sur Mac ou de la saisie vocale native sur iOS et Android. Vous pouvez transmettre de longues instructions comme « Je veux que ce composant bouge comme ceci pour cette raison, mais ne modifie pas les styles existants » sans taper. Comme vous pouvez transmettre les pensées au fur et à mesure qu'elles viennent, cela vous fait gagner du temps passé à organiser vos idées en tapant.
Utilisez `/context` pour vérifier l'état du contexte.
Vous pouvez voir ce qui se trouve actuellement dans la conversation et l'utilisation de la fenêtre de contexte en temps réel. Dans les longues sessions, le contenu du plan directeur initial a tendance à s'estomper. Cette commande vous permet de le surveiller.
Les opérations de réinitialisation pour cela sont `/compact` et `/clear`.
/compact compresse l'intégralité du contexte en un résumé. /clear est une réinitialisation complète. Si vous poursuivez une longue session, les réponses de Claude peuvent devenir vagues. C'est un signe que le contexte est obstrué. En utilisant périodiquement /compact, vous pouvez maintenir la qualité de la sortie.
Avant : Dans la seconde moitié d'une longue session, Claude donne une réponse inadaptée même en disant « suivant la politique de conception discutée précédemment ».
Après : Compresser avec /compact avant de continuer maintient la sortie conforme à la politique.
Les cinq fonctionnalités font une chose : maintenir l'état de Claude « sachant » en tant que conception. Cela devient la base de l'étape suivante, la conception de la délégation.
L'art de transmettre les problèmes
Une fois le contexte défini, l'étape suivante consiste à savoir comment transmettre le problème. La précision de la réponse change complètement selon que vous dites « corrige le bug » ou que vous le transmettez de manière structurée.
Tout d'abord, utilisez le mode plan (`Shift+Tab`).
Avant des changements majeurs, ce mode affiche « uniquement le plan » au lieu d'exécuter. Vous pouvez vérifier ce que Claude a l'intention de changer et dans quel ordre au préalable.
Au lieu de corriger les erreurs après qu'elles se soient produites, vous pouvez signaler « c'est faux » au stade de la planification. Intégrer cette seule étape dans votre conception change considérablement la fréquence des changements inattendus. En continuant à l'utiliser, vous réaliserez que cela réduit l'effort de vérification du « pourquoi ce fichier a-t-il été réécrit ? » après coup.
Deuxièmement, la structuration des problèmes, des contraintes et du contexte.
Si vous dites simplement « corrige le bug », Claude essaie de combler les hypothèses lui-même. Si ces hypothèses sont erronées, la solution le sera aussi.
Le format officiellement recommandé est d'écrire « ce qui est cassé » sur la première ligne, et « ce qui a été essayé, les contraintes et le format de sortie attendu » à partir de la deuxième ligne. Le simple fait de transmettre dans ce format modifie le taux de résolutions du premier coup. La façon dont vous transmettez le problème devient elle-même une compétence.
Troisièmement, `AskUserQuestion`.
Il s'agit d'une fonctionnalité où Claude demande des éclaircissements avant de procéder lorsqu'il rencontre des exigences ambiguës. Les reprises causées par une mise en œuvre basée sur des exigences vagues se produisent souvent lorsque cette fonctionnalité n'est pas utilisée. C'est une conception qui paie le coût de la confirmation avant la mise en œuvre.
Quatrièmement, l'étape d'auto-vérification.
À la fin d'une tâche, dites-lui d'« exécuter les tests et de confirmer que la construction réussit avant de terminer ». Au lieu d'ajouter cela manuellement à chaque fois, l'écrire dans CLAUDE.md garantit qu'il s'exécute automatiquement à la fin de chaque tâche. Au lieu que Claude s'arrête dans un état où les choses ne fonctionnent pas après un changement, la boucle incluant la vérification est terminée en une seule tâche.
Prendre des mesures proactives avec le mode plan et automatiser les mesures réactives avec l'auto-vérification. La structure du flux de développement change au moment où ces deux éléments sont intégrés dans la conception.
Dans le chapitre suivant, nous examinerons la conception de la délégation de tâches continues à Claude.
Concevoir la délégation
Dans les chapitres précédents, nous avons organisé la façon de communiquer avec Claude et comment lui permettre de conserver la mémoire. La prochaine étape consiste à changer « qui devient le sujet ».
10. Sous-agents
Si un humain gère les procédures lors de longues tâches, il finira inévitablement par être bloqué. Dire constamment « fais ceci ensuite, puis fais cela quand tu auras fini » signifie que l'humain, et non Claude, gère la coordination.
En utilisant les outils TodoWrite ou Task, Claude décompose les tâches en sous-tâches et les exécute en parallèle. En termes officiels, il s'agit d'une « exécution simultanée de sous-agents » — une structure où plusieurs Claude enfants se déplacent simultanément. Différents Claude exécutent la recherche, la mise en œuvre et les tests en même temps. Les humains n'ont pas besoin de détenir la procédure.
11. Compétences personnalisées (fichiers de modèle de flux de travail)
Placer des fichiers Markdown dans le répertoire .claude/commands/ vous permet d'appeler des ensembles d'instructions avec /nom-de-commande. Dans le contexte de Swarm, il est plus facile de considérer cela comme des « SKILL.md (fichiers de modèle de flux de travail) ».
Avant : Écrire « Veuillez effectuer une étude de la concurrence. Les étapes sont 1, 2, 3... » à chaque fois.
Après : Taper simplement /competitive-research en une seule ligne.
Le temps passé à écrire les mêmes instructions à plusieurs reprises disparaît. S'il est partagé avec une équipe, il devient un modèle où n'importe qui peut obtenir la même qualité de sortie.
12. Sélection du modèle
Vous pouvez changer de modèle au sein d'une session en appuyant sur Alt+P. Une utilisation réaliste en trois étapes est : les modèles à haut raisonnement pour les phases de conception et conceptuelles, les modèles légers pour la mise en œuvre simple et les modèles de milieu de gamme pour le débogage.
Faire correspondre la puissance du modèle au poids du processus améliore à la fois l'efficacité des coûts et la vitesse de réponse.
13. Mises à jour automatiques de CLAUDE.md
Si vous dites à Claude d'« ajouter ce que vous avez appris dans ce projet à CLAUDE.md », Claude mettra à jour CLAUDE.md lui-même. C'est une structure où le plan directeur grandit tout seul.
En ajoutant cette commande une fois par semaine, CLAUDE.md devient un « document vivant ». Même si les humains n'écrivent pas de réflexions, Claude accumule ce qu'il a appris.
14. Liaison de fichiers externes
Vous pouvez transmettre des fichiers, des URL ou des problèmes comme contexte en utilisant @{chemin_fichier}. C'est un mécanisme pour accomplir « lire ce fichier avant de travailler » en une seule ligne.
Avant : Copier et coller le contenu du fichier dans l'invite.
Après : Écrire simplement « Vérifier les paramètres en se référant à @src/config.yaml ».
Concevoir la délégation signifie créer un système qui confie le sujet à Claude. Lorsque les procédures, les modèles, les références et la mémoire sont tous en place, les humains n'ont plus qu'à penser à « quoi créer ».
Cependant, à mesure que la délégation augmente, le risque que « Claude aille dans une direction différente de celle prévue » augmente également. Dans le chapitre suivant, nous verrons comment arrêter cette dérive rapidement.
Arrêter la dérive rapidement
À mesure que la délégation à Claude augmente, un problème devient plus probable : se rendre compte qu'il est allé dans une direction complètement différente de celle prévue. Nous appelons cela la dérive.
La dérive n'est pas quelque chose à corriger plus tard ; elle peut être évitée en prenant des mesures de conception proactives.
15. Arrêt immédiat
Si vous sentez que la sortie va dans une direction manifestement erronée, vous pouvez l'arrêter immédiatement avec la touche Échap. « Je vais le réparer après l'avoir fini » est une erreur. Plus la génération progresse, plus le coût de correction est élevé. S'arrêter à mi-chemin et corriger l'invite permet d'économiser du temps et des tokens.
Si vous pensez intuitivement que quelque chose ne va pas, arrêtez-le sans hésitation. La rapidité de ce jugement a un impact direct sur la précision.
16. Demander la première sortie comme preuve
Une conception proactive consiste à dire « montre-moi d'abord la première sortie, et je déciderai si je continue » avant de commencer le travail.
Au lieu de le laisser passer 10 minutes dans la mauvaise direction, confirmez avec la première sortie avant de le laisser s'exécuter. C'est l'idée de tuer la dérive dans l'œuf. C'est essentiel pour les tâches de longue durée ou le travail commençant par des directions ambiguës.
Avant de dire « je te laisse le reste », insérez « laisse-moi vérifier le début ». Ce n'est qu'une étape, mais ce geste proactif change le résultat.
17. Crochets de notification
Regarder fixement l'écran en attendant la fin d'une longue tâche est une perte de temps. En plaçant un script dans ~/.claude/hooks/, vous pouvez recevoir des notifications de bureau lorsqu'une tâche est terminée.
Configurez-le une fois. À partir de là, même si vous faites un autre travail, Claude vous avertira quand il aura terminé. C'est une conception qui élimine l'acte d'attendre.
18. Transmission de captures d'écran
Expliquer les bugs de l'interface utilisateur avec des mots est étonnamment difficile. Au lieu de dire verbalement « une erreur rouge est apparue en haut à gauche et le bouton ne peut pas être enfoncé », transmettre une capture d'écran est plus rapide.
Claude reçoit l'image et renvoie le contenu de l'erreur, la cause et les suggestions de correction tels quels. C'est terminé avec « regarde cet écran ».
Les 18 fonctionnalités présentées jusqu'à présent sont toutes basées sur la prémisse d'une seule personne opérant. Dans le chapitre suivant, nous entrons dans la structure de « l'utilisation en équipe », où plusieurs Claude s'exécutent en parallèle et s'intègrent.
Opération parallèle et intégration
En utilisant Claude Code comme un outil de chat, vous ne pouvez pas commencer la tâche suivante tant que l'une n'est pas terminée. Mais en changeant la conception, vous pouvez créer une structure où plusieurs Claude se déplacent simultanément.
Commencez par l'intégration de Chrome DevTools. Puisque vous pouvez transmettre les journaux d'erreurs du navigateur et les journaux réseau directement à Claude Code, vous n'avez plus besoin d'expliquer verbalement des situations comme « il y a une erreur rouge dans la console mais je ne sais pas ce qui se passe ». La documentation officielle a une page dédiée à cela, le positionnant comme la passerelle vers le débogage.
La gestion des sessions change également. Vous pouvez reprendre la dernière session telle quelle avec claude --continue, ou choisir parmi une liste de sessions avec claude --resume. De plus, en nommant les sessions avec /rename, vous pouvez gérer plusieurs tâches en parallèle avec la même sensation que les branches Git. En utilisant des sessions nommées « Auth », « Paiement » et « Tableau de bord », le coût du changement de contexte devient presque nul.
Et le cœur de l'opération parallèle est la combinaison avec git worktrees. Taper claude --worktree feature-auth lance une session où la branche est complètement isolée par l'arbre de travail. Si vous exécutez Auth, Paiement et Tableau de bord dans des arbres de travail séparés, trois Claude procéderont au développement en parallèle. Comme chacun est dans un espace de travail indépendant, aucun conflit ne se produit. La structure pour terminer une semaine de développement en un jour est établie ici en tant que conception.
Il est également nécessaire d'organiser les réflexions sur MCP. Un serveur MCP n'est pas toujours la solution optimale. La documentation officielle indique que « les outils CLI sont le moyen le plus efficace en termes de contexte pour interagir avec les services externes », et les outils CLI comme gh ou aws sont réputés pour avoir une efficacité de contexte élevée et sont moins susceptibles d'atteindre les limites de débit. Avec seulement la commande gh, Claude Code peut créer, mettre à jour et fermer des problèmes GitHub de manière autonome. Avoir un axe de jugement pour vérifier si un outil CLI peut être utilisé avant d'ajouter un MCP maintient la conception simple.
Lorsque la conception parallèle est possible, les humains n'ont plus besoin de gérer la séquence. En effet, la conception passe à la transmission de plusieurs sujets à Claude simultanément. Ensuite, nous ferons évoluer ce traitement parallèle conçu en un système qui continue de bouger même lorsque vous êtes loin de votre bureau.
Opération autonome
La question suivante après la conception parallèle est : « Où dois-je être pendant ce temps ? » Lorsque l'opération autonome est conçue, un état est créé où le travail progresse même sans présence humaine.
/loop est une fonctionnalité qui exécute une interrogation automatique au sein d'une session. L'explication officielle est « Interrogation rapide pendant qu'une session est ouverte », et elle répète les opérations spécifiées tant que la session est ouverte. L'utilisation de --resume ou --continue vous permet de reprendre des sessions qui n'ont pas expiré, et selon les rapports d'expérience dans l'article original, des cas d'opération sans équipage allant jusqu'à trois jours ont été signalés. Bien que nous n'ayons pas confirmé ce nombre de jours directement auprès de sources officielles, cela fonctionne certainement comme un point d'entrée pour une opération autonome de longue durée.
La télécommande, ajoutée au premier trimestre 2026, est une fonctionnalité permettant d'opérer des sessions Claude Code s'exécutant localement à partir d'un smartphone ou d'un navigateur PC. Alors que le code reste local, seuls les messages sont échangés via un canal crypté. Il a été publié en tant qu'aperçu de recherche en février 2026. Un scénario est établi où le Claude Code local continue de bouger simplement en envoyant « vérifie si les tests ont réussi » depuis un smartphone pendant que vous êtes dehors.
Les requêtes en langage naturel aux bases de données peuvent également être intégrées à la conception. La connexion à SQLite, PostgreSQL ou MySQL via MCP vous permet de récupérer des données en utilisant le français (ou l'anglais) comme « dis-moi les utilisateurs inscrits la semaine dernière ». Le guide officiel suggère d'exécuter claude mcp add pour connecter des outils externes comme votre base de données, vous permettant de déléguer les routines de confirmation de données à Claude sans écrire de SQL.
Il existe également quatre fonctionnalités pour contrôler la profondeur de la réflexion. ultrathink déclenche une réflexion étendue allant jusqu'à 31 999 tokens simplement en incluant ce mot-clé dans l'invite. Il existe une hiérarchie : think est de 4 000 tokens, megathink est de 10 000 tokens et ultrathink est de 31 999 tokens. La bonne façon de l'utiliser est uniquement pour les 10 % de problèmes vraiment difficiles, tels que les décisions d'architecture complexes, les implémentations de sécurité, l'optimisation des performances et la refactorisation à grande échelle. L'utiliser pour chaque requête gonflera les coûts inutilement.
/effort ultracode est un paramètre pour activer le raisonnement xhigh et les flux de travail dynamiques pour l'ensemble de la session. Alors que ultrathink est un mot-clé à usage unique, ultracode reste actif pendant toute la session. Il convient aux « travaux lourds à l'échelle de la session » comme l'audit d'une base de code entière, la migration de centaines de fichiers ou les tâches à haut risque. Cependant, comme les coûts en tokens augmentent considérablement, discerner la situation détermine l'efficacité.
Claude Code, qui a commencé par taper dans un chat pour le faire bouger, a atteint la passerelle d'un système qui détecte les événements et se déplace de manière autonome. Au lieu que les humains le fassent bouger, la conception fait bouger Claude. Ensuite, nous confirmerons où la différence de productivité se situe essentiellement à travers toutes ces fonctionnalités.
Pourquoi les résultats diffèrent avec le même Claude Code
Les personnes qui développent rapidement n'ont pas nécessairement de capacités spéciales. Elles conçoivent simplement de manière plus systématique.
Par exemple, considérez la situation de l'exécution de /init. Même si la même commande est tapée, la qualité de la sortie plusieurs mois plus tard sera complètement différente entre un CLAUDE.md qui est mis à jour chaque semaine et un autre qui a été laissé depuis la configuration. En effet, la fraîcheur et la précision du contexte que Claude lit ont un impact direct sur la qualité de la sortie.
Pour utiliser une analogie culinaire, le niveau de cuisine est déterminé davantage par la façon dont la cuisine elle-même est organisée que par les ingrédients utilisés. Les performances du modèle de Claude sont fournies de manière égale à tous les utilisateurs. La différence réside dans la précision de ces trois points : comment le contexte a été organisé, comment les instructions ont été systématisées et comment l'opération autonome a été conçue.
Avant de discuter du « modèle à utiliser », essayez de vérifier quand votre CLAUDE.md actuel a été mis à jour pour la dernière fois. Cela vous indiquera l'état actuel de votre conception.
Alors, par où devriez-vous réellement commencer ? Dans le chapitre suivant, nous organiserons une séquence d'introduction étape par étape.
Par où commencer : un guide d'introduction étape par étape
Vous n'êtes pas obligé d'essayer de vous souvenir des 27 à la fois.
Au cours de la première semaine, limitez-vous à quatre.
- Créez une carte du projet avec
/init. - Compressez périodiquement le contexte avec
/compact. - Séparez l'exploration et l'exécution avec le mode plan (
Shift+Tab). - Transmettez les étapes d'auto-vérification (tests, builds) à Claude.
Avec seulement ces quatre éléments, la qualité de la session changera fondamentalement. Comme Claude commence à bouger avec une compréhension précise de « ce qui doit être fait », la quantité de reprises diminuera visiblement.
À partir de la deuxième semaine, ajoutez la conception de la délégation sur cette base. Résumez les instructions dans un format réutilisable avec les compétences personnalisées, ajustez le poids et la vitesse du traitement avec la sélection du modèle (Alt+P) et établissez l'habitude de mettre à jour CLAUDE.md chaque semaine. C'est l'étape où vous transformez les instructions de « quelque chose d'écrit à chaque fois » en « quelque chose qui s'accumule ».
Après un mois, passez aux sous-agents, git worktrees et aux sessions parallèles. Vous aurez un système où vous pourrez vous concentrer sur la conception et la confirmation tout en développant plusieurs fonctionnalités simultanément.
ultrathink et ultracode sont des outils à utiliser pour la première fois dans ce flux lorsque vous rencontrez des « problèmes vraiment difficiles ». Ce ne sont pas des outils à sortir pour chaque problème.
En suivant ces étapes, vous comprendrez par l'expérience « pourquoi chaque fonctionnalité est nécessaire ». Veuillez commencer par les quatre éléments de la première semaine.
Tout change au moment où vous le traitez comme une cible de conception
Au moment où vous commencez à considérer Claude Code comme une cible de conception, la qualité de la session change fondamentalement.
Je résumerai le contenu présenté dans cet article sous une forme que vous pouvez enregistrer et consulter.
- Les quatre éléments —
/init+/compact+ mode plan + auto-vérification — sont les conceptions de base les plus fondamentales. - Systématisez la réutilisation des instructions avec les compétences personnalisées et faites évoluer
CLAUDE.mdcomme un « plan directeur vivant » mis à jour chaque semaine. - Lorsque vous commencez à utiliser des sous-agents, la productivité passe de l'addition à la multiplication.
- La règle absolue est de détecter la dérive tôt et de s'arrêter immédiatement. Demandez toujours une preuve dans la première sortie.
- Vous pouvez développer plusieurs fonctionnalités simultanément avec
git worktrees+ sessions parallèles. - Mettez en place une opération autonome avec
/loop, et confirmez ou donnez des instructions depuis un smartphone avec la télécommande. ultrathinkest un outil dédié aux « 10 % vraiment difficiles ». Ce n'est pas pour tous les problèmes.
Si vous essayez ne serait-ce qu'une des fonctionnalités mentionnées dans cet article, votre relation avec Claude Code commencera progressivement à changer.
À ceux qui s'intéressent aux agents IA
Swarm (@swarm_japan) partage les philosophies de conception essentielles et les cas d'utilisation commerciale des agents.
Suivez-nous pour acquérir les connaissances métier nécessaires à l'ère des agents IA 👇
★ Explication des dernières informations sur les agents IA d'un point de vue unique
★ Présentation de cas d'utilisation commerciale des agents
★ Publication de savoir-faire original
Si cela vous intéresse, suivez-nous et venez voir ! 👀
