Le père de Claude Code révèle : comment transformer Claude en votre « petite équipe de développement virtuelle » ?

null

Texte original : Boris Cherny, développeur de Claude Code

Compilation et organisation : Xiaohu AI

Vous avez peut-être entendu parler de Claude Code et même utilisé pour écrire du code et modifier de la documentation. Mais vous êtes-vous déjà demandé : comment l’IA changerait-elle votre façon de travailler si ce n’est pas un « outil temporaire » mais un membre à part entière de votre processus de développement, ou même un système de collaboration automatisé ?

Boris Cherny, le père de Claude Code, a écrit un tweet très détaillé sur la façon dont il utilise efficacement l’outil et comment lui et son équipe intègrent Claude dans l’ensemble du processus d’ingénierie en pratique.

Cet article fera un résumé systématique et une interprétation populaire de son expérience.

Comment Boris a-t-il fait de l’IA un partenaire d’automatisation dans son flux de travail ?

Points clés :

Il a présenté son flux de travail, notamment :

Comment utiliser Claude :

Faites tourner plusieurs Clés ensemble : ouvrez 5~10 sessions sur le terminal et la page web pour gérer les tâches en parallèle, et utilisez aussi votre Claude sur votre téléphone.

Ne modifie pas aveuglément les réglages par défaut : Claude fonctionne dès la sortie de la boîte, donc pas besoin de configurations compliquées.

Utilisez le modèle le plus puissant (Opus 4.5) : un peu plus lent, mais plus intelligent et moins sans problème.

Planifiez avant d’écrire du code (mode Planification) : Laissez Claude vous aider à réfléchir clairement avant d’écrire, avec un taux de réussite élevé.

Après avoir généré du code, utilisez des outils pour vérifier la mise en forme afin d’éviter les erreurs.

Comment rendre Claude de plus en plus intelligent :

L’équipe maintient une « base de connaissances » : chaque fois que Claude écrit une erreur, il ajoute de l’expérience et ne recommence plus la fois suivante.

Former automatiquement Claude lors de l’écriture de PR : Laissez-le lire les PR et apprendre de nouveaux usages ou spécifications.

Les commandes couramment utilisées deviennent des ordres de barre, et Claude peut les appeler automatiquement, évitant ainsi un travail répétitif.

Utilisez des « sous-agents » pour gérer certaines tâches fixes, telles que la simplification du code, la vérification des fonctions, etc.

Comment gérer les autorisations :

Au lieu de sauter les permissions, configurez les commandes sécurisées pour qu’elles passent automatiquement.

Synchronisez les flux de travail de Claude sur plusieurs appareils (web, terminal, mobile).

Le point le plus important :

Assurez-vous de fournir à Claude un « mécanisme de validation » afin qu’il puisse confirmer que ce qu’il écrit est correct.

Par exemple, Claude lance automatiquement des tests, ouvre le navigateur pour tester les pages web et vérifie si la fonction fonctionne.

Claude Code est un « partenaire », pas un « outil »

Boris commence par transmettre une idée centrale : Claude Code n’est pas un outil statique, mais un compagnon intelligent capable de travailler avec vous, d’apprendre continuellement et de grandir ensemble.

Il ne nécessite pas beaucoup de configuration compliquée et est puissant dès la sortie de la boîte. Mais si vous êtes prêt à investir du temps pour construire de meilleures façons de l’utiliser, les gains d’efficacité qu’il peut apporter sont exponentiels.

Choix de modèles : choisissez le plus intelligent, pas le plus rapide

Boris utilise le modèle phare de Claude, Opus 4.5 + Mindset (« avec réflexion »), pour toutes les tâches de développement.

Bien que ce modèle soit plus grand et plus lent que Sonnet, mais :

C’est plus complet

Mieux avec les outils

Il n’y a pas besoin de directives répétées, moins de communication aller-retour

Dans l’ensemble, cela fait gagner plus de temps que d’utiliser des modèles rapides

Éclaircissement : La véritable efficacité de production ne réside pas dans la rapidité d’exécution, mais dans « moins d’erreurs, moins de retravails et moins d’explications répétitives ».

1. Mode Planification : Écrivez du code avec l’IA, ne vous précipitez pas pour la laisser « écrire »

