Claude Code 2.1 : Un guide avec des exemples pratiques

Claude Code est un outil de codage agentique développé par Anthropic qui s'exécute directement dans votre terminal et peut également fonctionner via une interface web connectée. Au lieu de travailler sur des invites isolées, Claude Code comprend l'ensemble du référentiel, peut raisonner à travers les fichiers, modifier le code et exécuter des outils. 

Par rapport aux les versions précédentes, qui se concentraient principalement sur l'assistance interactive au codage, Claude Code 2.1 offre une prise en charge supplémentaire des agents, des hooks et des compétences réutilisables qui peuvent influencer activement la manière et le moment où les modifications de code ont lieu.

Claude Code est conçu pour les développeurs qui souhaitent bénéficier d'une assistance IA directement intégrée dans leurs flux de travail réels, plutôt que de devoir passer sans cesse d'un éditeur à une interface utilisateur de chat. Bien qu'il soit encore en phase de prévisualisation, il démontre déjà une forte utilité pratique dans les processus de développement réels. 

Si vous souhaitez en savoir plus sur les modèles Claude, je vous recommande de suivre le cours cours Introduction aux modèles Claude. 

Quelles sont les nouveautés de Claude Code 2.1 ?

Claude Code 2.1 s'appuie sur l'expérience terminale de base en introduisant une série d'améliorations qui rendent les flux de travail pilotés par des agents plus flexibles. Ces modifications élargissent la manière dont Claude Code analyse une base de code et dont les développeurs interagissent avec celle-ci lors de tâches de développement réelles.

Parmi les ajouts les plus notables dans Claude Code 2.1, on peut citer :

• Les agents et les hooks de compétences dans le frontmatter permettent aux développeurs d'appliquer des vérifications et des contraintes avant que toute modification du code ne soit effectuée.
• Assistance technique améliorée avec contexte bifurqué, rechargement à chaud et définitions de compétences personnalisées, rendant les flux de travail réutilisables plus flexibles et plus performants.
• La fonction Slash (/) permet d'accéder rapidement aux actions fréquemment utilisées lors de sessions interactives.
• Les agents dans Claude Code 2.1 ne cessent plus de raisonner lorsqu'un appel d'outil est refusé, ce qui permet aux flux de travail de se poursuivre sans interruption.
• Cet outil prend en charge les réponses contrôlées par la langue, ce qui est particulièrement utile pour la documentation multilingue, les révisions et la collaboration en équipe.
• Les autorisations d'outils génériques, telles que Bash(*-h*), offrent des contrôles d'automatisation plus précis.
• L'interface CLI prend désormais en charge Shift+Enter pour la saisie multiligne, améliorant ainsi l'expérience de création interactive sans nécessiter de configuration supplémentaire.

Dans ce guide, nous nous concentrons sur une série d'expériences pratiques qui démontrent comment ces nouvelles capacités sont appliquées dans des projets concrets.

Configuration de l'expérience Web basée sur le cloud Claude Code

Claude Code 2.1 est disponible sous forme d'expérience Web fonctionnant entièrement dans le cloud. Ce mode est particulièrement utile pour les flux de travail collaboratifs, les révisions de demandes d'extraction et l'automatisation au niveau du référentiel sans nécessiter de configuration locale.

Étape 1 : Veuillez vous connecter pour accéder à Claude Code.

Pour commencer, rendez-vous sur https://claude.ai/code, et vous accéderez à l'interface Claude Code (aperçu de recherche). 

Étape 2 : Veuillez connecter Claude Code à GitHub.

Pour fonctionner avec des référentiels réels, Claude Code nécessite un accès à GitHub. Veuillez cliquer sur « Connect to GitHub » (Se connecter à GitHub) pour installer l'application Claude GitHub. 

Lors de l'autorisation, GitHub demandera la permission de se connecter aux référentiels en :

• Vérification de votre identité GitHub
• Veuillez consulter les référentiels auxquels Claude a accès.
• Agir en votre nom (par exemple, créer des branches ou des commits)

Vous avez le choix entre :

• Tous les référentiels, ou
• Veuillez sélectionner uniquement les référentiels (recommandé pour un contrôle plus strict)

