Claude Code : le guide complet 2026 (installation, commandes, workflows)

Qu’est-ce que Claude Code exactement ?

Claude Code, c’est l’agent de programmation officiel d’Anthropic. Techniquement, c’est un outil en ligne de commande qui wrappe les modèles Claude (Sonnet 4.6, Opus 4.7, Haiku 4.5 en avril 2026) et leur donne accès à ta machine : lecture de fichiers, écriture de fichiers, exécution de commandes bash, appels HTTP, et beaucoup d’autres capacités via le protocole MCP.

Concrètement, tu lances claude dans un terminal, tu décris ce que tu veux, et Claude exécute.

La vision d’Anthropic : « agentic coding »

L’idée sous-jacente est simple. ChatGPT et Copilot te donnent des suggestions, mais c’est toi qui les appliques. Claude Code fait. Il lit ton code, propose un plan, applique les changements, lance les tests, te montre les diffs. Tu restes dans la boucle pour valider, mais tu n’es plus le scribe.

On parle d’agentic coding : le modèle n’est plus un oracle auquel on demande des conseils, c’est un collaborateur qui exécute des tâches multi-étapes avec autonomie contrôlée.

Comment ça marche sous le capot

Claude Code s’appuie sur deux mécanismes clés :

• Tool use : les modèles Claude savent appeler des « outils » (fonctions exposées par l’agent : Read, Write, Bash, Grep, Edit, etc.). Chaque action de Claude est un tool call que tu peux voir passer.
• Context window large : Sonnet 4.6 et Opus 4.7 disposent de 1 million de tokens au tarif standard, sans premium long-context. Haiku 4.5 reste à 200K tokens. Claude peut donc lire de gros fichiers ou naviguer dans un projet entier sans perdre le fil. Source : platform.claude.com/docs/en/about-claude/pricing.

En pratique, ça veut dire que Claude peut explorer un projet inconnu (grep, read, glob), construire une représentation mentale, puis proposer des modifications ciblées. Ce n’est pas de la magie, c’est une orchestration d’outils très bien pensée.

Claude Code vs les autres en 30 secondes

J’ai écrit un comparatif détaillé Claude Code vs Cursor, mais le résumé est là.

• ChatGPT/Claude.ai : interface chat, pas d’accès à tes fichiers locaux. Tu copies-colles.
• GitHub Copilot : auto-complétion dans ton IDE. Ultra-rapide pour écrire ligne par ligne, peu autonome.
• Cursor : IDE (fork de VSCode) avec chat, Composer et edit inline. Plus autonome que Copilot.
• Claude Code : agent CLI autonome. Tu lui décris une tâche, il exécute plusieurs actions enchaînées sans intervention.

Si tu veux une métaphore : Copilot est un correcteur orthographique amélioré, Cursor un binôme de pair-programming qui regarde ton écran, Claude Code un stagiaire senior à qui tu délègues des tâches entières.

À qui c’est destiné

Honnêtement, tout développeur qui bosse régulièrement en terminal. Le prérequis cognitif, c’est de savoir ce qu’est un fichier, une branche git, un test. Si tu as ça, Claude Code est probablement l’outil le plus rentable à installer aujourd’hui.

Moins pertinent si tu fais du dev ultra-visuel (design-to-code, WordPress admin), si tu ne touches jamais au terminal, ou si tu as des contraintes strictes de confidentialité qui interdisent les APIs cloud.

Installation de Claude Code en 2026

On va à l’essentiel. Pour un guide installation extrêmement détaillé par OS (Mac, Windows, Linux avec WSL), je te renvoie à Comment installer Claude Code en 2026. Ici, la version rapide.

Prérequis

• Node.js ≥ 18, idéalement Node 22 LTS (Active LTS en 2026, Node 20 reste en Maintenance LTS, Node 18 est en fin de vie depuis avril 2025)
• Un compte Anthropic : abonnement Claude (Pro, Max ou Team Premium) ou clé API
• Un terminal moderne : iTerm, Alacritty, Windows Terminal, GNOME Terminal, tous marchent

