Claude Code : Guide Complet pour Créer avec l'IA (Même Sans Coder)

Claude Code est un agent de développement créé par Anthropic, l'entreprise derrière Claude. Contrairement à ChatGPT ou Claude.ai que vous utilisez dans un navigateur, Claude Code fonctionne directement dans votre 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 votre 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 vos 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 vous 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 : vous copiez-collez du code dans un chat, l'IA vous répond avec des suggestions que vous devez appliquer manuellement. C'est un échange conversationnel.
• Claude Code : vous donnez une instruction ("ajoute un formulaire de contact à mon site"), et l'agent navigue dans vos 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, vous pouvez inspecter exactement ce qu'il fait sous le capot.

Ce qui me fascine le plus, c'est que Claude Code rend la création de logiciels accessible à des gens qui n'ont jamais écrit une ligne de code. Vous décrivez votre 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 vous n'avez jamais touché un terminal. Mais suivez ces étapes dans l'ordre et vous serez opérationnel en moins de 10 minutes. Je vous 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échargez la version LTS sur nodejs.org, ou sur Mac utilisez 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 : votre compte Claude Pro existant.

Installation étape par étape

1. Ouvrez votre terminal

   Sur Mac, cherchez "Terminal" dans Spotlight. Sur Windows, utilisez PowerShell ou Windows Terminal. Sur Linux, vous savez déjà où c'est.

2. Installez Claude Code en global

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

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

3. Naviguez vers votre projet

   Rendez-vous dans le dossier de votre projet, ou créez-en un vide pour tester.

   cd ~/mon-projet

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

4. Lancez Claude Code

   Tapez simplement claude. La première fois, l'agent vous demandera de vous authentifier via un lien à ouvrir dans votre navigateur.

Première configuration

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

• Explorer

  "Explique-moi la structure de ce projet" : pour voir comment il analyse votre 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.

Vous verrez immédiatement comment Claude Code fonctionne : il vous montre ce qu'il fait, vous demande confirmation avant de modifier des fichiers, et vous explique ses choix.

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

1. Un site portfolio personnel

Le classique pour débuter. Un site simple qui vous présente, avec vos compétences et un moyen de vous 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 vos 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 vous utiliserez vraiment. Entrez les infos, générez 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éez votre 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 vous guider pour lancer le résultat dans votre navigateur. N'hésitez 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 vous passez à corriger les sorties de l'agent.

Pourquoi CLAUDE.md change tout

Imaginez que vous embauchez un nouveau dev demain. Vous allez 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 vous avez 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 vous lui faites une fois pour toutes. Il le lit automatiquement, sans que vous ayez 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 vous êtes 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. Vous gagnez 30 à 50% de temps par session, le code ressemble au reste du projet, 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 vos projets. Pour votre style de code préféré et vos préférences personnelles.

• 📁 Projet

  CLAUDE.md à la racine

  Le plus utilisé. Toutes les règles propres au projet courant. Versionnez-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

Mon template de base couvre six sections. Vous pouvez en ajouter ou en retirer selon votre projet :

1. Stack technique

   Versions exactes des frameworks, libs principales, langage. Évitez à Claude de proposer du code Vue 2 alors que vous êtes en Vue 3, ou du React class-component alors que vous êtes 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. Évitez à 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. Listez 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. Vous pouvez 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 100 fois plus efficace : toujours visible sans scanner le codebase.

Astuces avancées

1. Versionnez votre CLAUDE.md

   Commitez-le dans git. Toute votre é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éfixez avec "IMPORTANT" ou "CRITICAL"

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

3. Itérez régulièrement

   À chaque fois que Claude fait une erreur que vous corrigez à la main, ajoutez une ligne. En quelques semaines, votre fichier capture toute la connaissance tribale du projet.

4. Spécialisez par sous-dossier

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

Mon conseil. Démarrez petit : 10 lignes, 3 sections. Stack + ne jamais faire + ton. Enrichissez au fil des sessions quand Claude se trompe. En 2 semaines, vous aurez 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 à votre demande, vous présente un plan détaillé, et n'exécute rien tant que vous n'avez 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". Vous lui demandez quelque chose, il modifie les fichiers, vous validez chaque action ou il enchaîne directement.

En Plan Mode, c'est différent. Claude Code ne touche à aucun fichier. Il peut lire votre code, faire des recherches, explorer la codebase, mais aucune écriture. À la fin, il vous présente un plan structuré : quels fichiers il va modifier, dans quel ordre, et pourquoi. Vous validez (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). Vous voyez le mode actif en bas du terminal.
• Au démarrage : lancez claude --plan pour démarrer directement en Plan Mode.

