La Règle d'Or que le Créateur de Claude Code ne Transgresse Jamais

AAI LABS
Computing/SoftwareAdult EducationInternet Technology

Transcript

00:00:00Voici Boris,
00:00:00et quand les gens rencontrent des difficultés avec Claude Code,
00:00:02ils lui demandent comment l'utiliser.
00:00:04Mais pourquoi lui poseraient-ils la question ?
00:00:05C'est parce que Boris travaille chez Anthropic et c'est lui qui a créé Claude Code.
00:00:09Même s'il dit que sa configuration est assez simple,
00:00:11ce n'est pas le cas.
00:00:12C'est juste sa perspective.
00:00:13Ce qui est simple pour lui peut être tout un système pour les autres.
00:00:16Nous avons beaucoup de choses à aborder,
00:00:17car j'ai été honnêtement surpris par certains points,
00:00:19et même si certaines choses étaient techniquement plus anciennes,
00:00:22il m'a quand même donné une nouvelle perspective sur ces fonctionnalités.
00:00:25Dans l'une de ses astuces,
00:00:26Boris corrige l'une des plus grandes idées reçues que les gens ont lorsqu'ils essaient de construire quelque chose avec Claude Code.
00:00:31Ils lui donnent simplement une tâche,
00:00:32et quand il y a des erreurs mineures,
00:00:34ou qu'il n'est pas capable de la terminer à 100%,
00:00:37ils sont déçus.
00:00:38Mais les humains fonctionnent de manière très similaire.
00:00:40C'est pourquoi il nous dit que nous devrions toujours donner à Claude un moyen de vérifier son travail.
00:00:44Par exemple,
00:00:44si vous allez écrire du code Python pour construire un projet,
00:00:46vous devriez lui dire d'utiliser également des tests.
00:00:49C'est parce que Claude obtient cette boucle de rétroaction,
00:00:51et cela augmente instantanément la qualité du résultat final.
00:00:54Et si vous ne voulez même pas vous plonger dans le code,
00:00:56vous pouvez lui demander quels tests vous devriez utiliser,
00:00:59et il vous donnera un test pour chaque chose qu'il implémente.
00:01:02Même si vous voulez qu'il fonctionne de manière autonome,
00:01:04ce sur quoi Boris a aussi beaucoup de conseils,
00:01:06vous pouvez simplement modifier le fichier Claude.md,
00:01:08qui est envoyé dans chaque session Claude Code.
00:01:11Là,
00:01:11vous pouvez lui dire qu'avant de faire tout travail,
00:01:13il devrait mentionner comment il vérifierait ce travail,
00:01:15afin qu'il ait cette boucle de rétroaction constante.
00:01:18Un autre point important que Boris identifie est que la vérification est différente pour chaque domaine.
00:01:22Encore une fois,
00:01:22cela peut être aussi simple que d'exécuter une commande bash,
00:01:25ou pour la vérification basée sur l'interface utilisateur,
00:01:27vous avez aussi beaucoup de façons différentes de le faire,
00:01:29dont l'une est la propre extension de navigateur de Claude.
00:01:32Nous avons fait une vidéo assez complète sur ce sujet aussi,
00:01:33et nous mettrons le lien ci-dessous.
00:01:35Essentiellement,
00:01:35Claude navigue sur tout le site et peut tout vérifier.
00:01:39Cela fonctionne comme vérification pour pratiquement tout.
00:01:41Par exemple,
00:01:41quelqu'un a demandé comment vérifier une application mobile en cours de développement.
00:01:45Il existe en fait beaucoup de MCP de simulateurs iOS et Android que vous pouvez utiliser également.
00:01:50Mais si vous pensez que ces MCP consomment trop de jetons,
00:01:52vous pouvez utiliser non seulement la vérification,
00:01:54mais des techniques guidées par la vérification.
00:01:56Par exemple,
00:01:56vous pouvez utiliser le développement piloté par les tests où les tests pour une nouvelle fonctionnalité sont écrits en premier,
00:02:01puis vous faites l'implémentation réelle.
00:02:03Vous pouvez également utiliser des captures d'écran dans ce processus pour vérifier l'interface utilisateur aussi.
00:02:06En parlant du Claude.md,
00:02:07Boris souligne également à quel point ce fichier est important et à quel point il devrait être unique à chaque dépôt Claude Code.
00:02:14Voyez les choses ainsi : il devrait contenir toutes les informations de base qu'une session Claude nouvellement créée devrait avoir sur votre projet.
00:02:20Cela inclut la pile technologique,
00:02:21la structure de base du projet,
00:02:22certains styles de code et conventions que votre équipe suit,
00:02:25et surtout,
00:02:26les choses qu'il ne devrait pas faire.
00:02:28C'est parce que si vous rencontrez des erreurs dans l'une de vos sessions,
00:02:31vous ne voulez probablement pas que Claude les répète.
00:02:34Il a donc pris l'habitude de demander à toute son équipe de contribuer au Claude.md plusieurs fois par semaine.
00:02:39Chaque fois qu'ils le voient faire quelque chose de manière incorrecte,
00:02:42ils l'ajoutent là aussi.
00:02:43Chaque membre de l'équipe a également une responsabilité spécifique pour maintenir un fichier spécifique.
00:02:47Une autre excellente structure pour les applications full stack est que chaque microservice que vous exécutez peut avoir son propre Claude.md.
00:02:53Le front-end peut avoir le sien,
00:02:54et le back-end peut avoir le sien également.
00:02:56Une autre chose importante est de ne pas surcharger le Claude.md.
00:02:59Il le confirme en disant que son propre Claude.md fait environ 2,
00:03:025K jetons,
00:03:02et il a même mis en évidence exactement ce qu'ils y couvrent.
00:03:06Vous connaissez peut-être déjà les différents modes dans lesquels vous pouvez utiliser Claude Code,
00:03:09avec le mode plan spécifiquement pour la planification.
00:03:12Nous y reviendrons plus tard, car c'est un point important.
00:03:15Ensuite,
00:03:15il y a le mode auto-acceptation,
00:03:16qui accepte automatiquement toutes les modifications de fichiers.
00:03:19Mais il existe également une autre option,
00:03:20qui est le mode de contournement dangereux des permissions,
00:03:23où Claude a essentiellement la permission d'exécuter tout.
00:03:26Boris dit qu'il ne l'utilise pas,
00:03:27et il a raison,
00:03:28surtout dans les environnements de production,
00:03:30où une seule commande de terminal peut gâcher tout le projet.
00:03:33Au lieu de cela,
00:03:33il utilise les permissions dans Claude Code pour configurer quelles commandes sont autorisées,
00:03:37quelles commandes il devrait demander avant de les exécuter,
00:03:39et quelles commandes sont complètement interdites.
00:03:41Vous pouvez pratiquement ajouter n'importe quelle règle que vous voulez et la définir au niveau du projet,
00:03:45et Claude va la suivre.
00:03:46Pour partager cela avec son équipe,
00:03:47le dossier .Claude contient également un fichier settings.json où toutes ces commandes sont écrites,
00:03:52et il peut ensuite partager ce fichier avec le reste de l'équipe.
00:03:56D'une certaine manière,
00:03:57Claude Code a été l'un des produits les plus mal nommés d'Anthropic,
00:03:59car il n'est pas seulement utilisé pour le code.
00:04:02Vous avez peut-être même vu des gens générer des workflows Anetian complets avec,
00:04:05ou même mettre en place des pipelines SEO entiers ou différents agents pour analyser les marchés commerciaux et autres choses.
00:04:12Le point est que c'est un système complet permettant aux gens de contrôler beaucoup de workflows différents.
00:04:16L'exemple que Boris donne est que Claude utilise pratiquement tous ses autres outils pour lui aussi.
00:04:21Par exemple,
00:04:21il utilise Slack avec Claude Code en utilisant le serveur MCP,
00:04:24ainsi qu'un tas d'autres outils comme BigQuery et Sentry,
00:04:27tous via leurs CLI dans Claude Code.
00:04:30Encore une fois,
00:04:30cela montre simplement que vous pouvez utiliser Claude Code comme une forme d'orchestrateur.
00:04:33Pour moi spécifiquement,
00:04:34l'une des plus grandes façons dont je l'utilise dans cette orchestration est dans Notion,
00:04:38où Claude se connecte à Notion via MCP.
00:04:40Il est capable de créer des bases de données,
00:04:41de les remplir et de comprendre le contexte de toutes nos idées de vidéos.
00:04:45Bien sûr,
00:04:45vous les verrez floutées car ce sont des idées de vidéos à venir,
00:04:48mais j'espère que vous comprenez l'idée.
00:04:50Maintenant,
00:04:50si vous vous demandez comment Boris utilise réellement Claude Code avant de commencer à implémenter une fonctionnalité ou une tâche,
00:04:56il passe d'abord en mode plan et décrit clairement ce qu'il veut.
00:05:00Une fois que Claude a un plan, il continue à partir de là.
00:05:02Il soutient qu'avoir un bon plan est extrêmement important et que tous les allers-retours qu'il doit faire avec l'agent se produisent pendant le mode plan.
00:05:09Il ne lance l'agent qu'une fois qu'il a vérifié que le plan est réellement valide.
00:05:13Après cela,
00:05:13il le lance en mode auto-acceptation des modifications,
00:05:15pas en mode de contournement dangereux des permissions.
00:05:17Quant à la façon dont il l'utilise à grande échelle,
00:05:19il mentionne également qu'il exécute cinq de ces sessions Claude Code en parallèle.
00:05:23En travaillant avec elles,
00:05:24il numérote simplement ses onglets.
00:05:26Il fait cela pour que lorsqu'il reçoit des notifications de différents onglets,
00:05:29il sache de quel onglet de terminal elles proviennent.
00:05:32En plus de cela,
00:05:32il utilise également beaucoup les sessions web de Claude Code.
00:05:35C'est là que vous connectez la version web de Claude Code à votre GitHub,
00:05:38lui donnez accès à un dépôt de démo,
00:05:40et il est capable de travailler dessus dans le cloud.
00:05:43La façon dont Boris travaille avec cela est qu'il utilise la fonctionnalité d'agents en arrière-plan pour mettre toute tâche de longue durée en arrière-plan.
00:05:49Parfois,
00:05:49il l'utilise même sur son téléphone,
00:05:50où Claude peut automatiquement faire tout le travail dans une session cloud,
00:05:53et quand c'est terminé,
00:05:54il crée une nouvelle branche et pousse tous les changements de code là-bas pour que vous les examiniez.
00:05:59Il y a aussi la commande téléportation,
00:06:00qui ramène les sessions cloud dans le terminal local et vous permet de les visualiser et de travailler dessus vous-même.
00:06:06Et c'est vraiment la définition de travailler avec un agent IA,
00:06:08où il le traite essentiellement comme un développeur junior.
00:06:11Un autre point intéressant qu'il a mentionné est qu'il utilise pratiquement Opus 4.5 avec la réflexion activée pour tout.
00:06:17Il soutient que même si c'est un modèle plus grand et plus lent et qu'il prend plus de temps que Sonnet et beaucoup plus de temps que les modèles Haiku,
00:06:23il a une probabilité beaucoup plus faible de faire des erreurs.
00:06:26Par conséquent,
00:06:26le temps total passé à travailler avec le modèle et à le guider est en fait beaucoup plus faible avec Opus 4.5.
00:06:33Il utilise également l'action GitHub Claude Code,
00:06:35qui est essentiellement un bot que vous pouvez appeler depuis vos dépôts GitHub autorisés.
00:06:40Il a fourni un cas d'usage vraiment convaincant pour cela également.
00:06:43Lors des revues de PR,
00:06:44chaque fois qu'il trouve des erreurs,
00:06:45il demande simplement à Claude d'ajouter ces erreurs au fichier Claude.md.
00:06:49Concernant les tâches de longue durée,
00:06:50il utilise trois approches différentes.
00:06:52La première consiste à demander à Claude de vérifier son travail en utilisant différents tests que Claude Code lui-même conçoit,
00:06:58puis à placer ces tâches en arrière-plan.
00:07:00Il ne s'agit pas des agents cloud dont nous parlons.
00:07:02Ce sont simplement des tâches en arrière-plan qui s'exécutent silencieusement et font un rapport à l'agent principal une fois terminées.
00:07:07La deuxième approche consiste à utiliser un stop hook pour déclencher automatiquement cette vérification lorsque Claude cesse de produire du contenu.
00:07:12La troisième option qu'il mentionne repose également sur cette idée,
00:07:14c'est ce sur quoi le plugin Ralph Wiggum est construit.
00:07:17Nous avons fait une vidéo assez détaillée sur le plugin Ralph Wiggum.
00:07:20Nous avons montré comment nous utilisons le plugin Ralph et comment nous testons pendant le développement pour vérifier que l'interface utilisateur produite par Claude Code est effectivement correcte.
00:07:28Cela élimine essentiellement complètement l'humain de la boucle.
00:07:31Encore une fois,
00:07:31en reprenant le schéma de vérification dont il a parlé,
00:07:34il l'utilise également pour vérifier le format du code écrit en utilisant différents types de linters et de formateurs pour divers langages.
00:07:41Il dit essentiellement que même si les modèles génèrent du code correct,
00:07:44ces formateurs aident à peaufiner les 10% restants.
00:07:47Et c'est important pour qu'il n'y ait aucune erreur lorsque le code s'exécute en CI dans le cadre de leurs pipelines d'intégration GitHub.
00:07:53Passons maintenant à certaines des fonctionnalités plus simples qui existent dans Claude Code depuis longtemps mais qui permettent toujours d'économiser beaucoup de temps et que de nombreux débutants ne connaissent pas très bien.
00:08:01Comme il l'a déjà mentionné,
00:08:02son propre flux de travail est étonnamment classique.
00:08:04Cela s'applique à la plupart d'entre nous.
00:08:06Nous n'avons pas besoin de tout compliquer dans Claude Code pour être vraiment productifs.
00:08:09Ces simples fonctionnalités intégrées vous apportent déjà environ 90% de la productivité que vous cherchez à atteindre.
00:08:15En commençant par les /commands,
00:08:16il désigne ses flux de travail répétitifs comme ses flux de travail « en boucle interne »,
00:08:19des choses qu'il doit répéter plusieurs fois par jour.
00:08:22Il donne un exemple très simple d'une /command GitHub qu'il utilise fréquemment.
00:08:26Puisque toutes ces /commands sont stockées dans votre dossier .claud dans un sous-dossier command,
00:08:30vous pouvez en fait les commiter sur git.
00:08:33C'est également ainsi qu'il les partage avec toute son équipe.
00:08:36Ensuite,
00:08:36une autre fonctionnalité intégrée vraiment simple est les sous-agents.
00:08:39Les gens sont devenus un peu fous avec cette fonctionnalité,
00:08:41créant des sous-agents pour presque tous les cas d'usage imaginables comme des chercheurs de marché ou des validateurs de produits.
00:08:47Chacun a ses propres cas d'usage,
00:08:48mais Boris utilise les sous-agents pour automatiser des flux de travail simples qui nécessitent des instructions complètement différentes.
00:08:55Par exemple,
00:08:55la plupart de ses agents sont utilisés pour vérifier que l'architecture de son code est correcte,
00:08:59pour refactoriser le code qui a été écrit et pour valider que les builds finales fonctionnent réellement.
00:09:04Parlons maintenant d'Automata.
00:09:05Après avoir enseigné à des millions de personnes comment créer avec l'IA,
00:09:08nous avons commencé à implémenter ces flux de travail nous-mêmes.
00:09:11Nous avons découvert que nous pouvions créer de meilleurs produits,
00:09:13plus rapidement que jamais.
00:09:14Nous aidons à donner vie à vos idées,
00:09:15qu'il s'agisse d'applications ou de sites web.
00:09:18Peut-être avez-vous regardé nos vidéos en pensant : « J'ai une excellente idée,
00:09:20mais je n'ai pas d'équipe technique pour la réaliser.
00:09:22» C'est exactement là que nous intervenons..
00:09:24Considérez-nous comme votre copilote technique.
00:09:26Nous appliquons les mêmes flux de travail que nous avons enseignés à des millions de personnes directement à votre projet,
00:09:30transformant les concepts en solutions réelles et fonctionnelles sans les tracas de recruter ou de gérer une équipe de développement.
00:09:36Prêt à accélérer votre idée vers la réalité ?
00:09:39Contactez-nous à hello@automata.dev Cela nous amène à la fin de cette vidéo.
00:09:43Si vous souhaitez soutenir la chaîne et nous aider à continuer à créer des vidéos comme celle-ci,
00:09:47vous pouvez le faire en utilisant le bouton Super Thanks ci-dessous.
00:09:50Comme toujours,
00:09:50merci d'avoir regardé et je vous retrouve dans la prochaine.