Méthode recommandée : le native installer

Anthropic recommande désormais le native installer comme méthode primaire. Il télécharge un binaire signé, le place dans ton PATH, et gère les auto-updates en arrière-plan. Aucune dépendance Node.js requise.

# macOS, Linux (et WSL pour Windows) curl -fsSL https://claude.ai/install.sh | bash # Windows natif (PowerShell admin) irm https://claude.ai/install.ps1 | iex # Vérifier claude --version

Méthode alternative : npm

Si npm est plus naturel dans ton workflow, l’install npm reste fully supported par Anthropic. Le package npm pull en fait le même binaire natif qu’avec le script d’install.

# macOS, Linux, WSL npm install -g @anthropic-ai/claude-code # Vérifier claude --version

Si la commande claude n’est pas trouvée après l’install npm, c’est que ton PATH global npm n’est pas dans ton shell. Fix rapide :

echo 'export PATH="$(npm config get prefix)/bin:$PATH"' >> ~/.zshrc source ~/.zshrc

Ne lance jamais sudo npm install -g. Si tu as des erreurs de permission, configure plutôt nvm ou un dossier npm utilisateur (cf. docs.npmjs.com).

Premier lancement et authentification

Lance claude tout court. Au premier run :

1. Claude Code ouvre ton navigateur pour te connecter à Anthropic
2. Tu t’authentifies avec ton compte (Pro, Max ou Team)
3. Retour au terminal : tu es prêt

Alternative pour usage ponctuel ou compte sans abonnement, via clé API :

export ANTHROPIC_API_KEY=sk-ant-... claude

Premier test :

cd ~/un-projet-quelconque claude "liste les 3 fichiers les plus importants de ce projet et explique-moi ce qu'ils font"

Claude va naviguer ton repo, lire les fichiers qui semblent critiques (package.json, README, main), et te donner une synthèse. Si tu vois ça apparaître, l’install est OK.

Les commandes essentielles

Une session Claude Code est une conversation. Tu as aussi des slash commands spéciales pour contrôler le comportement de l’agent sans lui parler en langage naturel.

Les slash commands à connaître

Toutes ces commandes se tapent directement dans le prompt Claude, préfixées par / :

• /help, liste des commandes disponibles
• /clear, efface la conversation, repart à zéro (utile quand tu changes de tâche)
• /compact, résume la conversation pour libérer du contexte sans perdre la mémoire
• /context, affiche l’utilisation du contexte (utile pour décider quand /compacter)
• /model, change le modèle actif (Sonnet, Opus, Haiku ou auto)
• /cost, affiche ce que coûte la session en cours (tokens et dollars)
• /agents, liste et lance les subagents disponibles
• /mcp, info sur les serveurs MCP connectés
• /doctor, diagnostic d’install (utile en cas de pépin)
• /login et /logout, change d’identité Anthropic
• /exit, quitte la session (ou Ctrl+C deux fois)

Les quatre que tu vas utiliser le plus : /clear, /compact, /context, /model. La liste complète (60+ commandes) est documentée sur code.claude.com/docs/en/commands.

Les modes d’exécution

Par défaut, Claude te demande confirmation avant chaque action qui modifie des fichiers ou lance une commande. Tu peux ajuster :

• Mode par défaut : confirmation à chaque outil. Le plus safe pour débuter.
• Plan mode : Shift+Tab cycle entre les modes (default → acceptEdits → auto → plan), donc deux Shift+Tab depuis le défaut pour atterrir en plan mode. Claude élabore alors un plan d’exécution et te le présente avant de toucher à quoi que ce soit. Tu valides, puis il exécute. Indispensable pour les tâches complexes.
• --dangerously-skip-permissions : pas de confirmation, Claude fait ce qu’il veut. À n’utiliser que dans un sandbox ou un container, sinon tu risques de perdre du code.

Usage non-interactif (scripting)

Tu peux aussi lancer Claude en mode one-shot, idéal pour CI/CD ou scripts :

