Claude Code 2026 : le Guide Complet (Anthropic)

Claude Code est un agent de développement créé par Anthropic, l'entreprise derrière Claude. Contrairement à ChatGPT ou Claude.ai que tu utilises dans un navigateur, Claude Code fonctionne directement dans ton terminal, cette fenêtre noire où les développeurs tapent des commandes. Et c'est exactement ce qui le rend si puissant.

Concrètement, Claude Code comprend l'ensemble de ton projet : tous les fichiers, leur structure, les dépendances, l'architecture. Il ne se contente pas de répondre à des questions sur le code, il modifie tes fichiers, lance des commandes, exécute des tests et corrige les erreurs de façon autonome. C'est la différence entre un assistant qui te donne des conseils et un collègue qui fait réellement le travail.

Comment ça se distingue de ChatGPT et Claude.ai ?

• ChatGPT / Claude.ai : tu copies-colles du code dans un chat, l'IA te répond avec des suggestions que tu dois appliquer manuellement. C'est un échange conversationnel.
• Claude Code : tu donnes une instruction (« ajoute un formulaire de contact à mon site »), et l'agent navigue dans tes fichiers, crée ou modifie le code nécessaire, et vérifie que tout fonctionne. C'est de l'exécution autonome.

Pour faire simple : ChatGPT est un conseiller. Claude Code est un exécutant. Les deux sont utiles, mais pas pour les mêmes choses. Et la bonne nouvelle, c'est que Claude Code est open source sous licence Apache 2.0, tu peux inspecter exactement ce qu'il fait sous le capot.

Le plus marquant : Claude Code rend la création de logiciels accessible à des gens qui n'ont jamais écrit une ligne de code. Tu décris ton idée en langage naturel, et l'agent la construit. Ce n'est pas de la science-fiction, c'est ce que des milliers de personnes font déjà au quotidien.

L'installation de Claude Code peut sembler intimidante si tu n'as jamais touché un terminal. Mais suis ces étapes dans l'ordre et tu seras opérationnel en moins de 10 minutes. Je te guide pas à pas.

• ~10 minTemps total
• 4Étapes clés
• 2Prérequis

Prérequis

• Node.js 18+

  L'environnement qui fait tourner Claude Code. Télécharge la version LTS sur nodejs.org, ou sur Mac utilise Homebrew avec brew install node.

• Un compte Anthropic

  Soit un abonnement Claude Pro/Max sur claude.ai, soit une clé API. Le plus simple pour débuter : ton compte Claude Pro existant.

Installation étape par étape

1. Ouvre ton terminal

   Sur Mac, cherche « Terminal » dans Spotlight. Sur Windows, utilise PowerShell ou Windows Terminal. Sur Linux, tu sais déjà où c'est.

2. Installe Claude Code en global

   Tape la commande ci-dessous. L'installation prend entre 30 secondes et 2 minutes selon ta connexion.

   npm install -g @anthropic-ai/claude-code

3. Navigue vers ton projet

   Rends-toi dans le dossier de ton projet, ou crées-en un vide pour tester.

   cd ~/mon-projet

   Pas encore de projet ? Crées-en un : mkdir mon-premier-projet && cd mon-premier-projet

4. Lance Claude Code

   Tape simplement claude. La première fois, l'agent te demandera de t'authentifier via un lien à ouvrir dans ton navigateur.

Première configuration

Une fois connecté, Claude Code est prêt à travailler. Mon conseil pour débuter : commence par une demande simple pour prendre la main sans risque.

• Explorer

  « Explique-moi la structure de ce projet » : pour voir comment il analyse ton code sans rien modifier.

• Créer

  « Crée un fichier index.html basique avec un titre de bienvenue » : pour voir le cycle création + demande de confirmation.

• Itérer

  « Change le titre en bleu marine et ajoute une image » : pour tester la conversation continue.

Tu verras immédiatement comment Claude Code fonctionne : il te montre ce qu'il fait, te demande confirmation avant de modifier des fichiers, et t'explique ses choix.

La théorie c'est bien, mais rien ne vaut la pratique. Voici 5 projets concrets que tu peux réaliser avec Claude Code, même si tu n'as jamais codé. Pour chacun, je te donne le prompt de départ, copie-le tel quel dans Claude Code.

1. Un site portfolio personnel

Le classique pour débuter. Un site simple qui te présente, avec tes compétences et un moyen de te contacter.

Prompt : « Crée un site portfolio personnel moderne et responsive avec HTML, CSS et un peu de JavaScript. Il doit avoir une section hero avec mon nom et titre, une section 'À propos', une section 'Compétences' avec des cartes visuelles, et un formulaire de contact. Design épuré, couleurs professionnelles, animations subtiles au scroll. »

2. Un tableau de bord de suivi d'habitudes

Une petite application web pour tracker tes habitudes quotidiennes. Parfait pour comprendre comment Claude Code gère les données.

Prompt : « Crée une application de suivi d'habitudes en React avec Tailwind CSS. L'utilisateur peut ajouter des habitudes, les cocher chaque jour, voir un calendrier mensuel avec les jours complétés en vert, et un graphique de progression. Les données sont stockées dans le localStorage du navigateur. »