Les autorisations typiques comprennent :

• Accès en lecture aux métadonnées et aux vérifications du référentiel
• Accès en lecture et en écriture au code, aux problèmes, aux demandes d'extraction et aux flux de travail

Veuillez cliquer sur « Installer et autoriser », et vous pourrez modifier ou révoquer l'accès ultérieurement directement depuis les paramètres de l'application GitHub. Cette étape est nécessaire pour que Claude Code puisse lire les référentiels, ouvrir des pull requests et pousser des commits lorsque vous travaillez dans l'environnement web.

Étape 3 : Créer un environnement cloud

Avant de commencer votre première session, Claude Code vous invite à créer un environnement cloud. Cet environnement contrôle l'accès réseau et les limites d'exécution de Claude.

Les options disponibles sont les suivantes :

• Aucun : Cette option ne dispose pas d'accès à Internet, ce qui est particulièrement utile pour une sécurité maximale.
• Recommandé : Il permet d'accéder à des sources de paquets vérifiées.
• Complet : Ce paramètre offre un accès illimité à Internet.

Dans la plupart des cas, l'option Trusted offre le meilleur compromis entre sécurité et flexibilité.

Étape 5 : Veuillez démarrer une session Web.

Une fois la configuration terminée, vous serez redirigé vers l'éditeur web Claude Code, comme illustré dans la capture d'écran ci-dessous.

À partir de là, vous pouvez :

• Veuillez sélectionner un référentiel et une branche.
• Effectuer des refactorisations et des révisions
• Créer de nouvelles branches et de nouveaux commits
• Reprendre les sessions précédentes (le cas échéant)
• Passer d'un référentiel à un autre sans modifier l'environnement

Configuration de l'interface CLI basée sur le terminal Claude Code

L'interface CLI constitue le moyen le plus direct pour interagir avec Claude Code 2.1. Il est particulièrement adapté au développement local, aux refactorisations progressives et aux situations où un contrôle précis des actions de Claude dans votre référentiel est souhaité.

Étape 1 : Installation

Claude Code peut être installé directement depuis le terminal à l'aide d'un programme d'installation spécifique à la plateforme.

macOS, Linux, WSL:

curl -fsSL https://claude.ai/install.sh | bash

Windows PowerShell :

irm https://claude.ai/install.ps1 | iex

CMD Windows :

curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

Une fois l'installation terminée, un message de confirmation s'affichera, indiquant la version de Claude Code ainsi que le chemin d'installation. Pour plus d'options de configuration, veuillez consulter le guide de configuration officiel.

Étape 2 : Commencer

Après l'installation, veuillez vous rendre à la racine de votre projet et lancer Claude Code :

cd your-project-directory
Claude Code

Lorsque Claude Code démarre, il analyse immédiatement le référentiel et établit une compréhension initiale de la base de code. 

Ce contexte initial permet à Claude Code de raisonner plus efficacement dans les étapes suivantes.

Expérimentation avec Claude Code 2.1

Pour cette démonstration, j'ai utilisé l'un de mes projets issus de GPT 5.2. Voici un bref aperçu du projet.

Une fois que Claude Code a accès à tous les fichiers et dossiers contenus dans le dossier, nous pouvons commencer à expérimenter.

Réorganiser en utilisant les compétences contextuelles dérivées 

Dans le cadre de l'évaluation de Claude Code 2.1, j'ai procédé à une refonte complète du référentiel afin d'améliorer le pipeline. Cette expérience met en évidence les compétences dans un contexte bifurqué, où Claude peut raisonner sur plusieurs fichiers au lieu d'effectuer des modifications isolées sur un seul fichier.

Invite :

Refactor the CSV parsing and slide generation logic across the repository.
Improve readability, split responsibilities, and avoid duplicated logic.

Claude commence par élaborer un plan de refactorisation détaillé, comprenant la structure proposée pour les modules, les points de duplication et une séquence de mise en œuvre, puis demande l'approbation avant d'apporter des modifications. 

Une fois que vous avez donné votre accord, Claude applique la refactorisation de manière incrémentielle, en affichant les différences et la progression au fur et à mesure.