Quand on ouvre Claude, beaucoup de gens tapent intuitivement « écris une interface pour moi » ou « refactore ce code »… Claude en « écrit aussi » généralement, mais il s’égarera souvent, rate la logique, ou comprend même mal les exigences.

La première étape de Boris n’a jamais demandé à Claude d’écrire du code. Il utilise le modèle Plan – il travaille avec Claude pour développer d’abord l’idée de mise en œuvre, puis passe à l’étape d’exécution.

Comment a-t-il fait ?

Lors du lancement d’une PR, Boris ne laisse pas Claude écrire le code directement, mais utilise le mode Plan :

1. Décrire l’objectif

2. Faire un plan avec Claude

3. Confirmer chaque étape

4. Laisser Claude écrire à la main

Chaque fois qu’il doit implémenter une nouvelle fonctionnalité, comme « ajouter la limitation de la vitesse à une API », il confirmera avec Claude étape par étape :

Est-ce implémenté avec un middleware, ou est-ce logiquement intégré ?

La configuration actuelle de throttling doit-elle être modifiée dynamiquement ?

Avez-vous besoin de journaux ? Qu’est-ce qui est retourné lorsqu’il tombe en panne ?

Ce processus de « négociation de plan » ressemble à deux personnes dessinant ensemble des « plans de construction ».

Une fois que Claude comprend l’objectif, Boris active le mode « acceptation automatique des modifications », qui lui permet de modifier le code, de soumettre des PR, et parfois même d’éliminer le besoin de confirmation manuelle.

« La qualité du code de Claude dépend de votre accord avant d’écrire le code. » —— Boris

Révélation : Au lieu de corriger sans cesse les erreurs de Claude, traçons une feuille de route claire dès le départ.

Résumé

Le modèle du Plan n’est pas une perte de temps, mais une pré-négociation pour une exécution stable. Peu importe la puissance de l’IA, elle doit aussi être « vous le dis-le clairement ».

2. Multi-Claude Parallel : Pas une IA, mais une équipe de développement virtuelle

Boris n’a pas utilisé un seul Claude. Sa routine quotidienne est la suivante :

Ouvrez 5 Claudes locaux dans le terminal, et les sessions sont assignées à différentes tâches (comme le refactoring, l’écriture de tests et le bug).

Ouvrez 5 à 10 autres Claudes dans le navigateur, parallèlement au niveau local

Utilisez l’application Claude iOS sur votre téléphone pour lancer une tâche à tout moment

Chaque instance Claude est comme un « assistant dédié » : certaines sont responsables de l’écriture du code, d’autres de la complétion des documents, et d’autres restent longtemps en arrière-plan pour effectuer des tâches.

Il avait même configuré des notifications système pour être alerté dès que Claude attendrait une information.

Pourquoi faire ça ?

Le contexte de Claude est local et ne convient pas à « une fenêtre suffit à tout ». Boris divise Claude en plusieurs caractères pour travailler en parallèle, réduisant les temps d’attente et « interférant avec la mémoire » sur l’autre.

Il se rappelle aussi à travers les notifications système : « Claude 4 attend votre réponse » et « Claude 1 a fini de tester », gérant ces IA comme si elles géraient un système multithread.

Compréhension de l’analogie

Imaginez-vous assis à côté de cinq stagiaires intelligents, chacun chargé d’une tâche. Vous n’êtes pas obligé de tout faire jusqu’au bout, il suffit de « couper les gens » aux moments critiques et de faire avancer la tâche sans encombre.

Implications : Utiliser Claude comme plusieurs « assistants virtuels » pour effectuer différentes tâches peut réduire considérablement les temps d’attente et les coûts de changement de contexte.

3. Commandes de barrage : Transformez ce que vous faites chaque jour en raccourcis pour Claude

Il existe certains workflows que nous faisons des dizaines de fois par jour :

Modifier le code → commit → push → créer une PR

Vérifiez le statut de la version → informez l’équipe des problèmes de mise à jour →

Synchronisez les modifications de plusieurs sessions sur le web et sur site

Boris ne veut pas inciter Claude à chaque fois : « S’il te plaît, engage-toi, puis pousse, puis construis une image publique… »