3. Un générateur de factures PDF

Un outil pratique que tu utiliseras vraiment. Entre les infos, génère un PDF professionnel.

Prompt : « Crée un générateur de factures web. Formulaire pour entrer : nom de l'entreprise, client, lignes de facturation (description, quantité, prix unitaire), TVA, conditions de paiement. Génère un PDF propre et professionnel avec un bouton de téléchargement. Utilise React et une librairie de génération PDF. »

4. Un blog statique avec système de markdown

Crée ton propre blog où les articles sont écrits en Markdown, simple et élégant.

Prompt : « Crée un blog statique avec Next.js et Tailwind CSS. Les articles sont écrits en Markdown dans un dossier /posts. Page d'accueil avec la liste des articles, page individuelle pour chaque article avec mise en forme propre, navigation, mode sombre, et pages responsives. »

5. Un outil d'analyse de texte

Un outil qui analyse un texte et donne des statistiques : nombre de mots, temps de lecture, lisibilité, mots les plus fréquents.

Prompt : « Crée un outil d'analyse de texte web. L'utilisateur colle un texte, et l'outil affiche en temps réel : nombre de mots et caractères, temps de lecture estimé, score de lisibilité Flesch-Kincaid adapté au français, top 10 des mots les plus fréquents dans un graphique en barres. Interface propre avec Tailwind CSS. »

Pour chaque projet, Claude Code va créer les fichiers, installer les dépendances nécessaires, et te guider pour lancer le résultat dans ton navigateur. N'hésite pas à itérer : « change les couleurs pour du bleu marine », « ajoute une section témoignages », « rends le formulaire plus compact ». C'est comme ça qu'on apprend et qu'on obtient exactement ce qu'on veut.

Si je devais ne garder qu'une seule technique pour optimiser Claude Code, ce serait celle-là. Le fichier CLAUDE.md est probablement la fonctionnalité la plus sous-utilisée du produit, alors qu'elle peut diviser par deux le temps que tu passes à corriger les sorties de l'agent.

Pourquoi CLAUDE.md change tout

Imagine que tu embauches un nouveau dev demain. Tu vas passer une heure à lui expliquer la stack, les conventions, l'architecture, les choses à ne pas faire. Sans ça, il va écrire du code qui marche techniquement mais qui ne ressemble pas au reste du projet, va dupliquer une fonction qui existe déjà, ou utiliser une lib que tu as explicitement bannie.

Claude Code est dans la même situation à chaque session. Il ne se souvient pas du contexte d'hier. CLAUDE.md, c'est le brief que tu lui fais une fois pour toutes. Il le lit automatiquement, sans que tu aies besoin de le mentionner. Le fichier devient son cerveau persistant.

• Sans CLAUDE.md Cinq minutes de contexte à chaque session. L'agent propose du Vue 2 alors que tu es en Vue 3. Il recrée une fonction qui existe déjà. Il utilise une lib bannie.
• Avec CLAUDE.md L'agent connaît la stack, les conventions, les pièges. Tu ne réexpliques plus le contexte à chaque session, le code ressemble au reste du projet, et il y a moins de corrections.

Où placer le fichier

Claude Code lit les CLAUDE.md à plusieurs niveaux, dans l'ordre de priorité croissante :

• Global

  ~/.claude/CLAUDE.md

  S'applique à TOUS tes projets. Pour ton style de code préféré et tes préférences personnelles.

• Projet

  CLAUDE.md à la racine

  Le plus utilisé. Toutes les règles propres au projet courant. Versionne-le dans git.

• Sous-dossier

  legacy/CLAUDE.md

  Lu uniquement quand Claude travaille dans ce dossier. Idéal pour les monorepos ou zones à conventions différentes.

Que mettre dedans

Un bon template couvre six sections. Tu peux en ajouter ou en retirer selon ton projet :

1. Stack technique

   Versions exactes des frameworks, libs principales, langage. Évite à Claude de proposer du code Vue 2 alors que tu es en Vue 3, ou du React class-component alors que tu es en hooks.

2. Conventions de code

   Nommage des variables, indentation, single ou double quotes, semi-colons, structure des composants. Claude s'y conforme automatiquement.

3. Structure du projet

   Où se trouvent les composants, les utils, les types, les tests. Évite à Claude de créer un fichier au mauvais endroit.

4. Règles métier

   Les contraintes business non triviales. Par exemple : « le CMS WP est sur Hostinger, ne jamais router via lesastucesia.com pour les requêtes GraphQL ».

5. Choses à ne JAMAIS faire

   Section critique. Liste explicitement les pièges : « ne pas utiliser localStorage pour les données critiques », « ne jamais commit le fichier .env ».

6. Contexte business / produit

   Qui sont les utilisateurs, quel est le ton, quelles sont les priorités. Aide Claude à faire les bons choix quand il a le doigt sur la balance.

Exemple commenté de CLAUDE.md

Voici un extrait simplifié de mon vrai CLAUDE.md sur LesAstucesIA :

# LesAstucesIA - Contexte projet

## Stack
- Next.js 16.1.7 (App Router) + Tailwind v3.4.19 (PAS v4)
- WordPress headless GraphQL sur Hostinger
- Deploy auto sur Vercel via push main