Grâce à Claude Code, j'ai réalisé les améliorations suivantes :

• Répartition des responsabilités entre les modules : Claude a séparé le chargement CSV, les transformations, la création Excel, la génération PowerPoint et la planification LLM (essentiellement tous les modules) en composants dédiés.
• Réduction de la logique dupliquée : Il a centralisé les utilitaires répétés (tels que la détection et le formatage des colonnes) et a déplacé les constantes partagées dans une couche de configuration commune.
• Amélioration de la maintenabilité : Claude a également réduit la taille de l' app.py, tout en conservant le comportement externe de l'application.

Voici une comparaison de la structure du projet et du résultat de la refactorisation avant et après les modifications.

Avant :

Après :

Enfin, j'ai tenté la même refactorisation dans Claude Code Web. La principale différence réside dans le flux de travail :

• CLI procède étape par étape avec des approbations explicites.
• Web peut transférer la refactorisation directement vers une nouvelle branche, ce qui est pratique pour la collaboration et les workflows basés sur les relations publiques.

Enfin, Claude a refactorisé et déployé le code dans une branche.

Crochet de validation avant édition

Les pipelines de données échouent souvent pour une raison simple, à savoir que le schéma CSV d'entrée ne correspond pas à ce que le code attend. Dans Claude Code 2.1, il est possible de réduire ce type d'erreurs en utilisant des hooks de pré-édition. Cette nouvelle fonctionnalité permet à un agent d'effectuer des contrôles de validation avant que Claude ne soit autorisé à modifier le code.

Dans cet exemple, j'ai demandé à Claude Code de créer un agent qui valide la structure CSV avant toute modification.

Invite :

Create a Claude Code agent that validates the CSV schema before modifying any code. The agent should reject edits if the CSV schema is unclear.

Claude Code a d'abord généré un agent de validation de schéma CSV et l'a intégré au flux de travail afin qu'il puisse agir comme un contrôleur. La sortie CLI montre que Claude n'a pas seulement créé un script unique, mais qu'il a également mis en place un petit système de validation comprenant :

• Module de validation de schéma central qui vérifie les colonnes obligatoires, les valeurs manquantes et la cohérence de base.
• Un hook gatekeeper pré-édition exécute automatiquement la validation avant que les modifications ne soient effectuées.
• Enfin, une suite de tests et quelques exemples d'utilisation pour vérifier le validateur à travers des cas CSV valides/invalides.

En pratique, le processus devient simple :

• Claude effectue automatiquement des vérifications de schéma avant d'apporter des modifications au code, imposant ainsi une condition préalable.
• Si le schéma n'est pas clair ou n'est pas valide, l'agent bloque les modifications et renvoie des messages d'erreur exploitables afin de guider la correction.
• Une fois la validation effectuée, Claude procède aux modifications, en veillant à ce qu'elles soient encadrées et prévisibles.

La sortie Web affiche un résultat similaire, mais avec une différence importante. Claude Code Web peut transférer les modifications directement vers une nouvelle branche, y compris le module de validation, l'intégration des hooks, la documentation et les tests. 

Dans l'ensemble, Claude Code 2.1 met en place des garde-fous avant que les modifications ne soient effectuées en intégrant des hooks directement dans les agents et les compétences. Cela rend les hooks particulièrement utiles dans les projets impliquant de grandes quantités de données, où l'exactitude des entrées est souvent une source de bogues plus importante que le code lui-même.

Commandes rapides pour les tâches répétitives

Claude Code 2.1 a introduit des compétences de commande slash réutilisables, qui sont des flux de travail autonomes pouvant être invoqués de manière interactive dans une session Claude ou exécutés directement à partir de la ligne de commande. 

Dans cet exemple, nous créons une compétence réutilisable d'/generate-slides qui convertit un fichier CSV en une présentation PowerPoint professionnelle.

Invite :

Create a reusable skill called /generate-slides that converts a CSV into a PPT.

Conseil : Veuillez utiliser /statusline pour configurer une ligne d'état personnalisée qui apparaîtra sous l'invite de saisie (pratique pour afficher le dépôt, la branche ou le mode).