Une fois en Plan Mode, demandez ce que vous voulez normalement. Claude va explorer, réfléchir, et finir par un plan. Vous validez 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 vous é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 vous n'aviez pas anticipés.
• Debug profond : "trouve pourquoi cette page ne charge pas chez certains users". Le plan vous montre où Claude pense que se trouve le problème, vous pouvez 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, mettez Plan Mode. Sinon, mode normal.

Workflow recommandé

Le workflow que j'utilise quotidiennement :

1. Activez Plan Mode (Shift+Tab) avant de lancer la demande.
2. Formulez votre demande clairement. Précisez 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. Lisez le plan attentivement. Pas juste survoler. Vérifiez les fichiers listés, l'ordre proposé, les choix d'implémentation. Si quelque chose vous chiffonne, demandez à Claude de revoir : "Le plan touche aussi src/utils, est-ce nécessaire ?"
4. Validez ou affinez. Quand le plan est bon, vous lancez l'exécution. Sinon, vous reformulez et Claude refait un plan.

Ce qui est puissant, c'est que vous pouvez avoir une vraie discussion sur l'approche AVANT le moindre changement de code. Vous restez 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 votre CLAUDE.md dans son plan. Si votre 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 vous n'aimez pas, c'est souvent le signal qu'il manque une règle dans votre CLAUDE.md. Profitez-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 : votre base de données, Figma, Linear, GitHub, votre navigateur, n'importe quoi. Au lieu d'être un agent isolé dans votre terminal, Claude Code devient un agent qui a accès à tout votre stack. Si vous comprenez bien MCP, vous comprenez 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 : vous installez le serveur MCP GitHub. Quand vous dites à 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 les cinq MCP que j'utilise vraiment au quotidien, du plus utile 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 votre 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 votre 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 votre 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.

Sur LesAstucesIA, j'utilise principalement le MCP filesystem pour bidouiller mes outils de prod en parallèle, et le MCP Playwright pour vérifier que les fixes UI marchent vraiment dans le navigateur. Ça évite de perdre du temps à switcher entre fenêtres.

Installer un serveur MCP

L'installation se fait en deux temps. D'abord, vous installez le serveur (généralement via npm ou un binaire). Ensuite, vous l'enregistrez 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 vous guide pour l'authentification (token GitHub à coller), puis le serveur est dispo dans toutes vos sessions futures.

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

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

Une fois configuré, lancez /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 vous découvrez MCP, je recommande cet ordre :

1. Filesystem : le plus simple à configurer, immédiatement utile.
2. GitHub : si votre code est sur GitHub. ROI immédiat sur la gestion des issues et PRs.
3. Playwright : dès que vous travaillez 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), ajoutez-les selon vos besoins. Le registry officiel est sur github.com/modelcontextprotocol/servers.

Créer son propre MCP server

Si aucun MCP existant ne couvre votre besoin (votre API interne, votre outil maison), vous pouvez 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, vous avez un MCP qui expose vos 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 : configurez le minimum de permissions nécessaire. Pour le MCP GitHub, ne donnez pas un token avec accès admin si vous avez 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érifiez son code source ou son éditeur. Préférez les MCPs officiels d'Anthropic pour les actions sensibles.

Confirmations explicites : Claude Code vous demande confirmation avant chaque action MCP qui modifie quelque chose (créer une issue, supprimer un fichier, etc.). Ne désactivez 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 vous travaillez sur une grosse tâche, votre 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 votre 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, vous n'avez rien à faire pour activer les subagents. Claude Code décide lui-même de les utiliser quand c'est pertinent. Mais vous pouvez 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.

Vous pouvez aussi créer vos propres types de subagents pour des tâches récurrentes spécifiques à votre projet (un subagent "qa" pour vos tests, un subagent "docs" pour la documentation, etc.).

Skills, les fonctionnalités personnalisées

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

Une skill se définit dans un fichier markdown avec un nom, une description, et des instructions. Quand vous l'invoquez (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 VOUS définissez. 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.

Vous invoquez 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 vous demandez à Claude de "lire ce PDF", il invoque la skill pdf sans que vous ayez à le préciser.

Workflow combiné, l'efficacité maximale

