Claude Code : apprendre, pratiquer et industrialiser vos workflows

Claude Code est l'agent CLI d'Anthropic pour coder en profondeur : il explore votre codebase, propose un plan, modifie les fichiers, lance vos tests, et vous présente chaque changement en diff que vous validez ou rejetez. Ce n'est ni de l'autocomplétion comme GitHub Copilot, ni un IDE-cocoon comme Cursor : c'est un assistant agentique qui vit dans votre terminal et que vous pilotez avec discipline. Ce hub vous emmène d'installation à industrialisation, avec un fil rouge unique, ~/Projets/lab-claude, et une méthode CLI-first assumée.

Ce que vous allez apprendre

Ce parcours compte 9 modules et 28 leçons, dont 5 labs à rejouer sur le dépôt fil rouge ~/Projets/lab-claude, soit environ 14 h 30 de travail. Il est gratuit et se lit sans inscription. Les sept compétences ci-dessous sont classées dans l'ordre où elles se pratiquent : les trois premières suffisent à travailler sérieusement, les quatre suivantes servent quand l'outil devient un composant d'équipe.

• Comprendre la logique CLI-first et pourquoi elle accélère l'apprentissage
• Distinguer les blocs de compétences : démarrer, produire, contrôler, industrialiser
• Utiliser le fil rouge lab-claude pour pratiquer sans changer de contexte
• Poser vos conventions et garde-fous dans CLAUDE.md dès que le projet a du sens
• Appliquer la boucle opérationnelle : cadrer, exécuter, valider, corriger
• Transposer la méthode CLI vers VS Code sans perdre la discipline
• Repérer les sujets avancés à explorer ensuite : rules, skills, hooks, MCP, subagents

Qu'est-ce que Claude Code ?

Claude Code est un agent de développement lancé en CLI par Anthropic. Il s'installe avec un installeur officiel, se lance via claude dans un dossier de projet, et démarre une session interactive qui peut lire vos fichiers, exécuter des commandes shell, modifier votre code, lancer vos tests et vous présenter chaque changement en diff pour validation.

Trois caractéristiques qui le distinguent

Ces trois points expliquent la plupart des surprises des premières sessions. Le premier justifie pourquoi l'agent semble « ne rien faire » pendant plusieurs secondes au démarrage d'une tâche : il lit d'abord. Le deuxième dit où chercher la documentation de référence quand un comportement diffère entre l'éditeur et le terminal. Le troisième conditionne directement votre facture, puisque le modèle choisi change le coût par million de tokens dans un rapport de 1 à 5.

• Agentique plutôt que complétion : il explore votre projet avant d'écrire la première ligne. C'est ce qui change tout face à l'autocomplétion classique.
• CLI-first par design : la version CLI est la référence, l'extension VS Code reprend les mêmes concepts. Pas l'inverse.
• Modèles Anthropic derrière l'agent : Claude Opus 4.8 pour la capacité maximale, Sonnet 5 pour l'équilibre coût/qualité, Haiku 4.5 pour les opérations rapides. L'option --model accepte soit un alias (opus, sonnet, fable), qui pointe toujours vers la dernière version de la famille, soit un identifiant complet du type claude-fable-5. Pour le détail (capacités, prix, cas d'usage par modèle et arbre de décision), voir le guide dédié Modèles Claude Code : Opus, Sonnet, Haiku, quand choisir quoi.

Ce n'est pas (ou plus exactement « pas seulement »)

• Pas une autocomplétion type GitHub Copilot, pas de suggestion inline pendant que vous tapez.
• Pas un chat assistant type ChatGPT, il agit sur votre filesystem, pas seulement dans une fenêtre.
• Pas un IDE type Cursor, il vit dans votre terminal et s'intègre à votre éditeur existant.

C'est cette nature agentique CLI qui demande la méthode décrite dans ce parcours : plan, diff, validation. Sans ces réflexes, Claude Code part en sucette comme n'importe quel agent IA mal cadré.

Nouveautés Claude Code (mi-2026)