Il résume ces opérations dans des commandes Slash, telles que :

/commit-push-pr

Derrière ces commandes se trouve la logique de script Bash, stockée dans le dossier .claude/commands/, ajoutée à la gestion de Git et utilisée par les membres de l’équipe.

Comment Claude utilise-t-il ces commandes ?

Lorsque Claude rencontre cette commande, elle ne se contente pas d’« exécuter la commande », elle connaît le flux de travail qu’elle représente et peut automatiquement exécuter des étapes intermédiaires, pré-remplir les paramètres et éviter la communication répétée.

Comprenez les points clés

La commande Slash est comme le « bouton auto » que l’on installe pour Claude. Vous l’entraînez à comprendre un flux de tâches, puis il peut l’exécuter d’un seul clic.

« Non seulement je peux gagner du temps avec les commandes, mais Claude aussi. » —— Boris

Révélation : Ne répétez pas l’invite d’entrée à chaque fois, abstraite les tâches à haute fréquence en commandes, vous et Claude pouvez travailler ensemble pour « automatiser ».

4. Base de connaissances de l’équipe : Claude ne s’appuie pas sur les incitations pour apprendre, mais sur les gènes de connaissances maintenus par l’équipe

L’équipe de Boris maintient une base de connaissances .claude et rejoint la gestion Git.

C’est comme un « Wikipédia interne » pour Claude, enregistrant :

Quelle est la bonne façon d’écrire

Quelles sont les meilleures pratiques convenues par l’équipe

Quels problèmes doivent être corrigés ?

Claude consulte automatiquement cette base de connaissances pour comprendre le contexte et déterminer le style de code.

Que faire quand Claude fait quelque chose de mal ?

Chaque fois que Claude comprend mal ou écrit mal la logique, il ajoute une leçon.

Chaque équipe maintient sa propre version.

Tout le monde collabore à la révision, et Claude prend des décisions en temps réel à partir de cette base de connaissances.

Par exemple :

Si Claude continue d’écrire la mauvaise logique de pagination, l’équipe n’a qu’à écrire la bonne norme de pagination dans la base de connaissances, et chaque utilisateur en bénéficiera automatiquement à l’avenir.

L’approche de Boris : ne pas le gronder, ne pas l’éteindre, mais « entraînez-vous une fois » :

Nous n’écrivons pas ce code de cette façon, mais l’ajoutons à la base de connaissances

Claude ne refera pas cette erreur la prochaine fois.

De plus, ce mécanisme n’est pas maintenu uniquement par Boris, mais est apporté et modifié chaque semaine par toute l’équipe.

Éveil : Avec l’IA, pas tout le monde seul, mais pour construire un système de « mémoire collective ».

5. Mécanisme d’apprentissage automatique : la PR elle-même est la « donnée d’entraînement » de Claude

Boris @Claude souvent sur les PR lors des revues de code, telles que :

@.claude a ajouté cette fonction à la base de connaissances

En collaboration avec GitHub Actions, Claude apprend automatiquement l’intention derrière ce changement et met à jour ses connaissances internes.

C’est similaire à « entraîner Claude en continu », où chaque critique non seulement correspond au code mais améliore aussi les capacités de l’IA.

Ce n’est plus du « post-maintenance » mais intègre les mécanismes d’apprentissage de l’IA dans la collaboration quotidienne.

L’équipe utilise les relations publiques pour améliorer la qualité du code, et Claude améliore les connaissances en même temps.

Implications : Les relations publiques ne sont pas seulement un processus de relecture de code, mais une opportunité pour les outils d’IA de se faire évoluer eux-mêmes.

6. Sous-agents : Laissez Claude effectuer des tâches complexes de manière modulaire

En plus du processus principal de tâche, Boris définit également un certain nombre de sous-agents pour gérer des tâches secondaires courantes.

Les sous-agents sont des modules qui s’exécutent automatiquement, tels que :

code-simplifier : simplifie automatiquement la structure après que Claude ait fini d’écrire le code

verify-app : Effectuez un test complet pour vérifier que le nouveau code est disponible

Analyseur de logs : Analyse les journaux d’erreur pour localiser rapidement les problèmes

