Claude Code : les bases

Ce qu'est Claude Code et la boucle agentique

Claude Code est l'agent code d'Anthropic. Il vit dans votre terminal (également dans l'IDE et sur le web) et, contrairement au chat, il dispose d'outils : lire et écrire des fichiers, exécuter des commandes shell, rechercher dans le code, faire du git, interroger le web.

Son fonctionnement est une boucle agentique :

1. Vous donnez un objectif.
2. Il réfléchit, choisit un outil, l'appelle (lire un fichier, lancer un test...).
3. Il observe le résultat de l'outil.
4. Il recommence jusqu'à atteindre l'objectif, puis vous répond.

C'est la différence fondamentale avec le chat : Claude Code agit, observe, corrige de façon autonome. Vous ne dictez pas chaque commande, vous lui donnez un objectif et des garde-fous.

Installation : npm install -g @anthropic-ai/claude-code puis claude dans le dossier de votre projet. La première chose qu'il lit est votre CLAUDE.md (leçon suivante).

CLAUDE.md : la mémoire du projet

CLAUDE.md est un fichier markdown placé à la racine de votre projet (ou globalement dans ~/.claude/) que Claude Code lit automatiquement au démarrage. C'est sa mémoire persistante de vos conventions.

Ce qu'on y met :

• Les commandes du projet (build, test, lint, deploy).
• Les conventions de code et de style.
• Les règles absolues à ne jamais enfreindre.
• Le routage vers d'autres docs ou sous-projets.

Le CLAUDE.md de Pierre est un cas d'école : il encode ses règles non négociables (jamais de tiret cadratin, pas d'emoji, archiver plutôt que supprimer, le chemin exact est 00_SEPT TOOLS avec un underscore) et son routage de démarrage de session. Ces instructions prennent le dessus sur le comportement par défaut du modèle.

Générez un premier jet avec la commande /init : Claude analyse le dépôt et propose un CLAUDE.md. Vous l'affinez ensuite. Règle fondamentale : un CLAUDE.md court et précis vaut mieux qu'un document fleuve que personne ne respecte.

Les commandes slash essentielles

Les commandes slash pilotent la session. Les essentielles :

• /init : génère le CLAUDE.md en analysant le dépôt.
• /clear : réinitialise le contexte à zéro. A utiliser entre des tâches sans rapport, pour repartir sur une base propre.
• /compact : résume l'ancien contexte sans tout effacer. A utiliser en cours de tâche quand le contexte est plein mais que vous voulez garder la continuité.
• /agents : gérez les sous-agents spécialisés.
• /mcp : connectez et gérez les serveurs MCP.
• /hooks : configurez les hooks de cycle de vie.
• /review : revue de code du diff courant.

La distinction quotidienne la plus utile : /clear oublie tout, /compact résume. Trop de personnes laissent le contexte gonfler jusqu'à ce que la qualité se dégrade. Le réflexe du pro : /clear quand vous changez de sujet, /compact en plein milieu d'une grosse tâche.

Vous pouvez aussi créer vos propres commandes slash (modèles de prompts réutilisables) dans .claude/commands/. C'est la porte d'entrée vers les skills (module 5).

Permissions et plan mode

Claude Code peut exécuter de vraies commandes. Le système de permissions contrôle ce qu'il fait sans vous demander. Quatre modes principaux :

• Ask every time (défaut prudent) : il demande avant chaque action sensible.
• Accept edits : il modifie les fichiers sans demander, mais demande pour le reste.
• Plan mode : il n'agit pas, il propose d'abord un plan. Vous approuvez, puis il exécute. Idéal pour les modifications importantes.
• bypassPermissions : il agit sans rien demander. Rapide, mais sans garde-fou.

Ce paramétrage se fait dans settings.json (global ou projet), avec une liste d'autorisation précise : "autoriser npm run build et git status sans demander, mais demander pour tout rm".