• Le même agent partout : terminal (CLI), application desktop (Mac/Windows), web sur claude.ai/code et extensions VS Code / JetBrains. La méthode reste identique quel que soit le support.
• Mode rapide (/fast) : sur Opus 4.8, Claude Code répond plus vite sans rétrograder vers un modèle plus petit (c'est bien Opus, juste accéléré). Opus 4.7 le propose encore mais il est en cours de retrait ; Opus 4.6 ne l'a jamais eu.
• Modèles à jour : Opus 4.8 (capacité maximale), Sonnet 5 (équilibre coût/qualité), Haiku 4.5 (opérations rapides). Les alias opus, sonnet et fable suivent automatiquement la dernière version de chaque famille.

Comment installer Claude Code et lancer sa première session ?

Claude Code s'installe avec l'installeur officiel https://claude.ai/install.sh sur Linux et macOS, winget install Anthropic.ClaudeCode sur Windows, puis se lance en tapant claude dans le dossier du projet à traiter. Sur macOS, brew install --cask claude-code fait la même chose via Homebrew. Sur Windows en natif, Git for Windows doit être installé avant, contrainte qui disparaît sous WSL.

curl -fsSL https://claude.ai/install.sh -o claude-install.sh
less claude-install.sh
bash claude-install.sh
cd ~/Projets/lab-claude
claude

Le script est téléchargé, relu, puis exécuté : trois commandes au lieu d'un curl | bash qui exécuterait à l'aveugle un code que personne n'a regardé. Le cd compte autant que l'installation, parce que Claude Code lit le répertoire courant : le lancer depuis votre $HOME lui donne votre disque entier comme contexte, ce qui coûte cher en tokens et produit des réponses floues. La dernière ligne ouvre la session interactive, avec le choix du thème puis l'authentification OAuth au premier démarrage.

À partir de là, chaque tâche suit le même cycle en cinq temps : demande formulée en entier, plan proposé par l'agent et relu par vous, diff présenté fichier par fichier, validation de chaque modification, puis commit. Ce cycle est le seul point de contrôle entre ce que vous avez demandé et ce qui atterrit dans votre dépôt. Le détail par système d'exploitation, les commandes de diagnostic claude --version et claude doctor et le traitement de l'erreur claude: command not found sont dans Installer Claude Code CLI ; les garde-fous durables, dans Configurer CLAUDE.md.

Comment ce parcours est-il organisé ?

Le parcours enchaîne quatre blocs de compétences, du premier lancement à l'industrialisation, sur un seul dépôt d'entraînement, ~/Projets/lab-claude. Garder le même terrain d'un bout à l'autre évite de reconstruire un contexte à chaque leçon et rend les progrès mesurables : le dépôt sur lequel vous branchez des hooks au bloc « Contrôler » est celui que vous avez créé au bloc « Démarrer », enrichi.

1. Démarrer proprement Fondations

   • Installer la CLI
   • Créer le fil rouge
   • Vérifier l'environnement

2. Produire des changements fiables Pratique

   • Prompting de base
   • Workflow réel CLI
   • Validation systématique

3. Installer la gouvernance Contrôle

   • CLAUDE.md
   • Mode plan
   • Relecture diff et recadrage

4. Étendre vers l'IDE Industrialisation

   • Extension VS Code
   • @-mentions et contexte ciblé
   • Permissions et checkpoints

Quels sont les 8 leviers de configuration de Claude Code ?

Claude Code se pilote par huit leviers : le prompt ponctuel, le fichier CLAUDE.md, les rules .claude/rules/*.md, les skills, les hooks, les serveurs MCP, les subagents et l'auto memory. Ce tableau se lit du haut vers le bas comme une échelle d'engagement. Les deux premières lignes ne coûtent rien à mettre en place et suffisent à la majorité des usages ; les quatre suivantes demandent des fichiers versionnés et une convention d'équipe ; les deux dernières ne se justifient qu'une fois les précédentes en place. La colonne « Quand l'utiliser » est la plus importante : chaque levier ajouté consomme du contexte, donc de l'attention du modèle. Ajouter les huit d'un coup sur un projet qui débute dégrade les résultats au lieu de les améliorer.

Levier	Rôle	Quand l'utiliser
Prompt ponctuel	Demande immédiate sur une tâche	Besoin local et court
CLAUDE.md	Conventions persistantes du projet	Travailler en équipe avec cadre stable
.claude/rules/*.md	Règles ciblées par zone de code	API, tests, infra avec contraintes distinctes
skills/*/SKILL.md	Procédures réutilisables	Tâches répétitives et standardisées
Hooks	Automatisation déterministe	Vérifications obligatoires systématiques
MCP	Connexion à des outils externes	Issues, docs, données hors repo
Subagents	Délégation en contexte isolé	Audit, exploration, revue parallèle
Auto memory	Mémoire de session structurée	Capitaliser les apprentissages

Glissez pour voir

Par où commencer quand on découvre Claude Code ?

Commencez par installer la CLI, puis créez le dépôt fil rouge, et ne touchez à la gouvernance qu'après avoir mené une première tâche de bout en bout. Les trois onglets ci-dessous correspondent aux trois premiers blocs du parcours, dans l'ordre où ils se pratiquent. Démarrer installe l'outil et le terrain d'entraînement, Produire enseigne la boucle de travail sur une vraie tâche, Contrôler ajoute les garde-fous une fois que vous savez ce que vous voulez encadrer. Poser la gouvernance avant d'avoir produit quoi que ce soit est l'erreur d'ordre la plus fréquente : vous écrivez des règles pour des problèmes que vous n'avez pas encore rencontrés.

Démarrer

Installation CLI Installer Claude Code et vérifier l'environnement

Projet fil rouge lab-claude Créer le dépôt commun de pratique

Prise en main CLI Commandes, raccourcis et configuration de base

Produire

Prompting de base CLI Passer d'une demande vague à une demande testable

Workflow réel CLI Exécuter une tâche complète en mode contrôlé

Erreurs et recadrage Corriger rapidement les dérives de session

Contrôler

Configurer CLAUDE.md Poser des règles persistantes concrètes

Mode plan, diff et validations Sécuriser chaque exécution avant acceptation

Claude Code dans VS Code Appliquer la même méthode dans l'éditeur

Comment suivre sa progression et valider ses acquis ?

Chaque leçon porte une case à cocher, et votre progression reste enregistrée dans votre navigateur, sans compte ni inscription. Aucune donnée ne part sur un serveur, mais changer de machine ou vider le stockage local remet le compteur à zéro.

La page Mon parcours affiche le programme complet module par module, avec le pourcentage d'avancement et le temps restant estimé. En haut de chaque leçon, un bandeau rappelle où vous en êtes ; en bas, un bouton marque la leçon comme lue et enchaîne sur la suivante.

Pour mesurer ce qui est réellement acquis, le quiz Claude Code tire ses questions d'une banque de 150 items répartis en sept thèmes : fondamentaux, prise en main de la CLI, configuration, extensions (MCP, hooks, skills), workflows et validation, dépannage, modèles et coûts. Traitez-le après le module « Industrialiser » : avant, les questions sur les hooks et les subagents porteront sur des notions que vous n'aurez pas encore pratiquées.

Comment valider un changement produit par Claude Code ?

Toute modification acceptée se vérifie par deux commandes, uv run ruff check . puis uv run pytest -q, avant le commit. Sur le fil rouge lab-claude, ce rituel s'applique après chaque changement significatif, y compris ceux qui semblent triviaux.

uv run ruff check .
uv run pytest -q

Vérification : corrigez les erreurs de lint avant de relancer les tests, sinon vous lisez des échecs de test causés par un import mal placé. Cette discipline limite les régressions et raccourcit les sessions, parce qu'un agent qui reçoit une sortie de test en retour corrige seul ce qu'il a cassé, au lieu d'attendre que vous décriviez le symptôme.

Erreurs fréquentes

Ces quatre symptômes ont une racine commune, visible dans la colonne du milieu : quelque chose n'a pas été explicité. Ni le périmètre, ni le plan, ni la façon de vérifier, ni les règles du projet. C'est ce qui les rend faciles à corriger, mais aussi faciles à répéter, parce que chaque session repart de zéro et que rien n'oblige à poser ces éléments. La colonne « Correction » se lit donc comme une liste de réflexes à installer, pas comme un dépannage ponctuel.

Symptôme	Cause probable	Correction
Session trop longue et floue	Objectif mal borné	Réduire le périmètre à une amélioration unique
Changements difficiles à relire	Pas de plan ni diff cadré	Imposer plan court puis relecture diff
Résultat non fiable	Validation oubliée	Lancer uv run ruff check . puis uv run pytest -q
Règles non appliquées	Gouvernance implicite	Ajouter un CLAUDE.md minimal et concret

Glissez pour voir

---

Mon retour d'expérience, pourquoi CLI-first et pas autre chose

J'utilise des assistants IA pour coder depuis le premier accès grand public à GitHub Copilot en 2021. J'ai essayé Cursor sérieusement pendant 4 mois en 2024, Aider sur trois projets perso, Cody brièvement en équipe, et Claude Code depuis sa sortie publique. Mon constat après ces itérations : la qualité du résultat dépend moins du modèle que du cadre que vous imposez à l'outil.

Claude Code en mode CLI est celui qui m'a permis de poser le cadre le plus strictement, pour quatre raisons concrètes :

• Le terminal force la discipline. Pas de complétion qui tire votre attention pendant que vous tapez. Vous formulez votre demande en entier avant qu'il ne réponde. Cette friction est un atout, pas un défaut.
• Le CLAUDE.md est de la doc, pas du code. Vous l'éditez avec un éditeur normal, vous le commitez, vous le diffusez à l'équipe. Pas un système opaque baked-in dans un IDE propriétaire.
• Le triptyque plan → diff → validation est explicite. Vous voyez exactement ce qui va changer avant d'accepter. Pas de modification silencieuse dans l'arborescence pendant que vous regardez l'écran de chargement.
• Le mode headless permet d'industrialiser : pre-commit hook, GitHub Actions, scripts CI. C'est ce qui transforme l'outil de gadget personnel en composant d'équipe.

Je suis revenu au CLI après avoir testé Cursor non pas parce que Cursor est mauvais, il est très bon, mais parce que j'avais besoin de cette discipline et d'une transposabilité vers la CI que l'approche IDE-only ne donne pas.

Ce que ce parcours défend

J'assume cinq opinions qui structurent tout le contenu suivant :

1. Le plan vient avant le diff, toujours. Une session sans plan explicite produit du code qu'on relit deux fois plus longtemps. Trente secondes de cadrage économisent vingt minutes de relecture.
2. CLAUDE.md minimal et concret bat CLAUDE.md exhaustif et flou. Un fichier de 50 lignes ciblées qui dit « voici comment je teste, voici comment je commit, voici ce que je n'autorise pas » fait plus que 500 lignes d'opinions générales.
3. Sessions courtes plutôt que mégasessions. Une tâche = une session. Dès qu'on dépasse trois sujets dans la même conversation, la qualité s'effondre, pour Claude comme pour n'importe quel autre agent. Ce n'est pas un défaut du modèle, c'est une limite du contexte.
4. Validation automatisée plutôt que validation à la main. Tout ce que vous demandez à Claude doit pouvoir être validé par ruff, pytest, mypy, actionlint ou équivalent. Si vous ne pouvez pas l'automatiser, vous n'avez pas spécifié.
5. CLI avant IDE pour démarrer. L'extension VS Code est excellente, mais elle masque les concepts. Apprenez d'abord en CLI où vous voyez exactement ce qui se passe, puis transposez.

Ce que je vous interdis

Cinq anti-patterns que j'ai vus tuer la productivité dans les équipes :

• Lancer Claude sans plan. « Refactor cette classe » sur un fichier de 500 lignes = catastrophe garantie. Toujours demander un plan avant l'exécution, et le relire.
• Accepter un diff sans le relire ligne par ligne. L'IA est rapide, vous ne devez pas l'être. Cinq minutes de relecture évitent une régression silencieuse en production.
• Empiler les règles dans CLAUDE.md parce que « ça pourrait servir ». Une règle ajoutée = un signal cognitif de plus pour Claude. Les bons CLAUDE.md sont maigres et opérationnels, pas des bibles.
• Mélanger trois objectifs dans la même session. « Corrige ce bug + ajoute des tests + refactor cette autre fonction » → vous obtenez trois résultats moyens au lieu d'un bon. Sortez et recommencez.
• Croire que l'IA remplace les tests. Aucun agent, pas même Opus 4.8, ne peut garantir qu'une modification ne casse rien sans tests qui couvrent le comportement. Pas de tests = pas de filet, peu importe la qualité du diff.

Claude Code vs alternatives, positionnement honnête

Aucun de ces outils n'est mauvais. Ils ont des angles différents qui correspondent à des contextes différents.

Outil	Forces réelles	Limites réelles	Quand le choisir
Claude Code	Agentique CLI, cycle plan/diff/validate explicite, mode headless industrialisable, CLAUDE.md versionnable	Pas d'autocomplétion inline, courbe d'apprentissage si vous venez de Copilot pur	Vous voulez de la discipline et transposer en CI
Cursor	UX intégrée polissée, multi-modèles (Claude, GPT, Gemini), bonne intégration Composer	IDE-only (cocoon), abonnement par utilisateur qui grimpe vite, dépendance à un fork de VS Code	Vous voulez tout-en-un dans un IDE et vous acceptez le lock-in
GitHub Copilot	Autocomplétion mature, intégration native VS Code/JetBrains, Copilot Chat correct	Mode agentique encore en retrait (sauf Workspace en preview), pas de cycle plan/diff structuré, modèle moins capable que Claude Opus en raisonnement	Vous voulez accélérer la frappe sans changer vos workflows
Aider	Open source, support multi-modèles (OpenAI, Anthropic, Ollama local), commit Git automatique	UX terminal brute, courbe d'apprentissage, moins fluide que Claude Code pour les non-bash users	Vous voulez du CLI agentique open source et la portabilité multi-fournisseurs
Cody (Sourcegraph)	Indexation code-search avancée, bon sur les très gros monorepos	Moins agentique que Claude Code, focus historique sur le search assistance	Vous travaillez sur des monorepos massifs avec recherche cross-repo

Glissez pour voir

Mon choix personnel, assumé, est Claude Code en CLI plus un peu de Copilot pour l'autocomplétion ponctuelle quand je tape vite. Les deux outils ne se font pas concurrence : l'un cadre des sessions, l'autre accélère la frappe.

Sujets avancés à explorer ensuite

La phase intermédiaire/avancée prolonge la série débutant. Les guides suivants sont publiés et s'enchaînent dans cet ordre :

Sujet	Valeur ajoutée	Guide
settings.json avancé	Permissions, env et attribution au niveau projet	Lire
Rules ciblées (.claude/rules/*.md)	Règles locales par zone (API, tests, infra)	Lire
Skills (.claude/skills/<nom>/SKILL.md)	Procédures réutilisables invocables par /nom	Lire
Hooks	Automatiser ruff + pytest et bloquer les commandes destructives	Lire
Workflows concrets	Enchaîner les briques sur debug, refactor, test, doc, PR	Lire
Briques Claude Code : quand utiliser quoi	Orientation entre CLAUDE.md, rules, settings, hooks, skills	Lire
Dépannage avancé	Diagnostiquer permissions, config, diff et sessions qui dérivent	Lire
Serveurs MCP	Étendre Claude vers des ressources hors du dépôt (fetch, GitHub, bases)	Lire
Subagents	Isoler le contexte, déléguer exploration, revue ou audit à un agent spécialisé	Lire
Mode headless et CI	Piloter Claude en non-interactif : scripts locaux, pré-commit, GitHub Actions	Lire

Glissez pour voir

La série couvre à présent l'ensemble du parcours CLI. Pour construire un agent hors session, explorez l'Agent SDK d'Anthropic (voir le guide subagents).

Questions fréquentes

Ces réponses couvrent les points sur lesquels les lecteurs reviennent le plus après une première semaine d'usage : quels modèles sont réellement mobilisés, ce que coûte une session, le fonctionnement hors-ligne, le positionnement face à ChatGPT, Cursor et GitHub Copilot, et l'usage en équipe. Elles sont volontairement courtes, chaque sujet ayant son guide dédié dans le parcours.

Qu'est-ce que Claude Code exactement ?

Claude Code est un agent de développement en ligne de commande d'Anthropic. Installé via npm, il modifie les fichiers d'un projet et montre chaque diff pour validation. Ce n'est ni une autocomplétion ni un chat, mais un agent qui agit sur le système de fichiers.

Quels modèles Claude Code utilise-t-il ?

Claude Code s'appuie sur les familles de modèles Anthropic : Opus 4.8 pour la capacité maximale, Sonnet 5 pour l'équilibre coût/qualité, et Haiku 4.5 pour la vitesse et le faible coût. On change de modèle avec la commande /model, ou avec l'option --model qui accepte un alias comme opus ou sonnet.

Combien coûte Claude Code ?

Claude Code est gratuit à installer ; la facturation se fait à l'usage via un compte Anthropic (Claude Pro/Max ou API). Comptez quelques dollars par mois pour un usage personnel régulier. Le choix du modèle et le volume de tokens sont les principaux leviers de coût.

Claude Code fonctionne-t-il hors-ligne ?

Non, Claude Code dépend de l'API Anthropic et nécessite une connexion réseau. Le code reste local mais le raisonnement passe par le service. Pour une alternative locale, on peut regarder Aider avec Ollama, avec une qualité de modèle moindre.

Quelle différence avec ChatGPT ou Cursor ?

ChatGPT reste dans un navigateur sans toucher au code ; Cursor est un IDE complet fork de VS Code ; Claude Code est un agent en ligne de commande qui s'intègre au terminal et à l'éditeur existants, sans changer de stack.

Faut-il connaître Bash pour utiliser Claude Code ?

Un niveau Bash basique suffit pour démarrer (cd, ls, git). Pour les usages avancés comme les hooks, le mode headless ou la CI, un peu plus de maîtrise du shell aide.

Claude Code remplace-t-il GitHub Copilot ?

Pas nécessairement : Copilot accélère l'autocomplétion ligne par ligne, tandis que Claude Code est un agent qui structure des sessions complètes (plan, édition multi-fichiers, exécution de commandes). Les deux sont complémentaires et souvent combinés.

Comment utiliser Claude Code en équipe sans dérives ?

En équipe, un CLAUDE.md partagé à la racine pose les règles communes, les hooks imposent les vérifications obligatoires (lint, tests), et le mode headless permet l'industrialisation en CI. Les rules ciblées par dossier complètent la gouvernance.

Comment installer Claude Code ?

Installez la CLI en une commande npm : npm install -g @anthropic-ai/claude-code, puis lancez claude dans un dossier de projet pour ouvrir la première session. Prérequis : Node.js et un compte Anthropic (Claude Pro/Max ou une clé API).

Claude Code vs Aider : quelle différence ?

Aider est un agent CLI open source multi-fournisseurs (OpenAI, Anthropic, Ollama local), au commit Git automatique. Claude Code est édité par Anthropic et lié aux modèles Claude, avec un cycle plan/diff/validation explicite et un mode headless pour la CI.

À retenir

• Claude Code est un agent CLI, pas une autocomplétion. Cette nature change tout : il explore, planifie, modifie, valide, vous pilotez.
• Le cadre explicite (plan → diff → validation) est ce qui fait passer l'outil de gadget à composant fiable.
• Le parcours CLI-first accélère l'apprentissage et réduit la confusion. La transposition VS Code vient ensuite.
• Le fil rouge lab-claude évite la dispersion en gardant un seul terrain de pratique.
• Le CLAUDE.md minimal et opérationnel bat le CLAUDE.md exhaustif. Maigre et concret > gros et flou.
• Sessions courtes plutôt que mégasessions. Une tâche = une session.
• Mon choix personnel assumé : Claude Code en CLI pour le cadrage + Copilot pour l'accélération. Les deux outils se complètent au lieu de se concurrencer.

Pour aller plus loin

• Installer Claude Code CLI : L'installation sur Linux, macOS et Windows, avec les vérifications qui évitent les surprises au premier lancement.
• Créer le projet fil rouge lab-claude : Le dépôt d'entraînement commun à tout le parcours, prêt à recevoir vos premières sessions.
• Configurer CLAUDE.md : Les garde-fous persistants qui évitent de répéter les mêmes consignes à chaque session.
• Quelle brique utiliser quand ? : L'arbre de décision entre CLAUDE.md, rules, settings, hooks et skills, pour ranger chaque règle au bon endroit.

×

📖 Voir la documentation →