claude --print "résume les changements depuis le dernier commit" # -p est un alias pour --print # Continuer la dernière session claude --continue claude -c # raccourci

5 workflows concrets qui font gagner des heures

Assez de théorie. Voilà comment j’utilise Claude Code quotidiennement. La trame est volontairement variée : certains workflows sont des one-shots, d’autres sont des routines intégrées à un cycle de dev classique.

Workflow 1 : débugger une erreur en 3 prompts

Erreur en prod, tu as les logs. Au lieu d’ouvrir 4 onglets StackOverflow :

claude "J'ai cette erreur en prod : [coller le stack trace]. Trouve la cause et propose un fix."

Claude va chercher le fichier incriminé, lire la fonction, identifier la cause probable, et te proposer un patch. Tu valides, il applique. Sur les bugs typiques que j’ai mesurés (NullPointerException, parsing JSON, regex foireuse), on tombe à 2-3 minutes de résolution là où je passais 20-30 minutes seul.

Workflow 2 : refactor avec tests (TDD inversé)

Refactoriser une fonction legacy fait peur. La parade : générer d’abord les tests, puis seulement refactoriser.

claude "Refactorise la fonction processOrder() dans orders.ts pour extraire la logique de validation dans un fichier séparé. Écris d'abord les tests unitaires pour le comportement actuel, puis refactorise, puis vérifie que les tests passent toujours."

C’est du TDD guidé par IA. Claude lit la fonction, écrit les tests qui capturent le comportement actuel, les lance (ils passent, baseline OK), refactorise, relance les tests pour vérifier, et te donne le diff complet. Sur une fonction de 200 lignes, ça me prend 15 minutes au lieu de 2 heures.

Workflow 3 : ajouter une feature avec plan mode

Pour les features non-triviales, je passe en plan mode (deux Shift+Tab) :

Ajoute un endpoint /api/users/:id/export qui exporte toutes les données utilisateur en JSON, avec authentification JWT, rate limit 5/heure/user, et logs d'audit. Écris les tests d'intégration aussi.

Claude élabore un plan (quels fichiers créer, quelles dépendances, quelle structure), te le montre, tu valides, il implémente étape par étape. Tu peux interrompre à tout moment si ça dérive.

Workflow 4 : review de code avant commit

Avant de pousser une PR :

claude "Review les changements staged (git diff --cached). Identifie bugs potentiels, problèmes de perf, code smells, manque de tests. Sois critique mais constructif."

Claude joue le rôle du reviewer exigeant. Il repère souvent des edge cases que tu oublies (null check manquant, loop inefficace, secret hardcodé). C’est complémentaire à une review humaine, pas un remplacement.

Workflow 5 : migration de framework ou de version

React 18 vers 19, Vue 2 vers 3, Node 18 vers 22 : les migrations sont pénibles. Claude Code les rend quasi indolores.

claude "Migre ce projet de React 18 à React 19. Identifie les breaking changes qui nous impactent, applique les codemods officiels quand ça existe, corrige manuellement le reste, mets à jour les dépendances compatibles, lance les tests après chaque étape."

Sur un projet de taille moyenne, ce genre de migration me prenait une journée. Avec Claude Code, je redescends à 1-2 heures de supervision, plus le boulot mécanique.

Les fonctionnalités avancées qui changent tout

C’est ici que Claude Code se démarque vraiment des outils concurrents. Ces features prennent un peu de temps à maîtriser, mais leur effet compound est énorme.

CLAUDE.md : la mémoire persistante du projet

Le fichier CLAUDE.md à la racine de ton projet est chargé automatiquement dans le contexte à chaque lancement. C’est là que tu consignes tout ce que Claude doit savoir en permanence :