## Conventions
- Imports : pas de chemins relatifs au dela de 2 niveaux, utiliser @/
- Lucide : 100% lucide-react, ZERO data-lucide ou createIcons
- Tailwind : preferer les classes utilitaires inline aux composants styled

## Ne jamais
- Utiliser le CDN Lucide (cause des crashes DOM)
- Router GraphQL via lesastucesia.com (intercepte par Vercel, casse tout)
- Commit le fichier .env.local

## Ton du contenu
- Premiere personne, direct, sans bullshit
- Pas de em dashes dans le contenu (sonne IA)
- Pas de "incontournable", "revolutionnaire", "magique"

• ~15Lignes
• 5 minÀ écrire
• -40 %Temps de correction

CLAUDE.md vs README.md vs commentaires

Question fréquente : pourquoi pas mettre tout ça dans le README ? Parce que les trois n'ont pas la même cible.

• README.md

  Destiné aux humains. Long, narratif. Explique comment installer, lancer, contribuer. Claude le lit mais ce n'est pas optimisé pour lui.

• CLAUDE.md

  Destiné à l'agent. Court, direct, sous forme de règles claires. Tu peux avoir les deux, ils ne se concurrencent pas.

• Commentaires inline

  Utiles pour expliquer une logique locale non évidente. Mais pour les règles globales, CLAUDE.md est bien plus efficace : toujours visible sans scanner le codebase.

Astuces avancées

1. Versionne ton CLAUDE.md

   Commite-le dans git. Toute ton équipe profite du même contexte. Un nouveau piège découvert ? Une ligne ajoutée, et Claude l'évite pour tout le monde dès la prochaine session.

2. Préfixe avec « IMPORTANT » ou « CRITICAL »

   Claude prête plus d'attention aux règles emphasées. Pour les choses absolument à respecter, sois explicite : « IMPORTANT: ne jamais utiliser X car Y ».

3. Itère régulièrement

   À chaque fois que Claude fait une erreur que tu corriges à la main, ajoute une ligne. En quelques semaines, ton fichier capture toute la connaissance tribale du projet.

4. Spécialise par sous-dossier

   Si ton dossier tests/ a des conventions très différentes de ton code prod, mets un CLAUDE.md dedans. Claude appliquera les règles pertinentes selon où il travaille.

Mon conseil. Démarre petit : 10 lignes, 3 sections. Stack + ne jamais faire + ton. Enrichis au fil des sessions quand Claude se trompe. En 2 semaines, tu auras un brief précieux sans jamais l'avoir « écrit ».

Si CLAUDE.md est la fonctionnalité la plus sous-utilisée, le Plan Mode est probablement la deuxième. C'est un mode où Claude réfléchit à fond à ta demande, te présente un plan détaillé, et n'exécute rien tant que tu n'as pas validé. Sur les tâches complexes, c'est ce qui fait la différence entre une feature qui marche du premier coup et trois heures de debug.

Qu'est-ce que le Plan Mode

Par défaut, Claude Code est en mode « auto-accept » ou « edit ». Tu lui demandes quelque chose, il modifie les fichiers, tu valides chaque action ou il enchaîne directement.

En Plan Mode, c'est différent. Claude Code ne touche à aucun fichier. Il peut lire ton code, faire des recherches, explorer la codebase, mais aucune écriture. À la fin, il te présente un plan structuré : quels fichiers il va modifier, dans quel ordre, et pourquoi. Tu valides (ou pas), et seulement à ce moment il bascule en mode exécution.

C'est exactement comme un sénior qui prend un step back avant d'attaquer un gros refactor. Au lieu de foncer dans le code, il dessine d'abord son approche.

Comment l'activer

Deux façons :

• Avec un raccourci clavier : Shift + Tab pour cycler entre les modes (auto-accept → edit → plan). Tu vois le mode actif en bas du terminal.
• Au démarrage : lance claude --plan pour démarrer directement en Plan Mode.

Une fois en Plan Mode, demande ce que tu veux normalement. Claude va explorer, réfléchir, et finir par un plan. Tu valides en cliquant le bouton qui apparaît, et il exécute.

Quand l'utiliser (et quand pas)

Pas la peine de mettre Plan Mode pour tout. Pour un changement trivial (corriger une typo, ajouter un console.log, changer une valeur dans un fichier), c'est juste une perte de temps.

Mais pour ces cas, il vaut clairement le détour :

• Refactor multi-fichiers « renomme cette fonction utilisée à 40 endroits », « extrait ce composant en module séparé ». Le plan t'évite que Claude rate un import.
• Nouvelle feature de bout en bout « ajoute l'authentification SSO ». Beaucoup de fichiers touchés, beaucoup de décisions implicites. Voir le plan avant d'exécuter, c'est éviter de refaire le travail.
• Migration ou upgrade Passer de Tailwind v3 à v4, migrer une lib. Claude peut prévoir des breaking changes que tu n'avais pas anticipés.
• Debug profond « trouve pourquoi cette page ne charge pas chez certains users ». Le plan te montre où Claude pense que se trouve le problème, tu peux ajuster avant qu'il ne perde du temps.