Key Takeaway

Boris, créateur de Claude Code chez Anthropic, révèle sa règle d'or : toujours donner à Claude un moyen de vérifier son travail à travers des tests et boucles de rétroaction, transformant l'outil en un véritable orchestrateur de workflows avec des configurations projet-spécifiques via Claude.md et des permissions granulaires.

Highlights

Boris, créateur de Claude Code chez Anthropic, recommande de toujours donner à Claude un moyen de vérifier son travail via des tests pour augmenter instantanément la qualité du résultat final

Le fichier Claude.md doit être unique à chaque projet et contenir la pile technologique, la structure du projet, les conventions de code et surtout les erreurs à éviter - Boris demande à son équipe d'y contribuer plusieurs fois par semaine

Boris n'utilise jamais le mode de contournement dangereux des permissions mais configure plutôt des règles spécifiques pour autoriser, demander confirmation ou interdire certaines commandes

Boris utilise exclusivement Opus 4.5 avec réflexion activée car malgré sa lenteur, il fait beaucoup moins d'erreurs et réduit le temps total de travail avec l'agent

Le mode plan est crucial : Boris fait tous les allers-retours pendant la planification et ne lance l'agent en mode auto-acceptation qu'une fois le plan validé

Claude Code fonctionne comme un orchestrateur complet permettant de contrôler divers workflows via MCP et CLI (Slack, BigQuery, Sentry, Notion) au-delà du simple codage

