Maîtriser Claude Code Partie 1 : Premiers pas

Imagine le truc : tu fixes un énorme codebase legacy, des centaines de fichiers, et quelqu'un te demande de "juste ajouter une petite feature". Tu pourrais passer des heures à tracer les imports, comprendre les patterns, et deviner comment tout se connecte. Ou tu pourrais taper claude dans ton terminal et lui demander d'expliquer l'architecture en français courant.

C'est la promesse de Claude Code — un pair programmer IA qui ne fait pas que de l'autocomplétion, mais qui comprend vraiment l'ensemble de ton projet et peut exécuter des tâches de manière autonome. On va te mettre en route.

L'Écart de Productivité Est Réel

Voilà un truc que personne ne veut dire à voix haute : si tu n'utilises pas des outils comme Claude Code, tu es déjà en retard.

Les devs qui ont pigé ça tournent à 10-100x la productivité de ceux qui n'ont pas encore compris. C'est pas du hype. C'est ce qui se passe quand tu peux livrer des features entières en une heure au lieu d'une journée, quand tu refactores une architecture en minutes au lieu de semaines, quand tu débogues des problèmes complexes en laissant une IA lire des milliers de fichiers en quelques secondes.

Pendant que certains devs tracent manuellement dans les codebases, d'autres ont déjà fini et sont passés à la tâche suivante. Pendant que certains lisent la doc, d'autres ont déjà livré. Pendant que certains déboguent ligne par ligne, d'autres ont résolu et sont passés à autre chose.

Ce guide, c'est tout ce que j'ai appris en un an d'utilisation quotidienne de Claude Code. Chaque hack qui m'a fait gagner des heures. Chaque workflow qui a multiplié ma production. Chaque changement de mentalité qui a fait la différence entre frustration et flow.

Si tu es dev solo, ça va changer ta carrière. Si tu diriges une équipe, ça va changer toute ton organisation. L'écart se creuse vite. Assure-toi d'être du bon côté.

C'est Quoi Exactement Claude Code ?

Claude Code est l'assistant de coding agentique d'Anthropic qui vit dans ton terminal. Contrairement aux outils traditionnels de complétion de code qui suggèrent les prochains caractères, Claude Code peut :

• Naviguer dans tout ton codebase — Il lit, comprend et fait les connexions entre des centaines de fichiers
• Exécuter des tâches multi-étapes — "Refactore ce module en TypeScript" c'est pas juste une suggestion ; Claude le fait vraiment
• Gérer les workflows git — Commits, branches, descriptions de PR — tout en langage naturel
• Tourner partout — Terminal, VS Code, JetBrains, ou même directement sur GitHub via les mentions @claude

Vois-le moins comme un autocomplete et plus comme un dev junior super motivé qui tape 1000x plus vite que toi, peut lire tout ton codebase en quelques secondes, et a une patience infinie pour expliquer les choses.

Le hic : les LLMs foncent tête baissée sans aucun garde-fou si tu les laisses faire. Les devs qui tirent le meilleur parti de Claude Code ne sont pas juste bons en prompting — ils sont bons pour mettre en place une structure qui canalise toute cette vitesse vers quelque chose d'utile plutôt que de chaotique.

Avant d'Installer

Tu vas avoir besoin d'un de ces deux trucs :

Option A : Abonnement Claude Pro ou Max

Si tu paies déjà Claude Pro (20$/mois) ou Max (100$/mois), c'est bon. L'utilisation de Claude Code est incluse, et tu t'authentifies simplement en te connectant à ton compte Claude.

Option B : Clé API Anthropic

Tu préfères le pay-as-you-go ? Crée un compte sur console.anthropic.com, ajoute un moyen de paiement, et génère une clé API. Tu paies uniquement ce que tu utilises.

Astuce pro : Si tu as à la fois une clé API définie comme variable d'environnement ET un abonnement Claude, la clé API a la priorité — ce qui veut dire que tu seras facturé au token au lieu d'utiliser ton abonnement. Lance /status dans Claude Code pour vérifier quelle méthode d'authentification est active.

Prérequis système :

• Node.js 18 ou supérieur (vérifie avec node --version)
• macOS, Linux ou Windows

Installation

La méthode d'installation via npm est dépréciée. Voici les moyens officiels d'installer Claude Code :

macOS ou Linux (Recommandé) :

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

Homebrew (macOS/Linux) :

Brew install --cask claude-code

Windows (PowerShell) :

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

Windows (WinGet) :

Winget install Anthropic.ClaudeCode

Après l'installation, Claude Code se met à jour automatiquement en arrière-plan. Les utilisateurs Homebrew et WinGet doivent mettre à jour manuellement avec brew upgrade claude-code ou winget upgrade Anthropic.ClaudeCode.

Premier Lancement