Règle simple : si la tâche touche plus de 2-3 fichiers ou implique des décisions d'architecture, mets Plan Mode. Sinon, mode normal.

Workflow recommandé

Un workflow simple, en quatre temps :

1. Active Plan Mode (Shift+Tab) avant de lancer la demande.
2. Formule ta demande clairement. Précise le contexte, le but, les contraintes. Exemple : « Migre le composant Nav pour utiliser lucide-react au lieu du CDN. Préserve les props et le comportement actuels. Touche le minimum de fichiers. »
3. Lis le plan attentivement. Pas juste survoler. Vérifie les fichiers listés, l'ordre proposé, les choix d'implémentation. Si quelque chose te chiffonne, demande à Claude de revoir : « Le plan touche aussi src/utils, est-ce nécessaire ? »
4. Valide ou affine. Quand le plan est bon, tu lances l'exécution. Sinon, tu reformules et Claude refait un plan.

Ce qui est puissant, c'est que tu peux avoir une vraie discussion sur l'approche AVANT le moindre changement de code. Tu restes le décideur, l'agent exécute.

Combiner Plan Mode et CLAUDE.md

Plan Mode et CLAUDE.md se renforcent mutuellement. Quand Claude planifie, il intègre les règles de ton CLAUDE.md dans son plan. Si ton CLAUDE.md dit « ne jamais utiliser le CDN Lucide », le plan ne contiendra pas d'étape qui viole cette règle.

Inversement, si Plan Mode propose une approche que tu n'aimes pas, c'est souvent le signal qu'il manque une règle dans ton CLAUDE.md. Profites-en pour l'ajouter, et la prochaine fois Claude prendra le bon chemin spontanément.

MCP (Model Context Protocol) est sans doute la fonctionnalité qui transforme le plus radicalement Claude Code. Elle lui permet de se connecter à des services externes : ta base de données, Figma, Linear, GitHub, ton navigateur, n'importe quoi. Au lieu d'être un agent isolé dans ton terminal, Claude Code devient un agent qui a accès à tout ton stack. Si tu comprends bien MCP, tu comprends pourquoi Claude Code est qualitativement différent des autres assistants de code.

C'est quoi MCP exactement

MCP est un standard ouvert créé par Anthropic en 2024. L'analogie la plus simple : c'est l'USB-C des LLMs. Avant USB-C, chaque appareil avait son propre câble. Maintenant tout se branche pareil. Avant MCP, chaque assistant IA avait sa propre façon de se connecter à des services externes (souvent aucune). MCP standardise tout ça.

Concrètement, un serveur MCP expose des « tools » (actions que Claude peut faire) et des « resources » (données qu'il peut lire). Claude Code se connecte au serveur, voit la liste des tools disponibles, et les utilise quand pertinent dans la conversation.

Exemple concret : tu installes le serveur MCP GitHub. Quand tu dis à Claude « crée une issue avec ce qu'on vient de discuter », il voit qu'un tool create_issue est dispo, l'appelle avec les bons paramètres, et l'issue est créée. Pas besoin de quitter le terminal, pas besoin de copier-coller. C'est de l'automatisation conversationnelle.

Cas d'usage concrets

Voici cinq MCP parmi les plus courants, du plus généraliste au plus spécifique :

• GitHub MCP Créer des issues, des pull requests, lister les commits récents, lire des fichiers d'autres repos. Indispensable si ton code est sur GitHub.
• Filesystem MCP Permet à Claude d'accéder à des dossiers en dehors du projet courant. Utile pour bidouiller plusieurs projets en même temps sans changer de session.
• Playwright MCP Claude peut piloter un navigateur. Tester ton site en condition réelle, faire des captures d'écran, scraper des données. Très puissant pour le QA.
• Postgres / SQLite MCP Interroger directement ta base de données. Claude peut vérifier le schéma, suggérer des migrations, écrire des requêtes optimisées en connaissant la structure réelle.
• Figma MCP Extraire les specs d'un design Figma directement (couleurs, typographie, espacements). Top pour transformer une maquette en code sans aller-retour copier-coller.

Une combinaison fréquente : le MCP filesystem pour travailler sur plusieurs projets en parallèle, et le MCP Playwright pour vérifier dans un vrai navigateur qu'une correction d'interface fonctionne. Ça évite de jongler entre les fenêtres.

Installer un serveur MCP

L'installation se fait en deux temps. D'abord, tu installes le serveur (généralement via npm ou un binaire). Ensuite, tu l'enregistres dans Claude Code.

Méthode rapide : la commande claude mcp add fait les deux étapes pour les MCPs officiels. Par exemple :

claude mcp add github

Claude Code te guide pour l'authentification (token GitHub à coller), puis le serveur est dispo dans toutes tes sessions futures.

Méthode manuelle : pour les MCPs custom ou avancés, tu édites le fichier ~/.claude/mcp.json :

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "ghp_xxx" }
    }
  }
}

Une fois configuré, lance /mcp dans Claude Code pour voir la liste des serveurs connectés et tester qu'ils répondent bien.

Les MCP les plus utiles pour démarrer

Si tu découvres MCP, je recommande cet ordre :