Le cas de Pierre est instructif : il fonctionne en bypassPermissions par défaut (pour la vitesse), ce qui désactive le garde-fou automatique sur rm. Sa contremesure n'est pas technique, mais consiste en une règle absolue dans le CLAUDE.md : archiver dans _ARCHIVES/, ne jamais supprimer. Leçon : plus vous accordez d'autonomie, plus vos règles écrites comptent.

Installer Claude Code et premier lancement

Claude Code est l'agent de codage en ligne de commande d'Anthropic. Il lit vos fichiers, écrit du code, exécute des commandes et raisonne sur l'ensemble de votre projet, le tout depuis un terminal. Pour l'utiliser, vous avez besoin de Node.js (l'environnement d'exécution JavaScript) en version 18 ou supérieure, ainsi que de son gestionnaire de paquets intégré npm (Node Package Manager). Vérifiez ce que vous avez en exécutant node -v et npm -v dans n'importe quel terminal.

Installez Claude Code globalement avec une seule commande npm pour qu'il soit disponible depuis n'importe quel dossier de votre machine :

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

Le drapeau -g signifie "global" : npm place le binaire claude dans le chemin système. Une fois installé, authentifiez-vous une fois en exécutant claude sans argument. Claude Code ouvre une fenêtre de navigateur (ou affiche une URL) pour que vous puissiez vous connecter avec votre compte Anthropic. Vos identifiants sont stockés localement et réutilisés lors de chaque session future.

L'endroit depuis lequel vous lancez Claude Code a de l'importance. Le répertoire personnel est votre dossier utilisateur (par exemple C:\Users\yourname sous Windows ou /Users/yourname sous Mac). Démarrer Claude depuis ce répertoire charge uniquement votre mémoire et vos paramètres globaux. Le répertoire du projet est le dossier qui contient votre code. Démarrer Claude depuis ce répertoire charge la mémoire spécifique au projet et donne à Claude Code le contexte complet de cette base de code. Faites toujours un cd dans votre projet en premier, puis exécutez claude.

• Prérequis : Node.js 18+ et npm (fournis ensemble avec une installation standard de Node).
• Installation : npm install -g @anthropic-ai/claude-code
• Premier lancement : exécutez claude et finalisez la connexion dans le navigateur.
• Chaque session ensuite : cd votre-projet puis claude.

La zone de saisie : modes et pilotage

La zone de saisie de Claude Code fait bien plus qu'accepter du texte. C'est aussi un volant que vous pouvez saisir à tout moment pendant une tâche. Comprendre ses modes vous permet de rester aux commandes au lieu d'attendre sans rien faire qu'une longue exécution se termine.

Lorsque Claude Code est en cours d'exécution, appuyer sur Escape envoie un signal d'interruption (une demande d'arrêt de l'action en cours). Claude Code termine l'étape atomique en cours, puis se met en pause et vous rend la main. Vous pouvez alors le réorienter, corriger ou continuer avec une nouvelle instruction.

Pour la saisie multiligne (plusieurs lignes dans une seule invite, utile pour coller une spec ou un bloc de code), appuyez sur Shift+Enter pour insérer un saut de ligne sans envoyer. Appuyez sur Enter seul pour envoyer.

Trois modes d'invite vous permettent de façonner la manière dont Claude Code répond :

• Mode normal : saisissez votre instruction et appuyez sur Entrée. Claude Code choisit les outils et agit de façon autonome.
• Plan mode (--plan) : Claude Code rédige un plan étape par étape et attend votre approbation avant de toucher un fichier.
• Mode acceptation automatique (--dangerously-skip-permissions) : toutes les demandes de permission sont ignorées automatiquement. À utiliser uniquement dans un bac à sable sécurisé, jamais sur des fichiers de production.

Pointer vers des fichiers avec @

Dans Claude Code, la référence @ permet de pointer vers un fichier ou un dossier sans en copier le contenu. Tapez @ suivi d'un chemin et Claude Code lit ce fichier directement depuis votre disque. Vous n'avez donc jamais besoin de coller des blocs de code dans le chat.