# Mon projet, conventions internes ## Stack - Next.js 15 App Router - Prisma + Postgres - Tailwind CSS + shadcn/ui - Vitest pour les tests ## Conventions - Imports absolus via alias `@/` - Composants React en PascalCase, fichiers matching - Jamais `any`, préférer `unknown` + narrowing - Pas de `console.log` en prod (lint rule active) ## Commandes utiles - `npm run dev`, dev server - `npm run test`, tests unit + integration - `npm run build && npm run start`, build prod local ## Architecture - `app/` = routes Next.js - `lib/` = logique métier, pas de dépendance React - `components/` = composants UI - `prisma/` = schema et migrations ## Règles pour toi, Claude - Écris toujours des tests pour les fonctions de `lib/` - Commits atomiques avec messages conventionnels - Pas de `TODO` laissé en commentaire, ouvre un ticket GitHub à la place

Plus ton CLAUDE.md est précis, moins tu as à répéter tes conventions à chaque prompt. Version-le avec git, partage-le dans l’équipe. La doc officielle recommande de le garder sous 200 lignes : au-delà, tu utilises trop de tokens à chaque session.

Les hooks : automatiser autour de Claude

Les hooks te permettent d’exécuter des scripts avant ou après certaines actions de Claude. Configuration dans ~/.claude/settings.json ou .claude/settings.json du projet :

{ "hooks": { "PostToolUse": [ { "matcher": "Edit|Write", "hooks": [ { "type": "command", "command": "npx eslint --fix $CLAUDE_FILE_PATH" } ] } ], "Stop": [ { "hooks": [ { "type": "command", "command": "osascript -e 'display notification \"Claude a fini\" with title \"Claude Code\"'" } ] } ] } }

Quelques recettes que j’utilise :

• Auto-format après chaque édition (Prettier ou Biome)
• Auto-lint, refus du commit si ESLint échoue
• Notification desktop quand une tâche longue finit (pour bosser en arrière-plan)
• Backup auto des fichiers avant modification (via cp dans un dossier temporaire)
• Logger toutes les commandes bash exécutées par Claude pour audit

Subagents : déléguer à des spécialistes

Les subagents sont des mini-agents spécialisés, avec leur propre contexte et leur propre outillage. Tu les définis dans .claude/agents/mon-agent.md :

--- name: code-reviewer description: Review du code avant commit. À utiliser proactivement avant tout push. tools: Bash, Read, Grep, Glob model: sonnet --- Tu es un reviewer senior. Pour chaque fichier modifié : 1. Identifie les bugs potentiels et edge cases non gérés 2. Repère les problèmes de perf (N+1 queries, boucles inutiles) 3. Vérifie que les tests existent et couvrent les cas critiques 4. Signale les secrets hardcodés ou les fuites de données Sois concis, priorise ce qui bloque vraiment.

Claude sait alors invoquer le subagent automatiquement quand approprié, ou tu peux le lancer explicitement avec /agents code-reviewer. Avantage majeur : chaque subagent a son propre contexte isolé, ce qui évite de polluer ta session principale. Jusqu’à 10 subagents peuvent tourner en parallèle.

MCP : connecter Claude à ta stack

Le Model Context Protocol (MCP) est un standard ouvert pour brancher des outils externes sur un LLM. En 2026, l’écosystème MCP est massif : tu peux connecter Claude à GitHub, Supabase, Stripe, ton CRM, ta base Postgres, Playwright, et des centaines d’autres services.

Configuration minimale dans .mcp.json à la racine du projet :

{ "mcpServers": { "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/toi/projects"] }, "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"], "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..." } } } }

Une fois connecté, Claude peut directement créer des issues GitHub, lire une table Supabase, lancer un test Playwright, sans que tu aies à écrire un seul appel API. J’ai détaillé l’écosystème MCP dans MCP Server : le guide ultime en français.

Claude Code en équipe : versionner et partager

L’erreur classique en équipe : chaque dev configure Claude Code différemment, et les résultats divergent. Trois règles pour éviter ça.

Règle 1 : commiter CLAUDE.md au repo

Le fichier CLAUDE.md est un artefact du projet, pas de ta config perso. Il décrit les conventions partagées. Commit-le. Chaque PR qui introduit une nouvelle convention doit aussi updater CLAUDE.md.

Règle 2 : config partagée dans .claude/

Le dossier .claude/ à la racine du repo peut contenir :