1. Filesystem Le plus simple à configurer, immédiatement utile.
2. GitHub Si ton code est sur GitHub. ROI immédiat sur la gestion des issues et PRs.
3. Playwright Dès que tu travailles sur du frontend. Permet à Claude de vérifier que ses fixes fonctionnent visuellement.

Pour les autres (Postgres, Figma, Linear, Notion, Slack, et la centaine de MCPs communautaires), ajoute-les selon tes besoins. Le registry officiel est sur github.com/modelcontextprotocol/servers.

Créer son propre MCP server

Si aucun MCP existant ne couvre ton besoin (ton API interne, ton outil maison), tu peux en créer un. C'est plus simple qu'on ne pense : un MCP server est juste un programme qui expose des tools via un protocole JSON-RPC standardisé.

Anthropic fournit des SDKs en TypeScript et Python. En une heure, tu as un MCP qui expose tes tools custom à Claude Code. Le sujet mérite un article dédié, on y reviendra.

Sécurité MCP, ce qu'il faut savoir

Un MCP server donne à Claude Code des capacités d'agir sur des systèmes externes. C'est puissant mais ça demande deux précautions :

Permissions granulaires : configure le minimum de permissions nécessaire. Pour le MCP GitHub, ne donne pas un token avec accès admin si tu as juste besoin de lire les issues. Plus le token est restreint, moins une erreur de Claude peut faire de dégâts.

Confiance dans le serveur : un MCP server tiers peut techniquement faire tout ce que ses tools déclarent. Avant d'installer un MCP communautaire, vérifie son code source ou son éditeur. Préfère les MCPs officiels d'Anthropic pour les actions sensibles.

Confirmations explicites : Claude Code te demande confirmation avant chaque action MCP qui modifie quelque chose (créer une issue, supprimer un fichier, etc.). Ne désactive pas ces confirmations sauf cas très spécifique.

Les subagents et les skills sont deux mécanismes différents qui répondent à un même problème : étendre les capacités de Claude Code au-delà de ses fonctions de base. Les subagents permettent de déléguer une tâche à un Claude isolé. Les skills permettent de créer des fonctionnalités personnalisées qui s'invoquent dans n'importe quelle session. Ensemble, ils transforment Claude Code en plateforme extensible.

Subagents, déléguer une tâche à un Claude isolé

Quand tu travailles sur une grosse tâche, ta conversation avec Claude se charge progressivement : fichiers lus, code analysé, décisions prises. Plus la conversation est longue, plus Claude consomme de tokens et plus il peut perdre en précision sur les nouveaux sujets.

Un subagent résout ce problème. C'est un Claude secondaire que ton Claude principal lance pour une tâche précise et isolée. Le subagent fait son boulot dans son propre contexte, retourne un résumé, et disparaît. Le contexte principal reste léger.

Cas d'usage typiques :

• Recherche dans une grosse codebase « trouve tous les usages de cette API dans le repo ». Le subagent parcourt les fichiers, le contexte principal reçoit juste la liste.
• Audit ou exploration « analyse l'architecture du dossier components/ et donne un résumé en 200 mots ». Le subagent fait l'exploration, retourne la synthèse.
• Tâches parallèles Trois subagents qui font trois recherches indépendantes en même temps. Beaucoup plus rapide que séquentiel.
• Tests ou validation Un subagent qui lance la suite de tests et résume les échecs.

Concrètement, tu n'as rien à faire pour activer les subagents. Claude Code décide lui-même de les utiliser quand c'est pertinent. Mais tu peux le suggérer explicitement : « Lance un subagent pour explorer le dossier X pendant qu'on continue ici ».

Types de subagents disponibles

Claude Code embarque plusieurs types de subagents spécialisés :

• general-purpose Le subagent par défaut, capable de tout. Utilise tous les tools dispos.
• Explore Optimisé pour la navigation de codebase. Plus rapide, plus précis sur les recherches de fichiers et de patterns.
• Plan Architecte qui conçoit des plans d'implémentation. Utile pour préparer un gros refactor ou une nouvelle feature.

Tu peux aussi créer tes propres types de subagents pour des tâches récurrentes spécifiques à ton projet (un subagent « qa » pour tes tests, un subagent « docs » pour la documentation, etc.).

Skills, les fonctionnalités personnalisées

Une skill, c'est une procédure que tu veux que Claude exécute de la même façon à chaque fois, dans n'importe quel projet. Par exemple : ton process de code review, ton format de commit message, ta checklist de déploiement.

Une skill se définit dans un fichier markdown avec un nom, une description, et des instructions. Quand tu l'invoques (via /nom-de-la-skill ou par déclenchement automatique selon la description), Claude exécute la procédure définie.

Différence avec les subagents : les skills sont des procédures réutilisables que TU définis. Les subagents sont des aides ponctuelles que Claude lance lui-même.

Créer une skill custom

Une skill est un fichier dans ~/.claude/skills/nom-skill/SKILL.md (skill globale) ou .claude/skills/nom-skill/SKILL.md (skill du projet). Voici une skill exemple pour automatiser un audit pré-commit :

---
name: audit-pre-commit
description: Audit du code avant commit (typescript, lint, tests)
---

# Audit pre-commit