Au fur et à mesure que vous tapez @, Claude Code affiche un menu de complétion par tabulation listant les fichiers et dossiers de votre projet. Appuyez sur Tab pour parcourir les correspondances et sur Enter pour confirmer. Vous pouvez référencer plusieurs éléments dans un seul message.

Pourquoi est-ce supérieur au copier-coller ? Trois raisons :

• Exactitude : Claude lit le fichier tel qu'il existe sur le disque, donc rien n'est perdu à cause d'erreurs de copier-coller ou d'un contenu de presse-papiers obsolète.
• Efficacité du contexte : Claude Code n'envoie que ce dont il a besoin du fichier, ce qui évite de remplir inutilement la fenêtre de contexte (la quantité totale de texte que Claude peut conserver en mémoire simultanément).
• Références de dossiers : Pointer vers un dossier avec @src/ permet à Claude de parcourir toute l'arborescence et de sélectionner lui-même les fichiers pertinents, ce qui serait peu pratique à coller manuellement.

Vous pouvez combiner des références @ avec des instructions ordinaires dans le même message. Par exemple : Review @src/auth.js and check @tests/auth.test.js for missing coverage.

Exécuter des commandes shell

Claude Code peut exécuter de vraies commandes shell sur votre machine grâce à son outil Bash intégré. Un shell (aussi appelé terminal ou ligne de commande) est l'interface textuelle qui contrôle votre système d'exploitation. Lorsque vous demandez à Claude Code d'installer un paquet, de lancer des tests ou de vérifier un fichier, il envoie ces commandes à l'outil Bash et lit le résultat avant de vous répondre.

Avant d'exécuter toute commande, Claude Code vous montre ce qu'il s'apprête à lancer et attend votre approbation. Cette invite de permission constitue votre filet de sécurité. Vous pouvez approuver la commande, la modifier ou la refuser. Une fois approuvée, la sortie revient directement dans Claude Code, qui peut ainsi réagir aux erreurs ou aux résultats sans que vous ayez à copier-coller quoi que ce soit.

Vous pouvez contrôler quelles commandes nécessitent une approbation. La liste autorisée dans vos paramètres vous permet de mettre en liste blanche des commandes sûres (comme npm test ou ls) afin qu'elles s'exécutent sans interruption. Les opérations dangereuses, comme la suppression de fichiers, déclencheront toujours une invite, sauf si vous les autorisez explicitement.