Boris exécute cinq sessions Claude Code en parallèle et utilise les agents en arrière-plan dans les sessions web cloud, traitant Claude essentiellement comme un développeur junior

Timeline

Introduction et la règle d'or de la vérification

Boris, employé d'Anthropic et créateur de Claude Code, corrige l'une des plus grandes idées reçues des utilisateurs qui donnent simplement une tâche à Claude et sont déçus des erreurs mineures. Il explique que comme les humains, Claude doit toujours avoir un moyen de vérifier son travail pour augmenter instantanément la qualité du résultat final. Par exemple, pour un projet Python, il faut demander à Claude d'utiliser également des tests pour obtenir cette boucle de rétroaction critique. On peut même modifier le fichier Claude.md, envoyé dans chaque session, pour que Claude mentionne automatiquement comment il vérifierait son travail avant de commencer toute tâche.

Méthodes de vérification adaptées à chaque domaine

Boris identifie que la vérification diffère selon chaque domaine, allant de simples commandes bash à des méthodes plus sophistiquées pour l'interface utilisateur comme l'extension de navigateur de Claude qui peut naviguer sur tout un site. Pour les applications mobiles en développement, il existe des serveurs MCP de simulateurs iOS et Android disponibles. Si ces MCP consomment trop de jetons, on peut utiliser des techniques guidées par la vérification comme le développement piloté par les tests (TDD) où les tests sont écrits en premier avant l'implémentation réelle, combiné avec des captures d'écran pour vérifier l'interface utilisateur.