Lance dans cet ordre et stop au premier echec :
1. npx tsc --noEmit (verification typescript)
2. npm run lint (eslint)
3. npm test -- --run (tests vitest)

Si tout passe, affiche "OK pour commit".
Si quelque chose echoue, affiche les erreurs et propose un fix.
Ne corrige pas automatiquement, demande validation.

Tu invoques avec /audit-pre-commit dans n'importe quelle session. Claude suit la procédure exactement. Plus besoin de réexpliquer à chaque fois.

Skills officielles Anthropic

Anthropic fournit plusieurs skills prêtes à l'emploi pour les cas courants :

• pdf : lire, créer, manipuler des PDFs.
• docx : créer et éditer des documents Word.
• xlsx : manipuler des spreadsheets Excel.
• pptx : créer des slide decks PowerPoint.
• skill-creator : meta-skill qui aide à créer de nouvelles skills.

Ces skills s'activent automatiquement quand le contexte le demande. Si tu demandes à Claude de « lire ce PDF », il invoque la skill pdf sans que tu aies à le préciser.

Workflow combiné, l'efficacité maximale

Un workflow adapté aux gros chantiers :

1. Plan Mode pour cadrer la stratégie globale.
2. Subagents pour les explorations en parallèle (chercher tous les fichiers concernés, vérifier la structure actuelle).
3. Skills custom pour les étapes répétitives (lint, tests, formatage).
4. MCP pour les actions sur les services externes (créer la PR à la fin).

Une fois cette stack configurée, tu passes de « j'utilise un assistant de code » à « j'orchestre une équipe d'agents spécialisés ». Le saut de productivité est réel.

Les hooks sont une couche d'automatisation qui se déclenche autour des actions de Claude Code. Avant qu'il n'utilise un tool, après une modification de fichier, à la fin d'une session : tu peux attacher des scripts qui s'exécutent automatiquement. C'est ce qui transforme Claude Code d'un agent ponctuel en composant intégré dans ton workflow de dev.

C'est quoi un hook

Un hook est un script (bash, python, n'importe quoi qui se lance en ligne de commande) qui se déclenche sur un événement. Claude Code définit plusieurs événements auxquels tu peux t'accrocher : avant l'usage d'un tool, après l'usage d'un tool, à l'envoi d'un prompt par l'utilisateur, à la fin d'une réponse, etc.

Quand l'événement se produit, Claude Code lance ton script avec des données contextuelles (quel tool, quels arguments, quel fichier modifié). Ton script fait ce qu'il veut et peut éventuellement bloquer l'action ou retourner un message.

Les types de hooks principaux

• PreToolUse Déclenché avant que Claude n'utilise un tool. Utile pour valider, autoriser, ou bloquer une action sensible.
• PostToolUse Déclenché après l'usage d'un tool. Le plus utilisé. Parfait pour lancer un linter après chaque Edit, ou un formatter après un Write.
• UserPromptSubmit Déclenché à chaque fois que tu envoies un message. Permet d'enrichir le contexte ou de logger ce que tu demandes.
• Stop Déclenché en fin de réponse. Utile pour des notifications (son, popup) ou un récap automatique.
• Notification Déclenché quand Claude te demande quelque chose. Permet d'attirer ton attention si tu étais ailleurs.

Exemples utiles

Auto-formatter après chaque Edit : Claude modifie un fichier .ts ? Lance Prettier dessus automatiquement.

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{ "type": "command", "command": "prettier --write {{file_path}}" }]
    }]
  }
}

Validation TypeScript après gros changements : si Claude modifie plusieurs fichiers, vérifier que rien ne casse.

{
  "hooks": {
    "Stop": [{
      "hooks": [{ "type": "command", "command": "npx tsc --noEmit" }]
    }]
  }
}

Sound alert quand Claude attend ton input : pratique pour les longues sessions où tu travailles en parallèle.

{
  "hooks": {
    "Notification": [{
      "hooks": [{ "type": "command", "command": "afplay /System/Library/Sounds/Glass.aiff" }]
    }]
  }
}

Comment configurer un hook

Les hooks se configurent dans ~/.claude/settings.json (global) ou .claude/settings.json (par projet). Le format est simple :

{
  "hooks": {
    "EVENT_NAME": [
      {
        "matcher": "TOOL_PATTERN_OPTIONNEL",
        "hooks": [
          { "type": "command", "command": "VOTRE_COMMANDE" }
        ]
      }
    ]
  }
}

Le matcher est un regex qui filtre quand le hook se déclenche. Par exemple "Edit|Write" pour ne déclencher que sur les modifications de fichiers, ignorer les Read.

Les variables disponibles dans la commande dépendent de l'événement. Pour PostToolUse sur un Edit, tu as {{file_path}}, {{old_string}}, {{new_string}}, etc. La doc Anthropic liste les variables exactes par événement.

Hooks vs MCP vs Skills, quand utiliser quoi

Trois outils proches mais avec des usages distincts :

• Hook Déclenché AUTOMATIQUEMENT sur un événement. Tu ne décides pas, Claude Code les lance. Pour : lint, format, tests, alerts.
• MCP Un service externe que Claude PEUT appeler quand pertinent. Lui décide. Pour : GitHub, base de données, navigateur, services tiers.
• Skill Une procédure que tu INVOQUES explicitement (ou qui se déclenche selon une description). Pour : audits, checklists, workflows répétables.