Le workflow le plus efficace que j'utilise sur les 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, vous passez 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 : vous pouvez attacher des scripts qui s'exécutent automatiquement. C'est ce qui transforme Claude Code d'un agent ponctuel en composant intégré dans votre 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 vous pouvez vous 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 votre script avec des données contextuelles (quel tool, quels arguments, quel fichier modifié). Votre 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 vous envoyez un message. Permet d'enrichir le contexte ou de logger ce que vous demandez.
• Stop : déclenché en fin de réponse. Utile pour des notifications (son, popup) ou un récap automatique.
• Notification : déclenché quand Claude vous demande quelque chose. Permet d'attirer votre attention si vous étiez 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 votre input : pratique pour les longues sessions où vous travaillez 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, vous avez {{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. Vous ne décidez 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 vous INVOQUEZ 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.

Sur LesAstucesIA, j'utilise un hook PostToolUse pour Prettier sur chaque Edit/Write. C'est ce qui garantit que tout le code commit suit le même format, sans que je ne pense jamais à le formatter à la main.

Quatre outils, quatre philosophies. Si vous hésitez entre Claude Code et ses concurrents, voici un résumé rapide de ce qui les distingue. J'ai écrit un comparatif détaillé Claude Code vs Cursor si vous voulez creuser le match le plus serré.

Claude Code, l'agent autonome

Claude Code est un agent qui vit dans le terminal. Vous lui donnez une mission, il l'exécute de bout en bout. Il comprend toute votre 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, vous codez plus vite sans changer vos habitudes. Multi-modèles (Claude, GPT-4o, 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 vos 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 comparables (20$/mois pour le plan d'entrée). Si vous avez déjà l'un des deux abonnements, ça oriente naturellement votre 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 vous êtes déjà investi dans l'écosystème OpenAI. Les deux progressent vite, donc le match évolue chaque mois.

Mon verdict rapide

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

Pour un comparatif complet avec tableaux et cas d'usage détaillés, consultez 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 que j'utilise au quotidien sur LesAstucesIA et que j'ai vu remonter chez les développeurs les plus avancés en 2026.

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 vos procédures (commit, review, deploy) et des Subagents qui paralélisent les tâches lourdes. Concrètement : vous lancez 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 vos Skills pour respecter vos conventions, et vous présente un plan exécutable. Le tout sans polluer votre contexte principal.

Hooks pour CI/CD local

Les hooks PostToolUse permettent de transformer Claude Code en pipeline CI/CD local. Sur LesAstucesIA, j'ai 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 que je commit. Résultat : impossible de commit du code mal formaté ou qui casse les tests, sans configuration côté Git. Économie de temps phénoménale par rapport au workflow traditionnel pre-commit.

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. Vous gardez 80% de votre 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 vous devrez sans doute jeter, Claude présente 3 approches avec leurs trade-offs, vous choisissez, et l'exécution démarre sur la bonne piste. Sur les projets sérieux, j'utilise Plan Mode 80% du temps. Le 20% restant, c'est uniquement pour des modifications triviales évidentes.

Patterns de prompts pour développeurs séniors

Trois patterns qui changent tout :

• Spec-first prompting : avant toute implémentation, demandez à Claude d'écrire la spec en markdown (interface, types, contrats, edge cases). Vous validez 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". Vous trouvez 80% des problèmes avant qu'ils n'arrivent en prod.

Connecter Claude Code à votre observabilité

Avec MCP, vous pouvez exposer vos 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 votre 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, votre Claude Code devient un collègue qui connaît parfaitement votre projet et vos préférences. Cet investissement contextuel est le levier #1 pour augmenter votre productivité.

Ces techniques ne sont pas du tout des bonus optionnels en 2026. Sur les benchmarks internes que j'ai vus chez plusieurs entreprises tech FR, les développeurs qui les maîtrisent sortent 3 à 5 fois plus de fonctionnalités par semaine que ceux qui restent sur l'utilisation basique. La courbe d'apprentissage est de 2-3 semaines. L'investissement vaut largement le coup.

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

Option 1 : Claude Pro (20$/mois)

C'est l'option que je recommande pour commencer. L'abonnement Claude Pro sur claude.ai vous 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. Vous aurez 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 vous utilisez Claude Code plusieurs heures par jour sur des projets lourds, ce plan se justifie. Vous avez 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. Vous payez uniquement ce que vous consommez, 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 votre usage est irrégulier (certains jours beaucoup, d'autres rien) ou si vous intégrez Claude Code dans des workflows automatisés.

Quel plan choisir ?

• Usage occasionnel (quelques projets par semaine) : Claude Pro à 20$/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 : commencez avec Claude Pro. Si vous atteignez régulièrement les limites d'usage (Claude Code vous prévient quand vous approchez), passez au Max. Ne commencez pas directement par l'API sauf si vous savez ce que vous faites, la gestion des coûts API demande un peu d'expérience.