Claude Code est l'agent de code d'Anthropic qui vit dans le terminal. Il lit les fichiers du dossier où on le lance, en écrit, exécute des commandes, et chacune de ces actions passe par un système de permissions que vous réglez.
C'est l'outil des neuf travaux pratiques. Ce module l'installe, fait le tour de sa session, et met en place les deux réglages qui comptent sur les deux jours : le contexte qu'on lui donne et l'autonomie qu'on lui laisse.
Trois familles de modèles se partagent le travail, par ordre décroissant de puissance et de coût. On choisit le moins cher qui fait le travail : un modèle plus puissant ne rattrape pas un prompt mal posé, il coûte plus cher à se tromper.
| Famille | Alias /model |
Pour quoi | Où on le voit |
|---|---|---|---|
| Opus | opus, opus[1m] |
Raisonnement long, architecture, plan d'implémentation | TP 4 |
| Sonnet | sonnet, sonnet[1m] |
Écriture de code, tests, itérations | Tous les TP |
| Haiku | haiku |
Tâches courtes et répétitives, sous-agents de routine | TP 4, TP 9 |
| Mixte | opusplan |
Opus pour planifier, bascule sur Sonnet pour exécuter | Module 03 |
/model sans argument affiche le modèle courant et la liste des alias disponibles.
/model
Current model: `Sonnet 5`
Usage: /model <name>. Available: sonnet, opus, haiku, fable, best, sonnet[1m], opus[1m], fable[1m], opusplan, default, or a full model ID.
Avec un argument, il change de modèle pour la session en cours.
/model haiku
Set model to `Haiku 4.5` for this session only
Utilisez les alias plutôt que les identifiants complets : ils suivent la dernière version de chaque famille.
/effort règle la quantité de raisonnement que le modèle s'autorise avant de répondre, indépendamment du modèle choisi. Cinq niveaux sur Opus 5 et Sonnet 5, high par défaut.
/effort low # tâche courte, latence prioritaire
/effort medium # travail sensible au coût
/effort high # équilibre par défaut
/effort xhigh # raisonnement plus profond, plus de tokens
/effort max # tâches exigeantes, tendance à trop réfléchir
Sans argument, /effort ouvre un curseur interactif. Au lancement, claude --effort xhigh ne vaut que pour la session.
L'installateur natif est la méthode recommandée : il pose un binaire autonome, sans Node.js à gérer.
# macOS, Linux et WSL
curl -fsSL https://claude.ai/install.sh | bash
# Windows, dans PowerShell
irm https://claude.ai/install.ps1 | iex
Deux autres méthodes existent si votre poste est déjà outillé.
# Avec npm
npm install -g @anthropic-ai/claude-code
# Avec Homebrew, sur macOS
brew install --cask claude-code
On vérifie l'installation par la version, qui s'affiche suivie du nom du produit.
claude --version
<version> (Claude Code)
En cas de doute, claude doctor lance un examen de l'installation et de la configuration : emplacement du binaire, validité des fichiers de réglages, taille du CLAUDE.md du projet, serveurs MCP et plugins inutilisés. Il rend un rapport en plusieurs points et propose des corrections.
Au premier lancement de claude, le navigateur s'ouvre pour la connexion et le terminal affiche Login successful. Si le navigateur ne s'ouvre pas (SSH, conteneur, WSL), la touche c copie l'adresse. /login reconnecte ou change de compte, /status affiche le compte actif, l'organisation et la méthode d'authentification.
Pour une facturation à l'usage, la clé d'API de la Console se passe par la variable d'environnement ANTHROPIC_API_KEY, qui prend le pas sur le compte connecté.
export ANTHROPIC_API_KEY=sk-ant-...
C'est le mode de l'intégration continue, traité au module Git, CI/CD et hooks déterministes. Une clé d'API se traite comme un mot de passe : jamais dans un fichier versionné, jamais dans un prompt.
Note : Claude Code demande un abonnement Claude Pro, Max, Team ou Enterprise, ou un compte Claude Console avec facturation à l'usage. Le forfait gratuit ne donne pas accès à Claude Code. Cette liste change : revalidez-la avant chaque session de formation.
Le moteur est le même partout : l'extension IDE et la ligne de commande partagent les mêmes fichiers de configuration, les mêmes permissions et le même CLAUDE.md. Ce que l'IDE apporte, c'est l'affichage des différences dans l'éditeur et la sélection courante passée en contexte.
Cmd+Maj+X ou Ctrl+Maj+X, chercher « Claude Code », cliquer sur Install. L'extension embarque sa propre copie du binaire pour le panneau de conversation.Option+K ou Alt+K insère une référence du type @app/quiz.py#32-36. Quand Claude propose une modification, elle s'ouvre dans le comparateur natif de VS Code, original à gauche et proposition à droite, avec le choix d'accepter, de refuser ou de répondre.Cmd+Échap ou Ctrl+Échap bascule le focus entre l'éditeur et la zone de saisie de Claude.
claude dans le terminal intégré de l'IDE.claude depuis le terminal intégré. Les modifications s'ouvrent alors dans le comparateur de l'IDE et non dans le terminal, la sélection courante est partagée, et Cmd+Option+K ou Alt+Ctrl+K insère une référence de fichier avec ses numéros de ligne.Depuis un terminal externe, la commande /ide connecte la session à l'IDE ouvert et affiche Connected to IntelliJ IDEA. en cas de succès.
Note : Sous Windows, préférez WSL2. Beaucoup de commandes des TP (guillemets simples,
grep,sed) se comportent différemment sous PowerShell.
On lance Claude Code depuis le dossier du projet : c'est ce dossier qui devient son périmètre. L'écran tient en trois zones, le transcript qui déroule les actions et les réponses, la zone de saisie en bas, et sous elle une barre d'état qui affiche le modèle, le mode de permission courant et l'occupation du contexte.
cd ~/projets/quizops
claude
# Démarrer avec une première demande
claude "explique la structure de ce projet"
# Mode non interactif : une réponse, puis sortie
claude -p "liste les routes de l'API"
# Reprendre la conversation la plus récente de ce dossier
claude --continue
# Choisir une session passée dans une liste
claude --resume
# Ajouter un dossier hors du projet au périmètre
claude --add-dir ../bibliotheque-commune
Une fois lancé, l'agent enchaîne les actions sans repasser par vous entre chaque étape : il écrit un test, le lance, lit l'échec, corrige le code. Le transcript montre chaque appel d'outil et son résultat.
⏺ Bash(grep -n "def \|score" app/quiz.py)
⎿ 1:"""Tirage des questions et calcul du score.""" (+4 lignes)
⏺ Read(app/quiz.py)
⎿ 15 def sans_reponse(question: dict) -> dict: (+22 lignes)
⏺ Le score est calculé dans `app/quiz.py`, fonction `calculer_score` (avec l'aide de
`compter_bonnes_reponses`). Elle ne garde que les réponses effectivement fournies
(celles où `choix` n'est pas `None`), puis compte parmi elles combien correspondent
à la bonne réponse de la question associée.
Les raccourcis à connaître :
| Raccourci | Effet |
|---|---|
Échap |
Interrompt l'agent en pleine action |
Échap Échap |
Revient en arrière dans la conversation, ou efface le brouillon en cours |
Maj+Tab |
Passe au mode de permission suivant |
Option+T ou Alt+T |
Bascule la réflexion étendue |
Ctrl+R |
Cherche dans l'historique des prompts |
Ctrl+T |
Affiche la liste des tâches en cours |
Ctrl+O |
Bascule l'affichage détaillé du transcript |
! |
Exécute une commande shell et injecte sa sortie |
@ |
Insère un fichier en contexte |
/ |
Ouvre le menu des commandes |
Le préfixe @ est le plus utile au quotidien : @app/quiz.py évite à l'agent une phase de recherche et vous garantit qu'il lit le bon fichier.
Les commandes se tapent dans la zone de saisie et ne partent pas au modèle : elles agissent sur la session elle-même.
| Commande | Effet | Démontré |
|---|---|---|
/clear |
Vide la conversation et repart à zéro | Ci-dessous |
/compact |
Résume la conversation et repart du résumé | Ci-dessous |
/context |
Détaille ce qui occupe la fenêtre de contexte | Ci-dessous |
/cost |
Affiche la consommation de la session | Ci-dessous |
/model |
Change de modèle | Plus haut |
/effort |
Change le niveau de raisonnement | Plus haut |
/permissions |
Ouvre l'éditeur des règles d'autorisation et de refus | Module 06 |
/config |
Ouvre les réglages de la session (thème, comparateur, notifications) | TP 1 |
/resume |
Reprend une session passée choisie dans une liste | TP 1 |
/rewind |
Revient à un point antérieur de la session | TP 3 |
/memory |
Liste et ouvre les fichiers mémoire | Plus bas |
/init |
Génère un CLAUDE.md de départ |
Plus bas |
/doctor |
Diagnostique installation et configuration | Plus haut |
/status |
Affiche compte, modèle et connexions actives | Plus haut |
/context est le premier réflexe quand les réponses se dégradent. Sur QuizOps au tag tp1-depart, avant tout CLAUDE.md :
## Context Usage
**Model:** claude-sonnet-5
**Tokens:** 24.1k / 1m (2%)
### Estimated usage by category
| Category | Tokens | Percentage |
|-------------------------|--------|------------|
| System prompt | 8.8k | 0.9% |
| System tools | 13.2k | 1.3% |
| System tools (deferred) | 14.7k | 1.5% |
| Skills | 2.1k | 0.2% |
| Messages | 8 | 0.0% |
| Free space | 943k | 94.3% |
| Autocompact buffer | 33k | 3.3% |
Aucune ligne Memory files : le projet n'a pas encore de CLAUDE.md. La ligne Messages à 8 tokens indique une conversation vide.
/cost, alias de /usage, affiche la consommation. L'écran réunit un bloc Session (coût estimé, durées, lignes modifiées, détail par modèle), les barres d'usage du forfait avec leurs dates de remise à zéro, et la répartition de ce qui a consommé : skills, sous-agents, plugins, serveurs MCP. Sur un forfait, le montant du bloc Session est une estimation calculée en local au tarif public : il ne correspond à aucune facture, puisque l'usage est compris dans l'abonnement. Sur un accès API, c'est bien ce qui sera facturé.
You are currently using your subscription to power your Claude Code usage
Current session: 70% used · resets Sep 10 at 2:40pm (Europe/Paris)
Current week (all models): 12% used · resets Sep 14 at 11pm (Europe/Paris)
/compact n'affiche rien : il remplace la conversation par son résumé. La preuve se lit au /context suivant, où la ligne Messages passe de 8 tokens à 5 000.
**Tokens:** 29.5k / 1m (3%)
| Category | Tokens | Percentage |
|-------------------------|--------|------------|
| Memory files | 484 | 0.0% |
| Messages | 5k | 0.5% |
| Free space | 937.5k | 93.7% |
La règle d'usage tient en une ligne : /clear entre deux tâches sans rapport, /compact pour continuer la même tâche quand la fenêtre se remplit.
Le mode de permission est le curseur d'autonomie de l'agent. Il se change à tout moment avec Maj+Tab, qui fait défiler les modes, et le mode actif s'affiche dans la barre d'état.
| Mode | Ce qui passe sans demander | Quand l'utiliser |
|---|---|---|
default |
Rien au-delà des lectures ; chaque outil est demandé à son premier usage | Code sensible, découverte de l'outil |
acceptEdits |
Les écritures de fichiers et les commandes de fichiers courantes (mkdir, touch, mv, cp) dans le périmètre |
Itérer sur du code relu au fur et à mesure |
plan |
Les lectures et les commandes shell en lecture seule ; aucune écriture | Faire proposer une stratégie avant d'agir |
auto |
Tout, chaque action étant relue par un classifieur en arrière-plan qui vérifie qu'elle correspond à la demande | Tâches longues sur un projet outillé |
dontAsk |
Uniquement ce qu'une règle permissions.allow autorise ; tout le reste est refusé sans question |
Automatisation où une question bloquerait |
bypassPermissions |
Tout, sans contrôle | Conteneurs et machines virtuelles isolés, jamais ailleurs |
Au lancement, --permission-mode fixe le mode de départ.
claude --permission-mode plan
claude --permission-mode acceptEdits
Le README.md de QuizOps contient une faute : « Kubernete » au lieu de « Kubernetes ». En mode plan, on demande de la corriger.
⏺ Bash(grep -n "Kubernete" README.md)
⎿ 3:Un quiz sur Docker et Kubernete, servi par FastAPI.
⏺ Trouvé : c'est une correction triviale (une lettre manquante dans README.md:3).
⏺ Dites-moi si je peux procéder à cette modification.
L'agent a cherché, trouvé, et s'est arrêté là : git status --short ne signale aucun fichier modifié. La même demande en acceptEdits :
⏺ Bash(grep -n "Kubernete" README.md)
⎿ 3:Un quiz sur Docker et Kubernete, servi par FastAPI.
⏺ Edit(README.md)
⎿ The file ~/projets/quizops/README.md has been updated successfully.
⏺ Corrigé : "Kubernete" → "Kubernetes" dans README.md.
$ git status --short
M README.md
?? CLAUDE.md
$ git diff --stat
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
Le mode plan structure la phase de conception ; il est repris au module Prompt engineering et conception.
Une session oublie tout. Le fichier CLAUDE.md est lu au démarrage de chaque session, sans que vous ayez à le mentionner : c'est là que vivent les faits que vous ne voulez pas réexpliquer.
| Portée | Emplacement | Pour quoi | Versionné |
|---|---|---|---|
| Managée | /Library/Application Support/ClaudeCode/CLAUDE.md, /etc/claude-code/CLAUDE.md ou C:\Program Files\ClaudeCode\CLAUDE.md |
Règles d'entreprise déployées par l'informatique | Hors dépôt |
| Utilisateur | ~/.claude/CLAUDE.md |
Vos préférences, tous projets confondus | Non |
| Projet | ./CLAUDE.md ou ./.claude/CLAUDE.md |
Les conventions de l'équipe | Oui |
| Locale | ./CLAUDE.local.md |
Vos préférences sur ce projet seulement | Non, à mettre dans .gitignore |
Les quatre portées se cumulent dans cet ordre, de la plus large à la plus proche du dossier de travail. Visez moins de 200 lignes par fichier : au-delà, le contexte se remplit et les consignes sont moins bien suivies.
Pour un projet plus gros, .claude/rules/ range les instructions par sujet et les conditionne à des chemins avec le champ paths.
---
paths:
- "app/**/*.py"
---
# Règles du code serveur
- Toutes les requêtes SQL sont paramétrées
- Aucune route ne contient de SQL
Cette règle n'entre en contexte que lorsque l'agent lit un fichier Python de app/. Une règle sans champ paths se charge à chaque session, comme un CLAUDE.md.
Un CLAUDE.md peut en importer d'autres avec la syntaxe @chemin, jusqu'à quatre niveaux de profondeur.
Voir @PRD.md pour les exigences produit et @docs/conventions-api.md
pour les règles de nommage des routes.
Les fichiers importés sont chargés au démarrage : importer ne réduit pas la consommation de contexte, cela la déplace.
/init explore le projet et écrit un CLAUDE.md de départ. Sur QuizOps au tag tp1-depart, il lit une trentaine de fichiers avant d'écrire.
⏺ Bash(ls -la && echo "---" && find . -maxdepth 3 -not -path '*/node_modules/*' -not -…)
⎿ total 88 (+133 lignes)
⏺ Read(README.md)
⎿ 1 # QuizOps (+5 lignes)
⏺ Read(pyproject.toml)
⎿ 1 [project] (+21 lignes)
⏺ Read(app/main.py)
⎿ 1 """API et interface de QuizOps.""" (+38 lignes)
⏺ Read(app/quiz.py)
⎿ 1 """Tirage des questions et calcul du score.""" (+36 lignes)
⏺ Read(app/database.py)
⎿ 1 """Accès à la base SQLite des scores.""" (+33 lignes)
…
⏺ Write(CLAUDE.md)
⎿ File created successfully at: ~/projets/quizops/CLAUDE.md
Le fichier produit fait 82 lignes, en anglais, et décrit ce que l'agent a trouvé.
# CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
## What this is
QuizOps is a small quiz app about Docker and Kubernetes, served by FastAPI with a
dependency-free vanilla-JS frontend. Code, comments, docstrings, and commit messages
are in French; keep new code consistent with that.
…
## Commands
- Run the dev server: `uv run uvicorn app.main:app --reload`
- Run the test suite: `uv run pytest -q`
- Run a single test file: `uv run pytest tests/test_api.py -q`
…
## Architecture
- `app/main.py` : FastAPI app and routes. Loads all questions once at import time
(`QUESTIONS`, `QUESTIONS_PAR_ID`), initializes the SQLite schema, and mounts
`static/` at `/static` plus `/` for the SPA shell.
…
C'est un point de départ, pas un livrable. La relecture retire ce que l'agent aurait retrouvé seul (la structure des dossiers, la liste des routes) et ajoute ce qu'il ne peut pas deviner. Voilà ce que le dépôt garde au tag tp2-depart, 26 lignes en français :
# QuizOps
Quiz Docker et Kubernetes : API FastAPI, base SQLite, interface HTML, CSS et JavaScript sans framework.
## Commandes
- Lancer : `uv run uvicorn app.main:app --reload` puis http://127.0.0.1:8000
- Tests : `uv run pytest -q`
- Qualité : `uvx ruff format . && uvx ruff check .`
## Structure
- `app/main.py` : les routes `/api/...` et le service des fichiers statiques
- `app/quiz.py` : tirage des questions et calcul du score
- `app/donnees.py` : chargement et validation de `data/questions.json`
- `app/database.py` : accès SQLite (`quizops.db`, jamais versionné)
- `tests/` : la suite pytest ; `tests/a-venir/` : les tests des lots pas encore livrés, ignorés par pytest
- `outils/` : scripts du formateur, à ne pas modifier
## Conventions
- Code, commentaires, noms de tests et messages de commit en français
- Pas de module `utils.py` : chaque fonction va dans le module de son sujet
- Pas de `try/except` générique : une erreur inattendue doit remonter
- Ne modifie jamais un test existant sans le dire explicitement
- Une fonctionnalité = un commit ; lance `uv run pytest -q` avant de conclure
| Ce qu'on y met | Ce qu'on n'y met pas |
|---|---|
| Les commandes de lancement, de test et de formatage | La structure des dossiers, que l'agent découvre seul |
| Les conventions de code du projet | Une procédure en plusieurs étapes, qui est un skill (module 05) |
| Les règles métier non devinables | Une règle qui ne vaut que pour un dossier, qui est une règle paths |
Les pièges connus (quizops.db n'est jamais versionné) |
Un secret ou une URL interne : le fichier est versionné |
| Ce qu'il ne faut jamais toucher | Ce qui doit s'appliquer à coup sûr, qui est un hook (module 06) |
| Les décisions qui ne se lisent pas dans le code | Le contenu du README.md recopié |
/memory liste les fichiers mémoire des portées utilisateur et projet, en créant celui que vous choisissez s'il n'existe pas encore, et propose l'interrupteur de la mémoire automatique. Pour ajouter une consigne durable, demandez-le en clair (« ajoute cette règle au CLAUDE.md du projet ») : l'agent édite le fichier et vous relisez le diff.
En plus des fichiers que vous écrivez, Claude Code tient une mémoire automatique dans ~/.claude/projects/<projet>/memory/. Claude y consigne de lui-même vos corrections, vos préférences et les décisions du projet qu'il ne peut pas déduire du code. Un fichier MEMORY.md sert d'index et n'est chargé qu'à hauteur de 200 lignes ou 25 Ko par session, les fichiers de sujet étant lus à la demande. Elle est active par défaut, machine par machine, et se coupe avec autoMemoryEnabled: false dans les réglages.
Pour vérifier qu'un CLAUDE.md est bien chargé, /context le liste sous Memory files. Sur QuizOps au tag tp2-depart :
**Tokens:** 24.6k / 1m (2%)
| Category | Tokens | Percentage |
|-------------------------|--------|------------|
| Memory files | 484 | 0.0% |
| Skills | 2.1k | 0.2% |
| Free space | 942.4k | 94.2% |
### Memory Files
| Type | Path | Tokens |
|---------|-----------------------------|--------|
| Project | ~/projets/quizops/CLAUDE.md | 484 |
Un CLAUDE.md obsolète oriente l'agent vers un état passé du projet, ce qui est pire qu'un CLAUDE.md absent. Le TP 2 en écrit une version minimale, le TP 6 la complète une fois le projet stabilisé.
Tout ce qui personnalise Claude Code vit dans un répertoire .claude/, dans votre dossier personnel pour vos réglages et à la racine du projet pour ceux de l'équipe. Voici celui de QuizOps sur la branche solution/tp9, c'est-à-dire à la fin des neuf TP.
$ git ls-tree -r --name-only solution/tp9 | grep -E '^\.claude|^\.mcp|^CLAUDE'
.claude-plugin/marketplace.json
.claude/agents/relecteur.md
.claude/agents/test-runner.md
.claude/commands/revue.md
.claude/hooks/garde-fou.sh
.claude/settings.json
.claude/skills/nouvelle-question/SKILL.md
.claude/skills/nouvelle-question/modele.json
.claude/skills/nouvelle-question/verifier.py
.mcp.json
CLAUDE.md
Chaque dossier est construit dans un TP : commands/ et skills/ au module 05, hooks/ au module 06, .mcp.json et .claude-plugin/ au module 07, agents/ au module 08.
settings.json porte les réglages partagés. Celui de QuizOps déclare des permissions et deux hooks.
{
"permissions": {
"allow": [
"Bash(uv run pytest*)"
],
"deny": [
"Bash(git push --force*)",
"Bash(git push -f*)",
"Read(.env)"
]
},
"hooks": {
"PostToolUse": [
{
"matcher": "Write|Edit",
"hooks": [
{
"type": "command",
"command": "jq -r '.tool_input.file_path' | grep '\\.py$' | xargs -r uvx ruff format -q"
}
]
}
],
"PreToolUse": [
{
"matcher": "Bash",
"hooks": [
{
"type": "command",
"command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/garde-fou.sh"
}
]
}
]
}
}
Les entrées de permissions.allow évitent de réaccorder la même autorisation à chaque session : ici, uv run pytest passe sans question. Celles de deny valent interdiction, quoi que dise le prompt : le Read(.env) protège le fichier de secrets, les deux règles git push protègent l'historique. /permissions ouvre le même contenu depuis la session, en mode interactif. Le bloc hooks est traité au module Git, CI/CD et hooks déterministes.
| Fichier | Versionné | Pourquoi |
|---|---|---|
.claude/settings.json |
Oui | Permissions et hooks de l'équipe, identiques pour tout le monde |
.claude/settings.local.json |
Non | Vos réglages de poste, dans .gitignore |
CLAUDE.md |
Oui | Les conventions du projet |
CLAUDE.local.md |
Non | Vos préférences sur ce projet, dans .gitignore |
.mcp.json |
Oui | Les serveurs d'outils dont le projet a besoin |
Note : Un
settings.jsonversionné qui contient des hooks n'est appliqué qu'après approbation du dossier au premier lancement interactif. Une session non approuvée ignore les entrées concernées et le signale au démarrage.
opus, sonnet, haiku et opusplan suivent la dernière version de chaque famille ; /effort règle séparément la profondeur de raisonnement, de low à max.curl ou irm) pose un binaire autonome ; claude --version et claude doctor vérifient l'installation.default à bypassPermissions ; Maj+Tab en change au cours de la session, --permission-mode au lancement./context dit ce qui occupe la fenêtre, /clear sert entre deux tâches et /compact pour continuer la même.CLAUDE.md est lu à chaque session dans quatre portées cumulatives ; /init en propose un premier jet à relire, /context confirme son chargement sous Memory files.TP associé : TP 1 : Prise en Main de Claude Code sur un Projet Existant
➡️ Module suivant : Prompt Engineering et Conception