L'importance stratégique du fichier Claude.md

Boris souligne que le fichier Claude.md doit être unique à chaque dépôt et contenir toutes les informations de base qu'une session nouvellement créée devrait avoir sur le projet : pile technologique, structure de base, styles de code, conventions d'équipe et surtout les choses à ne pas faire. Il a pris l'habitude de demander à son équipe de contribuer au Claude.md plusieurs fois par semaine, ajoutant chaque erreur rencontrée pour éviter leur répétition. Pour les applications full stack, chaque microservice peut avoir son propre Claude.md (front-end et back-end séparés). Boris confirme que son propre Claude.md fait environ 2,5K jetons, soulignant l'importance de ne pas le surcharger tout en couvrant l'essentiel.

Gestion des permissions et sécurité

Bien qu'il existe trois modes dans Claude Code (plan, auto-acceptation et contournement dangereux des permissions), Boris révèle qu'il n'utilise jamais le mode de contournement dangereux, surtout dans les environnements de production où une seule commande peut gâcher tout le projet. Au lieu de cela, il configure des permissions granulaires dans Claude Code pour définir quelles commandes sont autorisées, lesquelles nécessitent une demande et lesquelles sont complètement interdites. Ces règles peuvent être définies au niveau du projet et sont stockées dans le fichier settings.json du dossier .Claude, permettant un partage facile avec toute l'équipe pour maintenir des standards de sécurité cohérents.