• .claude/settings.json, config partagée (hooks, modèles préférés)
• .claude/agents/, subagents disponibles à toute l’équipe
• .mcp.json, serveurs MCP requis

Commit ça aussi. Les secrets (tokens GitHub, clés API) vont dans .env locale, référencés par nom depuis la config.

Règle 3 : Claude Code en CI/CD

Tu peux faire appeler Claude dans un pipeline CI pour, par exemple, auto-review les PRs :

# .github/workflows/claude-review.yml (extrait) - name: Claude review env: ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }} run: | claude --print "Review les changements de cette PR et poste un commentaire structuré" > review.md gh pr comment ${{ github.event.pull_request.number }} --body-file review.md

Attention au coût côté API : limite ce hook aux PRs significatives (pas sur les changements de docs ou de lockfiles).

Les pièges courants et comment les éviter

Piège 1 : « Claude a cassé mon code »

Ça arrive. Trois préventions à mettre en place :

• Commit avant chaque session Claude substantielle (git stash si tu as des changements en cours)
• Plan mode pour les tâches qui dépassent 5 minutes : tu valides le plan avant exécution
• Hook PostToolUse pour lancer tes tests après chaque écriture critique

Piège 2 : la facture qui grimpe

Si tu es en pay-as-you-go via l’API (pas en abonnement), surveille ton usage. Quelques bonnes pratiques :

• /cost régulièrement pour voir où tu en es
• /compact quand la conversation devient longue, ça évite de payer pour un contexte devenu obsolète
• /clear au changement de tâche
• Modèle Haiku 4.5 (1 / 5 $ par MTok) pour les tâches simples, Opus 4.7 (5 / 25 $ par MTok) seulement quand tu as besoin de raisonnement complexe
• Prompt caching activé sur le système et CLAUDE.md : cache reads facturés à 10 % du tarif input, ça peut couper jusqu’à 90 % du coût des longs contextes (cf. platform.claude.com)

Avec un abonnement Pro (20 $/mois) ou Max (100 ou 200 $/mois selon le tier 5x ou 20x), tu as un quota mensuel généreux et la facture est prévisible.

Piège 3 : hallucinations

Claude peut inventer des APIs qui n’existent pas, surtout sur des libs récentes. Trois parades :

• Connecter un MCP qui a accès à la doc officielle (Context7 par exemple)
• Demander explicitement « vérifie dans la doc avant d’implémenter »
• Lancer les tests immédiatement après génération, les hallucinations échouent généralement vite

Piège 4 : dépendance cognitive

À force d’utiliser Claude Code, tu risques d’atrophier ta capacité à débugger à la main. Une fois par mois, force-toi à résoudre un problème sans aide, ça maintient tes réflexes bas niveau.

Une journée type avec Claude Code

Le meilleur moyen de comprendre la valeur, c’est de voir ce que ça donne dans un workflow réel. Voici à quoi ressemble une journée de dev depuis que j’ai intégré Claude Code à mon stack. Adapte à ton contexte.

Ouverture de la matinée : reprise de session

Je lance claude -c dans le terminal du projet sur lequel je bossais hier. La session précédente est restaurée, contexte préservé. Premier prompt :

Fais-moi un résumé de là où on en était hier, et propose les 3 priorités pour la matinée.

Claude me sort un récap structuré en 30 secondes. Plus besoin de scroller mes notes ou mon git log pour me remettre dans le bain.

Bug en cours de matinée : ticket nocturne

Un bug signalé par un utilisateur pendant la nuit. Le reporter a fourni une stack trace. Je colle le trace à Claude :

claude "Bug report client : [stack trace]. Trouve la racine, propose un fix avec test unit qui reproduit le bug, et prépare un commit atomique."

Claude explore le code, identifie un edge case non géré dans le parser d’URL, écrit un test qui reproduit le bug (rouge), applique le fix (vert), et prépare le commit avec un message conventionnel. Temps total : 8 minutes au lieu des 30 à 45 minutes habituelles en solo.

Session de build : nouvelle feature en plan mode