• Lecture de la sortie : Claude Code voit stdout et stderr (la sortie normale et le flux d'erreurs) et les analyse.
• Chaînes multi-étapes : il peut exécuter plusieurs commandes en séquence, en utilisant le résultat de l'une pour décider de la suivante.
• Tâches en arrière-plan : les commandes longues (comme un serveur de développement) peuvent être lancées en arrière-plan pour que la session reste réactive.
• Répertoire de travail : les commandes s'exécutent dans le dossier de projet que vous avez ouvert, pas dans un emplacement aléatoire.

Lire et approuver les modifications

Lorsque Claude Code modifie un fichier, il affiche un diff (abréviation de "difference"), une vue côte à côte ou en ligne où les lignes marquées - sont supprimées et les lignes marquées + sont ajoutées. Rien n'est écrit sur le disque tant que vous n'avez pas approuvé.

Claude Code vise des modifications chirurgicales : il ne touche que les lignes qui doivent changer, en laissant le reste du fichier intact. Cela permet de garder les diffs petits et faciles à relire. Si une modification proposée semble plus grande que prévu, c'est un signal pour lire attentivement avant d'accepter.

Trois réponses sont disponibles chaque fois qu'une modification est proposée :

• y / yes : accepter et écrire la modification sur le disque.
• n / no : rejeter et demander à Claude Code d'essayer une autre approche.
• e / edit : ouvrir le diff dans votre éditeur pour l'ajuster manuellement avant de sauvegarder.

Si vous exécutez Claude Code avec le flag --dangerously-skip-permissions (mode approbation automatique), toutes les modifications sont écrites immédiatement sans invite. N'utilisez ce flag que dans des environnements jetables où la vitesse prime sur la relecture.

Git depuis Claude Code

Claude Code comprend Git (le système de contrôle de version qui enregistre chaque modification de votre code) de façon native. Vous pouvez décrire ce que vous souhaitez en français courant et Claude Code exécutera les bonnes commandes Git, expliquera le résultat et demandera confirmation avant toute action destructrice.

Les quatre opérations Git du quotidien que Claude Code gère pour vous sont : vérifier le status (ce qui a changé), lire un diff (les lignes exactes ajoutées ou supprimées), rédiger un message de commit (une capture enregistrée avec une description), et ouvrir une pull request (une proposition formelle de fusionner vos modifications dans le code principal).

Claude Code gère également les branches (versions parallèles du code). Vous pouvez lui demander de créer une branche, de basculer vers l'une d'elles ou de fusionner des modifications, sans avoir à mémoriser de flags. Les principales commandes exécutées en coulisses sont git status, git diff, git add, git commit, git checkout -b et gh pr create (via le GitHub CLI).

• Status : "Quels fichiers ai-je modifiés ?" Claude Code exécute git status et fait un résumé.
• Diff : "Montre-moi ce qui a changé dans auth.js." Claude Code exécute git diff auth.js et explique les modifications en langage courant.
• Commit : "Commite ces modifications avec un bon message." Claude Code indexe les fichiers et rédige un message de commit concis et conventionnel.
• Branche : "Crée une branche appelée fix/login-bug." Claude Code exécute git checkout -b fix/login-bug.
• Pull request : "Ouvre une PR vers main avec un résumé." Claude Code utilise gh pr create et rédige le titre et le corps pour vous.

La liste de tâches

Lorsque vous confiez à Claude Code un travail complexe comportant plusieurs étapes, il ne conserve pas l'ensemble du plan de façon invisible dans sa mémoire. Il maintient à la place une liste de tâches : une checklist structurée de sous-tâches qu'il crée au début du travail et met à jour au fur et à mesure. Considérez-la comme un tableau blanc partagé entre vous et l'agent.

La liste de tâches remplit deux fonctions. Premièrement, elle permet à Claude Code de rester sur la bonne voie à travers de nombreuses modifications de fichiers, appels d'outils et décisions. Deuxièmement, elle vous permet de suivre la progression en temps réel sans lire chaque ligne de sortie. Chaque élément passe de "en attente" à "en cours" puis à "terminé" (ou "bloqué") au fil de la session.

Vous pouvez interagir avec la liste de tâches à tout moment :

• Tapez un message de suivi pour ajouter une nouvelle sous-tâche ou réorganiser les priorités.
• Demandez à Claude Code de faire une pause après une tâche spécifique afin de pouvoir vérifier avant qu'il continue.
• Dites "saute l'étape 3" ou "concentre-toi uniquement sur les étapes 1 et 4" et l'agent s'adaptera.
• Si une tâche est bloquée (par exemple, un fichier manquant), Claude Code le signalera et attendra plutôt que de l'ignorer silencieusement.

Dans l'extension VS Code et l'interface web, la liste de tâches apparaît sous forme de panneau latéral repliable. Dans l'interface CLI (interface en ligne de commande, la version terminal), elle est affichée en ligne au fur et à mesure que la session s'exécute. Dans les deux cas, les éléments terminés sont cochés et l'élément en cours est mis en évidence.

Le mode plan en profondeur

Le mode plan est une phase en lecture seule dans Claude Code où l'agent analyse votre base de code et propose un plan structuré avant d'écrire ou de modifier le moindre fichier. Considérez-le comme une revue de blueprint : Claude recense chaque étape, et rien ne change sur le disque tant que vous n'avez pas donné le feu vert.

Pour activer le mode plan, passez le flag --plan au démarrage d'une tâche, ou tapez /plan dans une session Claude Code active. Claude lira les fichiers, tracera les dépendances et produira une liste d'actions numérotées. Durant cette phase il ne dispose d'aucune permission d'écriture, il ne peut donc pas écraser votre travail par accident.

Une fois le plan affiché, trois options s'offrent à vous :

• Approuver : tapez yes ou appuyez sur Entrée pour laisser Claude exécuter chaque étape dans l'ordre.
• Modifier : collez le plan avec vos corrections, puis approuvez la version révisée.
• Annuler : tapez no ou appuyez sur Ctrl+C pour annuler sans toucher aucun fichier.

Utilisez le mode plan chaque fois qu'une tâche concerne plusieurs fichiers, implique un refactoring risqué, ou quand vous souhaitez un second avis avant de valider des modifications. Cela prend un peu plus de temps au départ, mais évite les erreurs difficiles à inverser et vous offre une trace claire de ce que Claude a l'intention de faire.

Modes de permission et bypass

Claude Code vous demande votre accord avant d'effectuer des actions comme modifier des fichiers ou exécuter des commandes. La fréquence de ces demandes dépend du mode de permission, un réglage qui équilibre sécurité et rapidité.

Il y a quatre modes à connaître :

• default : Claude demande confirmation avant chaque modification de fichier et chaque commande shell. Le plus sûr, mais qui nécessite le plus d'interactions.
• acceptEdits : Claude applique les modifications de fichiers automatiquement mais demande toujours confirmation avant d'exécuter des commandes shell. Un compromis courant pour les sessions de développement.
• plan : Claude se contente de lire et de planifier ; il n'écrit ni n'exécute rien. Utile pour examiner une stratégie avant de s'engager.
• bypassPermissions : Claude agit sans demander aucune autorisation. Vitesse maximale, filet de sécurité minimal.

Vous pouvez définir un mode pour une seule session avec le flag --permission-mode (par exemple, claude --permission-mode acceptEdits), ou le fixer pour un projet en l'ajoutant dans .claude/settings.json sous la clé permissionMode.

Le compromis de sécurité est réel : bypassPermissions supprime le garde-fou qui détecte les suppressions accidentelles ou les commandes shell destructrices. Utilisez-le uniquement dans des environnements éphémères, des bacs à sable, ou lorsque vous disposez d'un contrôle de version et savez exactement ce que Claude va faire.

La ligne de statut

A chaque fois que Claude Code répond, une ligne de statut apparaît en bas du terminal. Elle vous donne un instantané en direct de trois informations : la quantité de la fenêtre de contexte (la mémoire totale que Claude peut conserver pour votre session) que vous avez utilisée, le coût estimé de la session jusqu'à présent en USD, et l'identifiant du modèle actif.

L'utilisation du contexte est affichée sous forme de fraction et de pourcentage, par exemple 12 340 / 200 000 tokens (6%). Un token représente environ trois à quatre caractères de texte. Lorsque vous approchez les 100 pour cent, Claude commence à perdre les premières parties de la conversation, donc surveiller ce chiffre vous aide à décider quand démarrer une nouvelle session avec /clear.

La ligne de statut est pilotée par un petit script appelé statusline.cjs. Claude Code envoie un objet JSON à ce script après chaque tour. L'objet contient ces champs :

• context_window : tokens utilisés et capacité totale.
• cost : coût USD cumulé pour la session.
• rate_limits : utilisation glissante sur les 5 dernières heures et 7 jours (ces champs sont absents quand Claude Code ne les émet pas, donc la barre d'utilisation disparaît simplement plutôt que d'afficher des données périmées).
• model : l'identifiant du modèle actif, par exemple claude-sonnet-4-6 ou claude-opus-4-8.

Vous pouvez entièrement personnaliser ce qu'affiche la ligne de statut en modifiant statusline.cjs dans votre dossier de configuration Claude Code. Analysez le JSON entrant avec Node.js (pas jq, qui peut ne pas être installé) et formatez la chaîne de sortie comme vous le souhaitez : codes de couleur, champs supplémentaires, étiquettes abrégées, ou tout ce que votre terminal supporte.

/init et l'intégration d'un dépôt

Lorsque vous ouvrez un projet pour la première fois dans Claude Code (l'agent de développement CLI et IDE), lancez /init dans le panneau de conversation. Claude Code analyse votre dépôt et génère un fichier appelé CLAUDE.md à la racine du projet. Ce fichier est la source de vérité unique que Claude lit au démarrage de chaque session future, ce qui lui évite de redécouvrir à chaque fois le contexte du projet.

Lors de l'analyse, /init inspecte plusieurs éléments :

• Les manifestes de paquets et les fichiers de verrouillage (package.json, pyproject.toml, go.mod, etc.) pour identifier le langage et les dépendances
• Les fichiers de configuration des frameworks (Astro, Next.js, Vite, Django, et autres) pour comprendre le système de build
• Les points d'entrée courants tels que src/index.* ou main.* pour cartographier la structure du projet
• Les fichiers README ou CONTRIBUTING existants pour les conventions déjà documentées par l'équipe

Le fichier CLAUDE.md résultant contient une courte description du projet, les commandes pour exécuter, tester et construire le projet, les conventions de code que Claude a inférées, et une section à compléter manuellement avec les règles de l'équipe. Vous devez relire et modifier ce fichier avant de le committer : supprimez ce qui est inexact, ajoutez les contraintes que Claude n'a pas détectées (variables d'environnement, paquets interdits, règles de style), et gardez-le concis car Claude lit chaque mot à chaque démarrage de session.

Une fois que CLAUDE.md existe, chaque collaborateur (humain ou agent) qui ouvre le dépôt dans Claude Code hérite automatiquement du même contexte. Si le projet évolue, relancez /init à tout moment pour rafraîchir le fichier, ou modifiez-le directement comme n'importe quel autre fichier texte.

Raccourcis clavier et mode vim

Claude Code s'exécute dans votre terminal et s'appuie donc sur des raccourcis clavier plutôt que sur la souris. Apprendre quelques combinaisons suffit pour transformer des interactions lentes et répétitives en échanges rapides et fluides. Les raccourcis ci-dessous fonctionnent dans le mode readline par défaut (la couche d'édition de ligne standard intégrée à la plupart des shells et terminaux de type Unix).

Les combinaisons les plus utiles en session concernent la navigation et l'historique. Ctrl+A déplace le curseur au début de la ligne, Ctrl+E le déplace à la fin. Ctrl+U efface tout ce qui précède le curseur, ce qui est plus rapide que de maintenir la touche Retour arrière. Ctrl+W supprime le dernier mot. Pour parcourir l'historique des invites, utilisez les touches flèche vers le haut et flèche vers le bas, ou bien Ctrl+P (précédent) et Ctrl+N (suivant) en alternative.

Claude Code propose également un mode vim optionnel pour la saisie des invites. Vim est un éditeur de texte piloté au clavier dont la conception "modale" permet de basculer entre la saisie de texte et l'exécution de commandes de déplacement ou d'édition. Pour l'activer, exécutez /vim dans une session Claude Code. Une fois actif, la saisie démarre en mode Insertion (tapez normalement). Appuyez sur Échap pour passer en mode Normal, où les touches individuelles deviennent des commandes : h j k l pour le déplacement, dd pour supprimer une ligne, 0 pour aller au début, $ pour aller à la fin. Appuyez sur i pour revenir en mode Insertion. Appuyez sur Entrée dans l'un ou l'autre mode pour envoyer l'invite.

Quelques raccourcis supplémentaires méritent d'être connus au niveau de la session :

• Ctrl+C : interrompt (annule) la tâche en cours sans fermer la session.
• Ctrl+L : efface l'écran du terminal tout en maintenant la session active.
• Ctrl+R : recherche inverse dans l'historique des invites (tapez un fragment pour retrouver une invite passée).
• /clear : commande tapée qui réinitialise le contexte de conversation dans Claude Code.
• /vim : active ou désactive le mode vim.