Claude Code comme orchestrateur universel

Boris explique que Claude Code est l'un des produits les plus mal nommés d'Anthropic car il ne sert pas uniquement au code - les gens l'utilisent pour générer des workflows Anetian complets, des pipelines SEO ou analyser des marchés commerciaux. C'est un système complet permettant de contrôler de nombreux workflows différents, servant essentiellement d'orchestrateur. Boris lui-même utilise Claude Code avec Slack via le serveur MCP, ainsi qu'avec BigQuery et Sentry via leurs CLI. L'exemple personnel donné montre l'utilisation avec Notion via MCP, où Claude peut créer des bases de données, les remplir et comprendre le contexte d'idées de vidéos, démontrant la puissance d'orchestration au-delà du simple développement logiciel.

Méthodologie de planification et d'exécution

Boris révèle sa méthodologie stricte : il passe d'abord en mode plan et décrit clairement ce qu'il veut avant toute implémentation. Il insiste sur l'importance d'avoir un bon plan et fait tous les allers-retours nécessaires avec l'agent pendant le mode plan uniquement. Il ne lance l'agent qu'une fois le plan vérifié comme valide, puis le lance en mode auto-acceptation des modifications (pas en mode de contournement dangereux des permissions). Pour travailler à grande échelle, Boris exécute cinq sessions Claude Code en parallèle, numérotant simplement ses onglets pour identifier facilement de quel terminal proviennent les notifications.