Ces sous-agents se connectent automatiquement aux flux de travail de Claude comme des plugins, s’exécutant automatiquement et de manière collaborative, sans avoir besoin d’invites répétées.

Révélation : Le sous-agent est le « membre de l’équipe » de Claude, et Claude est promu d’assistant à « commandant de projet ».

Claude n’est pas qu’une seule personne, mais un petit manager que l’on peut diriger en équipe.

7. Paragraphe supplémentaire 1 : Crochet PostToolUse - le dernier gardien de la mise en forme du code

Ce n’est pas facile de faire écrire tout le monde dans un style uniforme dans une équipe. Bien que Claude ait de grandes capacités de génération, il présentera inévitablement des défauts de détail tels que de mauvaises indentations et plus de lignes blanches.

Ce que fait Boris, c’est mettre en place un crochet PostToolUse -

En termes simples, c’est le « crochet de post-traitement » que Claude appelle automatiquement après « avoir terminé la tâche ».

Son rôle inclut :

Corriger automatiquement la mise en forme du code

Notes supplémentaires manquantes

Gérer les erreurs de peluches pour éviter les blocages de CI

Cette étape est généralement simple, mais cruciale. Tout comme relancer Grammarly après avoir écrit un article, le travail soumis est stable et ordonné.

Pour les outils d’IA, la clé du succès ne réside souvent pas dans la puissance générative, mais dans la capacité à finir.

8. Gestion des permissions : pré-autoriser au lieu de sauter

Boris précise qu’il n’utilise pas --dangerly-skip-permissions-- un paramètre de Claude Code qui peut passer toutes les invites d’autorisation lors de l’exécution de commandes.

Cela semble pratique, mais cela peut aussi être dangereux, comme supprimer accidentellement des fichiers, exécuter de mauvais scripts, etc.

Ses alternatives sont :

1. Utiliser la commande /permissions pour déclarer explicitement quelles commandes sont fiables

2. Écrire ces configurations d’autorisations en .claude/settings.json

3. Partagez ces paramètres de sécurité avec toute votre équipe

C’est comme pré-ouvrir un lot d’opérations de « liste blanche » pour Claude, telles que :

« préCommandesApprouvées » : [

« Engage-toi »,

« build de course npm »,

« le plus pyre »

]

Claude exécute ces actions sans les interrompre à chaque fois.

Ce mécanisme d’autorisation est conçu pour ressembler davantage à un système d’exploitation d’équipe qu’à un outil autonome. Il pré-autorise les commandes bash communes et sécurisées avec la commande /permissions, qui sont sauvegardées en .claude/settings.json et partagées par l’équipe.

Implications : l’automatisation de l’IA ne signifie pas devenir incontrôlable. Intégrer des politiques de sécurité dans le processus d’automatisation lui-même, c’est vraiment de l’ingénierie.

9. Liaison multi-outil : Claude = robot multifonctionnel

Boris ne laisse pas Claude écrire du code localement. Il a configuré Claude pour accéder à plusieurs plateformes centrales via MCP (un module de service central) :

Notifications automatiques Slack (comme les résultats de compilation)

Requête des données BigQuery (comme les métriques de comportement utilisateur)

Extraction des journaux de sentinelle (par exemple, suivi d’anomalies en ligne)

Comment y parvenir ?

La configuration de MCP est enregistrée dans .mcp.json

Claude lit les configurations à l’exécution, effectuant de manière autonome des tâches multiplateformes

Toute l’équipe partage un ensemble de configurations

Tout cela se fait grâce à l’intégration du MCP (système de contrôle central de Claude) avec Claude, et la configuration est sauvegardée en .mcp.json.

Claude est comme un assistant robotique qui vous aide à :

« Terminer l’écriture du code → soumettre un rapport de → de revue des rapports de → Notification de l’assurance qualité → journal de rapport ».

Ce n’est plus un outil d’IA au sens traditionnel, mais un centre névralgique pour les systèmes d’ingénierie.

Révélation : Ne laissez pas l’IA fonctionner uniquement « dans l’éditeur »,

Cela peut être un planificateur dans tout votre écosystème système.

10. Traitement asynchrone des longues tâches : agent en arrière-plan + plugin + hook