Navigue vers n'importe quel répertoire de projet et lance :

Claude

Ce qui se passe ensuite dépend de ta config :

1. Le navigateur s'ouvre pour l'authentification
2. Connecte-toi avec ton compte Claude ou tes identifiants Anthropic console
3. Autorise Claude Code à accéder à ton compte
4. Un "workspace Claude Code" dédié est créé automatiquement pour le suivi d'utilisation

C'est tout. T'es dedans.

La Première Chose à Faire

Lance cette commande immédiatement :

/terminal-setup

Ça installe les raccourcis terminal qui te permettent d'utiliser Shift + Enter pour le multi-ligne. Sans ça, tu es coincé à tout taper sur une seule ligne — et ça devient vite pénible quand tu écris des prompts détaillés.

Pourquoi c'est important : Imagine essayer d'expliquer un bug complexe en une ligne versus pouvoir structurer tes idées sur plusieurs paragraphes. Le multi-ligne transforme la façon dont tu communiques efficacement avec Claude.

Deux Façons de Travailler

Mode Interactif (Ton Outil du Quotidien)

Claude

Ouvre une session REPL où tu as une conversation de va-et-vient. Claude maintient le contexte tout du long, se souvient de ce dont vous avez discuté, et peut gérer des tâches complexes multi-étapes.

Utilise ça pour :

• Construire de nouvelles features
• Déboguer des problèmes coriaces
• Revues de code et refactoring
• Explorer des codebases inconnus