Sessions cloud et agents en arrière-plan

Boris utilise intensivement les sessions web de Claude Code où on connecte la version web à GitHub, donne accès à un dépôt de démo et Claude peut travailler dans le cloud. Il utilise la fonctionnalité d'agents en arrière-plan pour les tâches de longue durée, parfois même depuis son téléphone. Claude fait automatiquement tout le travail dans la session cloud et une fois terminé, crée une nouvelle branche et pousse tous les changements pour examen. La commande téléportation permet de ramener les sessions cloud dans le terminal local pour les visualiser et travailler dessus. Cette approche représente la vraie définition de travailler avec un agent IA, où Boris traite Claude essentiellement comme un développeur junior.

Choix du modèle Opus 4.5 et justification

Boris révèle qu'il utilise pratiquement Opus 4.5 avec la réflexion activée pour tout, malgré que ce soit un modèle plus grand et plus lent que Sonnet et beaucoup plus lent que les modèles Haiku. Il justifie ce choix en expliquant qu'Opus 4.5 a une probabilité beaucoup plus faible de faire des erreurs, ce qui signifie que le temps total passé à travailler avec le modèle et à le guider est en réalité beaucoup plus faible avec Opus 4.5. Il utilise également l'action GitHub Claude Code, un bot appelable depuis les dépôts GitHub autorisés, particulièrement lors des revues de PR où il demande à Claude d'ajouter automatiquement les erreurs trouvées au fichier Claude.md.