Dans de vrais projets, Claude doit parfois gérer de longues tâches, telles que :

Build + Test + Deploy

Générer des rapports + envoyer des e-mails

Le script de migration des données s’exécute

L’approche de Boris est très conçue :

Trois façons de gérer les tâches longues :

1. Après Claude terminé, utiliser l’agent en arrière-plan pour vérifier les résultats

2. Utiliser Arrêt du Crochet pour déclencher automatiquement les actions de suivi à la fin de la tâche

3. Utiliser le plugin ralph-wiggum (proposé par @GeoffreyHuntley) pour gérer les longs états de processus

Dans ces scénarios, Boris utilise :

–permission-mode=n’InterrogePas

Ou mettez les tâches dans un bac à sable pour éviter d’interrompre le processus à cause des demandes d’autorisation.

Claude n’est pas un « observateur constant », mais un collaborateur en qui vous pouvez avoir confiance pour votre hébergement.

Implications : Les outils d’IA ne conviennent pas seulement aux opérations courtes et rapides, mais aussi aux processus complexes et à long terme – à condition de construire un « mécanisme d’hébergement » pour eux.

11. Mécanisme de vérification automatique : la valeur de sortie de Claude n’en vaut pas la peine, elle dépend de sa capacité à se vérifier elle-même

L’un des aspects les plus importants de l’expérience de Boris est :

Tout résultat produit par Claude doit être équipé d’un « mécanisme de validation » pour vérifier sa justesse.

Il ajoutera un script de validation ou un hook à Claude :

Après avoir écrit le code, Claude exécute automatiquement des cas de test pour vérifier que le code est correct

Simulez les interactions utilisateur dans le navigateur pour valider l’expérience frontale

Comparer automatiquement les journaux et les métriques avant et après l’opération

Si cela ne passe pas, Claude modifiera automatiquement et réexécutera. jusqu’à ce qu’elle passe.

C’est comme si Claude avait lui-même apporté un « système de retour en boucle fermée ».

Cela améliore non seulement la qualité, mais réduit aussi la charge cognitive sur les personnes.

Enlightenment : Ce qui détermine vraiment la qualité des résultats de l’IA, ce n’est pas le nombre de paramètres du modèle, mais si vous avez conçu un « mécanisme de vérification des résultats » pour celui-ci.

Résumé : Au lieu de remplacer les humains, laissez l’IA travailler ensemble comme les humains

L’approche de Boris ne repose pas sur des « fonctionnalités cachées » ou une technologie obscure, mais utilise Claude de manière ingénieuse pour la faire passer d’un « outil de chat » à un composant efficace du système fonctionnel.

Son utilisation de Claude présente plusieurs caractéristiques principales :

Parallélisme multi-sessions : division plus claire des tâches et plus grande efficacité

Plan d’abord : Le mode Plan améliore l’alignement des objectifs de Claude

Support des systèmes de connaissances : L’équipe maintient conjointement la base de connaissances en IA et itère continuellement

Automatisation des tâches : commandes obliques + sous-agents, permettant à Claude de fonctionner comme un moteur de processus

Mécanisme de rétroaction en boucle fermée : chaque sortie de Claude dispose d’une logique de vérification, garantissant une sortie stable et fiable

En fait, l’approche de Boris montre une nouvelle façon d’utiliser l’IA :

Faire passer Claude d’un « assistant conversationnel » à un « système de programmation automatisé »

Transformer l’accumulation de connaissances du cerveau humain en une base de connaissances pour l’IA

Transformer les processus, passant d’opérations manuelles répétitives à des flux de travail automatisés scriptés, modulaires et collaboratifs

Cette approche ne repose pas sur la magie noire, mais est une manifestation de la capacité d’ingénierie. Vous pouvez aussi apprendre à utiliser Claude ou d’autres outils d’IA de manière plus efficace et intelligente.

Si vous avez souvent l’impression que « il en sait un peu mais est peu fiable » ou « je dois toujours corriger le code que j’écris », le problème ne vient peut-être pas de Claude, mais du fait que vous ne lui avez pas donné un mécanisme de collaboration mature.

Claude peut être un stagiaire qualifié ou un partenaire d’ingénierie stable et fiable, selon la façon dont vous l’utilisez.