Une story à développer : export CSV des commandes. Je passe en plan mode (deux Shift+Tab) :

Ajoute un endpoint GET /api/orders/export.csv pour l'admin uniquement. Stream la réponse pour éviter OOM sur gros datasets. Authentification via middleware admin existant. Tests d'intégration couvrant : utilisateur non admin refusé, gros dataset OK, format CSV conforme.

Claude me propose un plan en 8 étapes. Je vois qu’il suggère d’ajouter une dépendance (csv-stringify) que j’évite, je l’informe qu’on utilise déjà une lib maison pour le CSV. Il ajuste le plan. Validation, exécution. 40 minutes plus tard, la feature est complète, testée, prête à review.

Après le déjeuner : session review

Je bascule sur mon subagent code-reviewer pour review la PR d’un collègue :

/agents code-reviewer Review la PR #432, sois strict sur les perf et la sécurité.

Mon subagent a son contexte isolé, pas pollué par le travail du matin. Il sort une liste de 12 points : 3 bugs potentiels, 2 questions de perf, 7 nits cosmétiques. Je passe les points un par un, j’en retiens 5 pour commentaires sur la PR, je jette les autres.

Bloc dette technique : migration de tests

Bloc de 2 heures bloqué pour migrer un module de Jest vers Vitest. Sans Claude Code, c’était une semaine. Avec plan mode et hooks de test auto :

Migre le module /lib/pricing de Jest à Vitest. Ne casse pas la config existante pour les autres modules. Vérifie que tous les tests passent après chaque fichier migré.

Je regarde d’un œil, je corrige ponctuellement, je prépare ma to-do du lendemain. 1h40 plus tard, migration complète, tests verts, je pousse une PR.

Fin de journée : debug d’incident

Une feature flag casse en prod, rollback fait, il faut comprendre. Je demande à Claude de m’aider à investiguer avec les logs :

claude "Voici les logs des 30 dernières minutes [paste]. Voici le code de la feature flag [paste]. Trouve le pattern de l'échec."

Claude identifie une race condition liée à un cache mal invalidé. Il propose un fix. Je valide, tests locaux verts, déploiement staging, puis prod. Incident fermé en 25 minutes au lieu des 2 heures redoutées.

Récapitulatif de fin de journée

Avant de fermer :

Résume ce qu'on a fait aujourd'hui, et liste ce qui reste en cours pour demain matin.

Claude me sort un mini-standup écrit, que je colle dans mon journal. Le lendemain je reprends avec claude -c et je repars sur cette base.

Bilan de la journée : 1 bug fixé, 1 feature livrée, 1 review PR, 1 migration, 1 incident prod résolu. Avant Claude Code, une bonne journée pour moi c’était 2 ou 3 items sur cette liste, le reste glissait à demain.

Claude Code vs les alternatives en 2026

Petit comparatif synthétique (analyse approfondie dans Claude Code vs Cursor) :

Ma recommandation personnelle : Claude Code et Copilot en parallèle. Copilot pour les micro-tâches (compléter une ligne), Claude Code pour les tâches substantielles (refactor, feature, debug).

Pour aller plus loin

Ce guide couvre les fondamentaux et les workflows clés. Pour approfondir chaque sujet :

• Comment installer Claude Code en 2026, guide d’installation détaillé par OS
• Claude Code vs Cursor : comparatif objectif, comparatif approfondi avec benchmarks
• MCP Server : le guide ultime en français, tout sur le protocole qui connecte Claude à ta stack
• Documentation officielle : docs.anthropic.com/claude-code
• Référence des commandes : code.claude.com/docs/en/commands
• Repository GitHub : github.com/anthropics/claude-code
• Tarifs officiels Anthropic : claude.com/pricing

Si tu veux recevoir les nouveaux guides directement en boîte mail, inscris-toi au Brief AI Coding FR depuis la page d’accueil. Un email par semaine, maximum, sans spam.

Des questions, des corrections, un workflow que tu veux partager ? Écris-nous à hello@tutosss.com.