Règle simple : si c'est « à chaque fois que Claude fait X, fais Y » → hook. Si c'est « Claude peut accéder à Y quand pertinent » → MCP. Si c'est « quand je le demande, fais cette procédure » → skill.

Exemple classique : un hook PostToolUse qui lance Prettier après chaque Edit/Write. Tout le code commité suit alors le même format, sans jamais y penser à la main.

Quatre outils, quatre philosophies. Si tu hésites entre Claude Code et ses concurrents, voici un résumé rapide de ce qui les distingue. Le comparatif détaillé Claude Code vs Cursor creuse le match le plus serré.

Claude Code, l'agent autonome

Claude Code est un agent qui vit dans le terminal. Tu lui donnes une mission, il l'exécute de bout en bout. Il comprend toute ta codebase, modifie plusieurs fichiers, lance les tests, corrige les erreurs. C'est le plus puissant des quatre pour les tâches complexes et le refactoring massif. Idéal aussi pour les non-développeurs qui veulent créer des projets complets.

Cursor, l'éditeur augmenté

Cursor est un fork de VS Code avec l'IA intégrée nativement. Complétion de code en temps réel, chat contextuel, édition inline. C'est le plus productif pour le développement quotidien, tu codes plus vite sans changer tes habitudes. Multi-modèles (Claude, GPT-5, Gemini). Moins autonome que Claude Code sur les grosses tâches.

GitHub Copilot, le pionnier

Copilot a popularisé l'assistance IA au code. Bonne complétion inline, intégré à VS Code et d'autres éditeurs. Mais en 2026, il a pris du retard : moins contextuel que Cursor, bien moins autonome que Claude Code. Son avantage reste l'intégration native à l'écosystème GitHub.

Codex CLI, la réponse d'OpenAI

Codex CLI est l'outil terminal d'OpenAI sorti en 2025, positionné directement face à Claude Code. Même concept : agent autonome qui vit dans le terminal, modifie tes fichiers, exécute des commandes. La différence se joue sur trois axes.

Modèle : Codex CLI tourne sur GPT-5, Claude Code sur Sonnet 4 et Opus 4. Sur les benchmarks de code (SWE-bench notamment), les deux sont au coude à coude. Dans la pratique, Claude Sonnet 4 est souvent plus précis sur le refactoring et le debug profond, GPT-5 plus rapide sur la génération initiale.

Écosystème : Claude Code a un écosystème plus mature côté MCP (la majorité des MCPs développés par la communauté sont d'abord pour Claude Code). Codex CLI rattrape mais reste derrière. Pour les workflows avancés (hooks, skills, subagents), Claude Code est plus complet.

Tarification : les deux sont compris dans leurs abonnements respectifs (Claude Pro/Max pour Claude Code, ChatGPT Plus/Pro pour Codex CLI). Tarifs proches sans être identiques : 18 €/mois pour Claude Pro, 23 €/mois pour ChatGPT Plus. Si tu as déjà l'un des deux abonnements, ça oriente naturellement ton choix.

Mon avis honnête : pour un développeur qui débute avec les agents en terminal, Claude Code est plus facile à prendre en main et son écosystème est plus riche. Codex CLI est solide aussi, surtout si tu es déjà investi dans l'écosystème OpenAI. Les deux progressent vite, donc le match évolue chaque mois.

Mon verdict rapide

• Tu ne codes pas et veux créer des projets → Claude Code
• Tu codes tous les jours et veux aller plus vite → Cursor
• Tu es déjà dans l'écosystème GitHub et veux rester simple → Copilot
• Tu es déjà sur ChatGPT Plus et veux tester un agent terminal → Codex CLI
• Tu veux le plus complet pour les workflows avancés (MCP, hooks, skills) → Claude Code
• Tu veux le maximum de puissance → Claude Code + Cursor ensemble

Pour un comparatif complet avec tableaux et cas d'usage détaillés, consulte notre comparatif Claude Code vs Cursor.

Une fois les bases en place (CLAUDE.md, MCP, subagents, hooks), Claude Code peut devenir bien plus puissant qu'un simple assistant de code. Voici les techniques les plus utiles une fois ces bases maîtrisées.

Combiner CLAUDE.md + Skills + Subagents pour des workflows agentiques

La vraie force de Claude Code en 2026 ne vient pas d'une seule fonctionnalité, mais de leur combinaison. Le pattern qui change tout : un CLAUDE.md qui définit le projet, des Skills qui encodent tes procédures (commit, review, deploy) et des Subagents qui paralélisent les tâches lourdes. Concrètement : tu lances une commande haut niveau (« ajoute le module facturation »), Claude orchestre, lance 2-3 subagents en parallèle pour explorer différentes parties du code, applique tes Skills pour respecter tes conventions, et te présente un plan exécutable. Le tout sans polluer ton contexte principal.

Hooks pour CI/CD local

Les hooks PostToolUse permettent de transformer Claude Code en pipeline CI/CD local. Exemple de montage : un PostToolUse qui lance Prettier après chaque Edit/Write, un autre qui lance ESLint sur les fichiers .ts modifiés, et un Stop hook qui exécute la suite de tests rapides avant le commit. Résultat : du code mal formaté ou qui casse les tests ne passe plus, sans configuration côté Git.

Multi-agent orchestration pour les refactorings massifs

Pour un refactoring qui touche 30+ fichiers, l'approche standard (tout faire dans le contexte principal) explose le contexte et dégrade la qualité. La technique avancée : orchestrer 5-10 subagents en parallèle, chacun responsable d'un dossier ou d'un domaine. Chaque subagent reçoit un mini-CLAUDE.md spécifique à sa zone, fait son refactoring, retourne un résumé structuré. L'agent principal consolide, vérifie la cohérence, et lance les tests. Tu gardes 80 % de ton contexte libre pour les décisions, l'exécution se fait dans des contextes isolés.

Plan Mode pour les décisions techniques critiques

Plan Mode (Shift+Tab) est sous-utilisé en 2026. Les développeurs avancés l'activent systématiquement pour toute tâche qui touche plus de 2 fichiers, ou qui implique un choix architectural. Au lieu d'écrire du code que tu devras sans doute jeter, Claude présente 3 approches avec leurs trade-offs, tu choisis, et l'exécution démarre sur la bonne piste. Pour une modification triviale et évidente, le mode normal suffit.

Patterns de prompts pour développeurs séniors

Trois patterns qui changent tout :

• Spec-first prompting Avant toute implémentation, demande à Claude d'écrire la spec en markdown (interface, types, contrats, edge cases). Tu valides la spec, ensuite il code. Évite 90 % des malentendus.
• Test-first prompting « écris d'abord les tests qui doivent passer, montre-les moi, on en discute, ensuite tu codes l'implémentation ». Forcer Claude à expliciter les comportements attendus avant d'écrire le code améliore drastiquement la qualité.
• Adversarial prompting Après chaque feature, « lance un subagent qui critique ce code comme un reviewer hostile, identifie les bugs potentiels, les edge cases manqués, les performances dégradées ». Tu trouves 80 % des problèmes avant qu'ils n'arrivent en prod.

Connecter Claude Code à ton observabilité

Avec MCP, tu peux exposer tes logs Datadog, Sentry, ou Grafana directement à Claude Code. Lors d'un debug, au lieu de copier-coller des stack traces, Claude requête la source. Encore plus puissant : un MCP qui expose ta métrique principale (latence p99, taux d'erreur) permet à Claude de vérifier en temps réel l'impact de ses changements sur la production. Pour les équipes SRE, c'est un game-changer.