Stratégies pour les tâches de longue durée

Boris décrit trois approches différentes pour gérer les tâches de longue durée. La première consiste à demander à Claude de vérifier son travail en utilisant différents tests que Claude Code lui-même conçoit, puis à placer ces tâches en arrière-plan (pas les agents cloud, mais des tâches locales qui s'exécutent silencieusement et font un rapport à l'agent principal). La deuxième approche utilise un stop hook pour déclencher automatiquement la vérification lorsque Claude cesse de produire du contenu. La troisième option repose sur le plugin Ralph Wiggum, qui permet de tester pendant le développement pour vérifier que l'interface utilisateur produite est correcte, éliminant essentiellement complètement l'humain de la boucle de vérification.

Vérification du format et linters

Boris étend le schéma de vérification en l'appliquant aussi au format du code écrit, utilisant différents types de linters et formateurs pour divers langages de programmation. Il explique que même si les modèles génèrent du code correct sur le plan fonctionnel, ces formateurs automatiques aident à peaufiner les 10% restants, garantissant la qualité et la cohérence du code. Cette étape est particulièrement importante pour éviter toute erreur lorsque le code s'exécute en CI (intégration continue) dans le cadre de leurs pipelines d'intégration GitHub, assurant ainsi que le code respecte tous les standards de l'équipe avant d'être fusionné.

Fonctionnalités simples et flux de travail classique

Boris souligne que son propre flux de travail est étonnamment classique et s'applique à la plupart des utilisateurs - il n'est pas nécessaire de tout compliquer dans Claude Code pour être vraiment productif. Ces simples fonctionnalités intégrées apportent déjà environ 90% de la productivité recherchée. Il désigne ses flux de travail répétitifs comme ses flux de travail « en boucle interne », des tâches qu'il doit répéter plusieurs fois par jour. Il utilise des /commands pour automatiser ces workflows répétitifs, donnant l'exemple d'une /command GitHub qu'il utilise fréquemment et qui est stockée dans le dossier .claud pour être commitée sur git et partagée avec toute l'équipe.

Sous-agents et cas d'usage spécifiques

Boris explique l'utilisation des sous-agents, une fonctionnalité intégrée avec laquelle les utilisateurs sont devenus créatifs, créant des sous-agents pour presque tous les cas d'usage imaginables comme des chercheurs de marché ou des validateurs de produits. Cependant, Boris garde une approche pragmatique : il utilise les sous-agents uniquement pour automatiser des flux de travail simples nécessitant des instructions complètement différentes. Ses cas d'usage spécifiques incluent vérifier que l'architecture du code est correcte, refactoriser le code qui a été écrit et valider que les builds finales fonctionnent réellement, restant ainsi fidèle à son principe de simplicité et d'efficacité.

Présentation d'Automata et conclusion

La vidéo se termine par une présentation d'Automata, le service de la chaîne qui aide à donner vie aux idées en appliquant les flux de travail d'IA enseignés dans les vidéos directement aux projets des clients, créant des applications et sites web. Ils se positionnent comme un copilote technique pour ceux qui ont d'excellentes idées mais pas d'équipe technique, transformant les concepts en solutions réelles sans les tracas de recruter ou gérer une équipe de développement. Le créateur encourage les spectateurs à les contacter à hello@automata.dev, invite à soutenir la chaîne via le bouton Super Thanks et conclut en remerciant l'audience avant de se retrouver dans la prochaine vidéo.

Community Posts

View all posts