Mode Plan (Réfléchir Avant d'Agir)

Appuie sur Shift+Tab deux fois avant d'envoyer ton message pour entrer en Mode Plan. Dans cet état lecture seule, Claude peut explorer ton codebase, rechercher des approches et proposer des solutions — mais ne peut modifier aucun fichier.

Utilise ça pour :

• Les décisions d'architecture avant l'implémentation
• Comprendre du code inconnu
• Évaluer différentes approches d'un problème
• Les refactorings complexes où tu veux d'abord voir le plan

Le Mode Plan est couvert en détail dans la Partie 2 : Le Modèle Mental.

Mode One-Shot (Questions Rapides)

Claude -p "ta question ici"

Lance une seule commande et quitte. Pas de session interactive, juste question → réponse → terminé.

Utilise ça pour :

• Recherches rapides : claude -p "que fait le middleware auth ?"
• Scripts automatisés : claude -p "liste tous les commentaires TODO" >> todos.txt
• Pipelines CI/CD : claude -p "génère le changelog des commits récents"

Commandes Essentielles

Une fois dans une session interactive, ces commandes slash contrôlent le comportement de Claude :

/help — Affiche toutes les commandes disponibles y compris les personnalisées. Utilise quand tu oublies une commande ou veux en découvrir de nouvelles.

/clear — Efface l'historique de conversation. Utilise souvent ! Repars de zéro entre des tâches sans rapport pour économiser des tokens.

/compact — Compresse le contexte de conversation. Utilise quand le contexte devient long mais que tu veux garder un peu d'historique.

/model — Bascule entre Opus, Sonnet ou Haiku. Opus pour le raisonnement complexe, Haiku pour les tâches rapides, Sonnet pour l'équilibre.

/config — Ouvre la configuration des paramètres. Utilise pour ajuster les permissions, défauts et préférences.

/status — Affiche le statut actuel et la méthode d'auth. Utilise pour vérifier quel compte/clé API est utilisé.

/cost — Affiche la consommation de tokens. Garde un œil sur la conso.

/context — Affiche le contenu actuel du contexte de Claude. T'aide à comprendre ce que Claude "sait" en ce moment.

/vim — Active l'édition style vim. Si t'es un utilisateur vim, tu vas te sentir chez toi.

/init — Initialise ou met à jour CLAUDE.md. Lance après des features importantes ou des refactors pour garder le contexte projet à jour.

Commandes de Gestion de Session

/terminal-setup — Installe le raccourci Shift+Enter pour le multi-ligne.

/allowed-tools — Configure quels outils Claude peut utiliser (accès fichiers, bash, etc.).

/hooks — Configure des hooks d'automatisation pour certains événements.

/mcp — Gère les serveurs Model Context Protocol.

/agents — Crée et gère des sous-agents pour les tâches parallèles.

/install-github-app — Configure l'intégration GitHub Actions pour les mentions @claude.

Gestion de Session depuis le Terminal

Parfois tu as besoin de reprendre là où tu t'étais arrêté :

# Continue ta dernière session exactement où tu t'étais arrêté
Claude -c

# Parcours et sélectionne parmi les sessions récentes
Claude -r

Le flag -r est particulièrement utile quand tu réalises "attends, je bossais sur ce bug auth il y a deux jours et Claude avait trouvé un truc". Tu peux retomber pile dans cette conversation.

Ta Première Vraie Tâche

Voilà un bon moyen de tester ta config. Navigue vers n'importe quel projet et lance :

Claude

Puis tape :

Explique l'architecture de ce projet. Quels sont les composants principaux
et comment ils se connectent ? Où est-ce que je devrais regarder si je veux
ajouter un nouveau endpoint API ?

Claude va scanner ton codebase, identifier les patterns, et te donner un aperçu structuré. C'est sincèrement l'un des meilleurs moyens de découvrir un projet inconnu — que ce soit un nouveau job, une contribution open-source, ou ton propre code d'il y a six mois.

Le Système de Permissions

Claude ne modifie pas silencieusement tes fichiers. Avant de faire des changements, tu verras des prompts comme :

Claude wants to edit src/auth.ts
Allow? [y]es / [n]o / [a]lways allow for this file

Tes options :

• y — Autorise cette action spécifique
• n — Bloque-la
• a — Toujours autoriser ce type d'action (plus de prompts pour des opérations similaires)

Ma recommandation : Commence avec y pour tout jusqu'à ce que tu comprennes les patterns de comportement de Claude. Une fois que tu lui fais confiance pour certaines opérations (comme éditer des fichiers de test), passe à a pour accélérer ton workflow.

Permissions avancées : Pour un contrôle fin avec des listes allow/deny, des hooks automatisés et des politiques de permissions à l'échelle de l'équipe, voir la Configuration des Paramètres dans la Partie 3.

Intégration IDE

Claude Code fonctionne nativement avec plusieurs IDEs :

VS Code — Cherche "Claude Code" dans les Extensions (Cmd/Ctrl+Shift+X). Intégration complète avec diffs inline et conversations multi-onglets.

Cursor — L'installation manuelle du VSIX peut être nécessaire. Basé sur VS Code, fonctionne très bien une fois installé.

Windsurf — Config similaire à Cursor. Fork de VS Code qui supporte les extensions VSIX.

JetBrains — Plugin disponible. Fonctionne avec IntelliJ, WebStorm, PyCharm et les autres IDEs JetBrains.

Important : L'extension VS Code n'est pas un remplacement du CLI — c'est un lanceur qui fournit une interface plus agréable. Le vrai Claude Code tourne toujours avec le même moteur sous le capot. Tu peux avoir plusieurs instances en parallèle sur différentes parties de ton codebase.

Le Changement de Mentalité : La Structure Crée la Vitesse

Voilà ce qui sépare les devs qui adorent Claude Code de ceux qui le trouvent frustrant : ceux qui réussissent le traitent comme une collaboration avec un dev junior très capable mais très enthousiaste.

Ce dev junior tape incroyablement vite, ne se fatigue jamais, et peut absorber tout ton codebase en quelques secondes. Mais il va aussi foncer tête baissée sans garde-fous si tu le laisses faire. Les pratiques qui font que le coding assisté par IA marche ne sont pas nouvelles — ce sont les mêmes choses que les devs expérimentés font depuis des années. Elles deviennent juste critiques maintenant.

Git Est Ton Filet de Sécurité

Commite fréquemment, en petits morceaux. Si Claude part en vrille, tu peux juste faire git checkout . ou revenir à un état connu. Pense aux commits comme des points de sauvegarde dans un jeu vidéo.

Ça a l'air basique, mais ça change tout. Quand tu sais que tu peux toujours revenir en arrière, tu es libre de laisser Claude expérimenter. Quand t'es pas sûr, tu hésites, tu microgères, et tu perds la majeure partie de l'avantage vitesse.

Si t'es rouillé sur Git, les docs officielles GitHub sont vraiment excellentes pour démarrer.

Planifie Avant de Prompter

Écris ce que tu construis avant de commencer à prompter. Un simple doc markdown avec tes objectifs, décisions d'architecture et contraintes fait des merveilles. Garde-le dans ton repo pour que Claude puisse s'y référer.

Et sérieusement — utilise le Mode Plan. C'est littéralement dans le nom. Quand tu demandes à Claude de planifier quelque chose, il te pose des questions de clarification, puis propose un plan et te donne l'option de l'accepter. Si tu n'es pas satisfait pour n'importe quelle raison, dis non et dis à Claude ce que tu voudrais changer. Itère autant que nécessaire.

Ça te force toi à réfléchir, et donne au LLM un contexte crucial. Shift+Tab deux fois, puis "design un formulaire de login" c'est infiniment mieux que "construis-moi un formulaire de login".

Découpe les Grosses Tâches en Issues

Au lieu de "hey Claude, construis-moi un système d'authentification utilisateur", découpe en morceaux distincts : "Crée le modèle User", "Ajoute la gestion de sessions", "Construis le formulaire de login". Un PR par issue.

Crée des templates d'issues GitHub (demande de feature, rapport de bug — ces deux-là couvrent 90% des cas) et enregistre-les dans le contrôle de source. GitHub les utilise automatiquement quand quelqu'un crée une issue via l'UI.

Une fois que tu as un plan solide et que tu le comprends, demande à Claude de créer une issue GitHub avec ton template. Ou si t'as un gros plan, demande à Claude de le découper en morceaux plus petits et gérables, puis transforme les parties qui te conviennent en issues.

Tests d'Abord (Oui, Vraiment)

Demande à Claude d'écrire les tests avant l'implémentation. Ça a l'air contre-intuitif, mais ça force le LLM à réfléchir clairement à ce que "terminé" veut dire — et ça te donne un filet de sécurité. Si les tests ne passent pas, y'a un souci avec l'implémentation.

C'est ce qu'on appelle le TDD (test-driven development), ou "passer du rouge au vert" basé sur les couleurs typiques du CLI pour les tests qui échouent vs. ceux qui passent. C'est pas juste une bonne pratique — c'est comme ça que tu gardes Claude honnête.

Les Linters Rattrapent les Choix "Créatifs"

ESLint, Prettier, Rubocop, markdownlint, yamllint — peu importe ce qui correspond à ta stack. Configure-les avec des hooks pre-commit Git. Ça attrape pas mal des choix stylistiques que les LLMs font et qui ne correspondent pas à ton codebase.

Exemple : Claude adore sauter la ligne vide entre un titre et une liste à puces dans les fichiers markdown. Aucune idée pourquoi. Mais la pratique standard c'est de l'inclure. Alors tu installes markdownlint, tu définis tes préférences de règles dans un fichier de config, tu le lances sur tous les fichiers markdown que Claude touche, et problème résolu.

CLAUDE.md : Le Manuel d'Instructions de Ton Projet

Crée un fichier CLAUDE.md à la racine de ton projet avec tes standards de code, tes préférences et le contexte du projet. Claude le lit automatiquement au début de chaque session.

Ne le fais pas trop gros par contre. Les LLMs ont une mémoire à court terme étonnamment mauvaise comparée aux trucs random qu'ils semblent sortir de nulle part sur des événements d'il y a 300 ans (merci les données d'entraînement). Garde-le focalisé sur tes préférences et les détails clés du projet.

Lance /init après toute implémentation de feature importante ou refactor pour garder CLAUDE.md à jour. Claude te dira s'il y a quelque chose à ajouter ou mettre à jour, ou dira juste "ça a l'air bon, aucun changement nécessaire".

Erreurs Courantes de Débutant (Et Comment les Éviter)

1. Sauter /terminal-setup

Tu vas te demander pourquoi tes prompts détaillés sont à l'étroit. Lance-le, c'est tout.

2. Ne jamais utiliser /clear

Chaque message que tu envoies inclut tout le contexte précédent. Après avoir fini une tâche, fais table rase. Ta facture de tokens te remerciera.

3. Être trop vague

"Corrige le bug" vs "Corrige l'exception null pointer dans auth.ts à la ligne 42 où user.id est accédé avant le null check" — l'un des deux te donne de meilleurs résultats.

4. Demander à Claude de changer du code qu'il n'a pas lu

Laisse toujours Claude analyser d'abord. "Lis le module auth et explique comment les sessions fonctionnent" avant "réécris la gestion des sessions".

5. Balancer des tâches massives en un seul prompt

"Réécris toute l'application en TypeScript" c'est écrasant. Découpe : "Convertis le module user en TypeScript, puis on fera auth ensuite".

6. Ne pas vérifier /status

Si tu te demandes pourquoi tu es facturé alors que tu as un abonnement, vérifie quelle méthode d'authentification est active.

7. Sauter le Mode Plan

"Construis-le direct" semble plus rapide. Ça l'est pas. Shift+Tab deux fois et prends cinq minutes pour planifier — ça économise des heures à défaire du travail parti dans la mauvaise direction.

8. Pas de filet de sécurité

Si tu ne commites pas fréquemment, tu es à une mauvaise génération d'un après-midi frustrant. Commite avant les gros changements. Commite après les changements réussis. Les commits sont gratuits.

La Suite

Tu as maintenant Claude Code installé et tu comprends non seulement les commandes, mais la mentalité qui fait que le coding assisté par IA fonctionne. La structure et les garde-fous ne sont pas des contraintes — c'est ce qui rend la vitesse vraiment utile au lieu de chaotique.

Dans la Partie 2 : Le Modèle Mental, on va plonger dans la façon dont Claude Code "pense" vraiment — comprendre les fenêtres de contexte, l'utilisation des outils, et comment structurer tes prompts pour obtenir des résultats systématiquement meilleurs. Cette connaissance transforme Claude d'un assistant parfois utile en un partenaire d'ingénierie fiable.