Workflow continu plutôt que sessions ponctuelles

La différence entre les développeurs débutants et avancés sur Claude Code : les premiers lancent claude, font une tâche, ferment. Les seconds gardent une session ouverte toute la journée, accumulant le contexte projet, demandant à Claude de mettre à jour CLAUDE.md au fil de l'eau, créant des skills à la volée pour les patterns récurrents. Au bout de quelques semaines, ton Claude Code devient un collègue qui connaît parfaitement ton projet et tes préférences. Cet investissement contextuel est le levier #1 pour augmenter ta productivité.

Ces techniques demandent un peu de pratique, mais ce sont elles qui font passer Claude Code d'un assistant à un vrai outil de production.

Parlons argent. Claude Code n'est pas gratuit, mais les options sont flexibles selon ton usage. Voici le détail des prix en 2026.

Option 1 : Claude Pro (18 €/mois)

C'est l'option que je recommande pour commencer. L'abonnement Claude Pro sur claude.ai te donne accès à Claude Code avec un quota d'utilisation généreux. Pour la plupart des projets personnels et des petits projets professionnels, c'est largement suffisant. Tu auras accès à Claude Sonnet 4, le modèle qui offre le meilleur rapport performance/vitesse.

Option 2 : Claude Max (100$ ou 200$/mois)

Pour les développeurs intensifs. Le plan Max à 100$/mois multiplie par 5 le quota de Claude Code par rapport au Pro. Le plan à 200$/mois le multiplie par 20. Si tu utilises Claude Code plusieurs heures par jour sur des projets lourds, ce plan se justifie. Tu as aussi accès à Claude Opus 4, le modèle le plus puissant d'Anthropic.

Option 3 : API à l'usage

Pour les utilisateurs avancés et les entreprises. Tu paies uniquement ce que tu consommes, au token. Le tarif dépend du modèle utilisé : Sonnet 4 est nettement moins cher qu'Opus 4. Cette option est idéale si ton usage est irrégulier (certains jours beaucoup, d'autres rien) ou si tu intègres Claude Code dans des workflows automatisés.

Quel plan choisir ?

• Usage occasionnel (quelques projets par semaine) : Claude Pro à 18 €/mois
• Usage quotidien intensif (développeur à temps plein) : Claude Max à 100$/mois
• Projets très lourds ou usage en équipe API ou Max à 200$/mois

Mon conseil : commence avec Claude Pro. Si tu atteins régulièrement les limites d'usage (Claude Code te prévient quand tu approches), passe au Max. Ne commence pas directement par l'API sauf si tu sais ce que tu fais, la gestion des coûts API demande un peu d'expérience.