Claude Code génère une définition complète des compétences sous .claude/skills/, comprenant la documentation, la logique de validation et un point d'entrée Python exécutable.

• s de création de compétences: Claude rédige une compétence d'generate-slides entièrement documentée, décrivant son objectif, ses entrées, ses étapes de validation et son flux d'exécution.
• s de validation du schéma: Cette compétence valide le schéma CSV avant tout traitement, garantissant ainsi la qualité des données et la clarté des messages d'erreur.
• Exécution: La compétence peut être exécutée directement depuis le terminal, se comportant comme un outil en ligne de commande autonome.
• s relatives à la gestion des erreurs: Les fichiers manquants, les schémas non valides ou les clés API manquantes entraînent des erreurs claires et exploitables.
• s en automatisation: Une seule commande permet de générer des artefacts Excel, des graphiques et une présentation PowerPoint.

Vous pouvez tester la compétence localement avec :

python .claude/skills/generate-slides.py --csv-file kpis.csv

Remarque: Veuillez vous assurer d'ajouter votre clé API avant d'exécuter cette opération. 

Les compétences en matière de commandes slash transforment Claude Code en un moteur de flux de travail, et non plus seulement en un assistant. Au lieu de demander à plusieurs reprises la même tâche, vous la définissez une seule fois et la réutilisez dans différents projets, sessions et environnements. Vous pouvez observer ci-dessous la structure mise à jour du référentiel, qui reflète l'ajout de la nouvelle compétence.

Cet exemple illustre comment :

• Les compétences peuvent être invoquées de manière interactive à partir de l'interface CLI.
• Les compétences générées par Claude s'intègrent parfaitement aux bases de code existantes.

Sortie contrôlée par la langue 

Claude Code 2.1 peut être configuré pour répondre dans une langue spécifique, ce qui est particulièrement utile pour les équipes multilingues, la documentation localisée et les explications de code en langues autres que l'anglais. Dans cet exemple, nous avons demandé à Claude d'expliquer entièrement en japonais le processus de génération des diapositives du référentiel.

Invite :

Explain the slide generation logic in Japanese.

Claude a répondu en japonais et a fourni une explication structurée du flux de bout en bout. Comme le montre le résultat, il ne s'est pas contenté de traduire un résumé, mais a également divisé le processus en phases claires et référencé les modules pertinents impliqués dans chaque étape. La sortie CLI affiche :

• Du début à la fin en japonais : La réponse est entièrement rédigée en japonais, y compris les titres et les puces.
• Déroulement étape par étape : Claude divise le pipeline en plusieurs étapes distinctes (validation CSV, traitement des données, classeur Excel, planification LLM et création de diapositives).
• Références tenant compte du code source : Il indique les fichiers et répertoires pertinents tout en expliquant la fonction de chaque composant.
• Formatage de type documentation : Le résultat se présente sous la forme de documents internes, ce qui facilite sa réutilisation dans un fichier README ou un guide d'intégration.

Remarque : Je n'ai testé ce comportement que dans l'interface CLI pour cet exemple, mais la même fonctionnalité de contrôle linguistique est intégrée à Claude Code 2.1 dans son ensemble.

Il s'agit d'une fonctionnalité mineure sur le papier, mais dans la pratique, elle représente un gain de productivité considérable lorsque la documentation et les révisions doivent être effectuées dans des langues autres que l'anglais.

Commandes Claude Code 2.1

Voici quelques commandes que vous pouvez essayer avec Claude Code.

Conclusion

Dans ce guide, nous avons exploré Claude Code 2.1 en réalisant des expériences pratiques à la fois sur l'interface CLI et sur les workflows web. Nous avons utilisé Claude Code pour refactoriser un référentiel existant à l'aide de compétences contextuelles dérivées, appliquer des garanties de données avec des hooks de validation pré-édition, créer des compétences de commande slash réutilisables et générer des explications contrôlées par le langage directement à partir de la base de code.

Ces exemples illustrent comment Claude Code 2.1 va au-delà du simple montage assisté par l'IA pour s'orienter vers des workflows de développement davantage axés sur les agents. Bien que Claude Code 2.1 soit encore en phase de prévisualisation, il démontre déjà une forte valeur pratique dans des projets réels.