Claude Code 2026 : guide complet — installation, MCP, hooks et workflows

Ce que vous allez apprendre : installer et authentifier Claude Code, maîtriser les slash commands et le fichier CLAUDE.md, connecter des outils externes via MCP (GitHub, bases de données, navigateur), automatiser vos workflows avec les hooks, et comprendre quand choisir Claude Code plutôt que Cursor, Windsurf ou GitHub Copilot.

TL;DR — L'essentiel en 30 secondes

• Installer : npm install -g @anthropic-ai/claude-code (Node.js 18+)
• Lancer : claude dans votre projet, puis /init pour créer le CLAUDE.md
• Mode non-interactif : claude -p "..." pour CI/CD et scripts
• Étendre : MCP pour connecter GitHub/DB/browser, hooks pour automatiser lint et tests
• Positionnement : tâches longues autonomes — complément idéal de Cursor, pas un remplaçant

Terminal-first · CLI natif Claude Sonnet 4 / Opus 4 macOS · Linux · Windows natif ou WSL2

# Vérifier la version de Node.js (18+ requis)
node --version

# Installation globale
npm install -g @anthropic-ai/claude-code

# Vérification de l'installation
claude --version

# Alternative sans installation globale (one-shot)
npx @anthropic-ai/claude-code

macOS avec Homebrew : si vous avez des problèmes de permissions avec npm global, installez d'abord Node.js via brew install node puis relancez l'installation. Évitez d'utiliser sudo npm install -g — préférez configurer le prefix npm dans votre répertoire utilisateur.

Plateformes supportées

# Dans ~/.bashrc ou ~/.zshrc
export ANTHROPIC_API_KEY="sk-ant-api03-..."

# Vérification — Claude Code lit cette variable au démarrage
claude --version   # doit afficher la version sans erreur d'auth

# Pour CI/CD : passer la clé via l'environnement du pipeline
ANTHROPIC_API_KEY=$SECRET claude -p "résume ce diff" < diff.txt

Sécurité : ne committez jamais votre clé API dans le dépôt. Ajoutez .env et *.env à votre .gitignore. En production, utilisez les secrets de votre gestionnaire (GitHub Secrets, Vault, AWS Secrets Manager).

Comparaison des modes de facturation

Mode	Prix	Idéal pour
API Sonnet	$3 input / $15 output / M tokens	Usage intensif, CI/CD, meilleur rapport qualité/prix
API Opus	$5 input / $25 output / M tokens	Tâches très complexes, raisonnement avancé
Pro (20$/mois)	Quota mensuel inclus	Usage modéré, découverte
Max (100$ ou 200$/mois)	Quota étendu inclus	Usage quotidien intensif, accès Opus, limites plus hautes

# ── Mode interactif (session REPL) ──────────────────────────
claude                   # Démarre une session interactive
claude --model opus      # Force le modèle Opus (le plus puissant)
claude --model haiku     # Modèle léger et rapide

# ── Mode non-interactif (--print / -p) ──────────────────────
claude -p "explique cette fonction"          # One-shot, pas d'interaction
claude --print "génère un README pour ce projet"

# ── Pipe et stdin ───────────────────────────────────────────
cat error.log | claude -p "qu'est-ce qui ne va pas ici ?"
git diff HEAD~1 | claude -p "résume ces changements en français"

# ── Sortie structurée ───────────────────────────────────────
claude -p "liste les fonctions de ce fichier" --output-format json
claude -p "..." --output-format stream-json  # Streaming JSON

# ── Limiter les outils disponibles ──────────────────────────
claude --allowedTools "Read,Grep"            # Lecture seule
claude --allowedTools "Read,Edit,Write,Bash" # Plein accès standard

Conseil CI/CD : utilisez toujours --print dans les pipelines automatisés. Sans ce flag, Claude Code attend une interaction et bloque indéfiniment. Combinez avec --output-format json pour parser la sortie dans vos scripts Bash ou Python.

Commande	Description	Quand l'utiliser
/help	Affiche l'aide complète et les raccourcis	Découverte, rappel des options
/clear	Réinitialise le contexte de conversation	Nouvelle tâche sans rapport avec la précédente
/compact	Compresse le contexte (résumé + élagage)	Quand la fenêtre de contexte est proche du maximum
/init	Génère un fichier CLAUDE.md pour le projet courant	Première configuration d'un nouveau projet
/memory	Affiche et gère la mémoire persistante	Vérifier ce que Claude retient entre sessions
/config	Affiche et modifie la configuration courante	Changer de modèle, ajuster les permissions
/doctor	Diagnostic de l'environnement et des dépendances	Dépannage, problèmes d'installation
/cost	Affiche les tokens consommés et le coût estimé	Suivi budgétaire, optimisation
/review	Revue de code des changements courants	Avant un commit ou une PR

# Structure d'une commande personnalisée
.claude/
  commands/
    review-pr.md    # accessible via /review-pr
    add-tests.md    # accessible via /add-tests
    deploy-check.md # accessible via /deploy-check

# Exemple : .claude/commands/add-tests.md
Analyse le fichier courant et génère des tests unitaires exhaustifs :
- Couvre tous les cas nominaux et les cas limites
- Utilise le framework de test déjà présent dans le projet
- Ajoute les tests dans le fichier de test correspondant
- Vise une couverture de 100% des branches

# En session interactive, dans la racine du projet
/init

# Claude Code génère un CLAUDE.md avec :
# - Description du projet et de la stack
# - Commandes essentielles (build, test, lint, dev)
# - Architecture détectée
# - Conventions de nommage observées

# Projet : API de gestion d'inventaire

## Stack technique
- FastAPI + Python 3.12
- PostgreSQL 16 (SQLAlchemy ORM)
- Tests : pytest + httpx
- Linter : ruff + mypy strict

## Commandes essentielles
```bash
make dev      # Lance le serveur de développement
make test     # Lance la suite de tests complète
make lint     # ruff check + mypy
make migrate  # Applique les migrations Alembic
```

## Conventions
- Toutes les routes dans src/routes/, un fichier par ressource
- Models Pydantic dans src/schemas/, SQLAlchemy dans src/models/
- Pas de logique métier dans les routes — tout dans src/services/
- Type hints obligatoires sur toutes les fonctions publiques

## À éviter
- Ne pas utiliser requests (httpx uniquement)
- Ne pas modifier les migrations existantes
- Ne pas committer de fichiers .env

Conseil : gardez le CLAUDE.md concis. Un fichier de 200 lignes sera entièrement lu à chaque session ; un fichier de 2 000 lignes consomme des tokens et dilue l'attention. Documentez le pourquoi et le où, pas le comment (le code lui-même exprime ça).

// ~/.claude/settings.json — configuration globale
{
  "model": "sonnet",
  "permissions": {
    "allow": [
      "Bash(git:*)",          // Autorise toutes les commandes git
      "Bash(npm:*)",          // Autorise toutes les commandes npm
      "Read(**)",             // Lecture de tous les fichiers
      "Edit(**)",             // Édition sans confirmation
      "Write(**)"             // Création de fichiers
    ],
    "deny": [
      "Bash(rm -rf:*)",       // Interdit les suppressions récursives
      "Bash(curl:*)"          // Interdit les requêtes réseau depuis Bash
    ]
  },
  "env": {
    "NODE_ENV": "development"
  }
}

Sécurité des permissions : les règles allow listent des actions que Claude Code peut effectuer sans demander de confirmation. Soyez conservatif au départ — ajoutez des permissions au fur et à mesure selon votre niveau de confiance dans les actions de Claude sur votre projet. Sur un projet de production, évitez d'autoriser les commandes Bash au niveau global.

Pour aller plus loin sur MCP : consultez notre article dédié MCP — le standard Anthropic qui connecte les LLMs au monde réel pour l'architecture complète du protocole.

# ── Serveur local (processus stdio) ─────────────────────────
claude mcp add github-mcp -- npx @modelcontextprotocol/server-github

# ── Serveur distant (SSE / HTTP) ────────────────────────────
claude mcp add mon-service --transport sse https://mon-mcp.example.com/sse

# ── Scope : user (global) ou project (.claude/settings.json) ─
claude mcp add --scope project mon-db -- npx @modelcontextprotocol/server-postgres

# ── Gestion ─────────────────────────────────────────────────
claude mcp list              # Lister les serveurs configurés
claude mcp remove github-mcp # Supprimer un serveur
claude mcp get github-mcp    # Détails d'un serveur

Serveur	Package	Capacités
GitHub	@modelcontextprotocol/server-github	Lecture/création d'issues, PRs, code review, recherche
PostgreSQL	@modelcontextprotocol/server-postgres	Requêtes SQL, exploration du schéma, lecture de données
Filesystem	@modelcontextprotocol/server-filesystem	Accès étendu au système de fichiers (chemins configurables)
Puppeteer	@modelcontextprotocol/server-puppeteer	Navigation web, captures d'écran, scraping, test E2E
Slack	@modelcontextprotocol/server-slack	Lecture des canaux, envoi de messages, recherche
SQLite	@modelcontextprotocol/server-sqlite	Requêtes et modification de bases SQLite locales

# 1. Créer un Personal Access Token GitHub (PAT)
#    Permissions nécessaires : repo, issues, pull_requests

# 2. Exporter la variable d'environnement
export GITHUB_PERSONAL_ACCESS_TOKEN="ghp_..."

# 3. Ajouter le serveur MCP GitHub
claude mcp add github -- npx -y @modelcontextprotocol/server-github

# 4. En session Claude Code, vous pouvez maintenant :
# "liste les issues ouvertes du repo anthropics/claude-code"
# "crée une PR pour cette branche avec ce résumé"
# "quels fichiers ont été modifiés dans la PR #142 ?"

// .claude/settings.json
{
  "hooks": {
    "PostToolUse": [
      {
        // Lance ruff après chaque modification de fichier Python
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path // empty' | grep -q '\\.py$' && ruff check --fix \"$( jq -r '.tool_input.file_path' )\" || true"
          }
        ]
      },
      {
        // Lance les tests après modification de fichiers de test
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path // empty' | grep -q 'test_' && pytest --tb=short -q || true"
          }
        ]
      }
    ],
    "Stop": [
      {
        "matcher": ".*",
        "hooks": [
          {
            "type": "command",
            // Notification macOS en fin de tâche longue
            "command": "osascript -e 'display notification \"Claude Code a terminé\" with title \"DEV\"' 2>/dev/null || true"
          }
        ]
      }
    ]
  }
}

Mécanisme : Claude Code passe les informations sur l'action (outil utilisé, fichier modifié, résultat) au hook via stdin au format JSON. Le hook lit ce JSON avec jq ou n'importe quel outil de parsing. Un code de retour 0 laisse Claude Code continuer ; un code non-zéro interrompt l'action (utile pour les hooks PreToolUse de validation).

# Lancer Claude Code dans la racine du projet
claude

> Le module `utils.database` doit être renommé en `core.db`.
> Mets à jour tous les imports dans le projet, adapte les tests
> et vérifie qu'aucune référence à l'ancien nom ne subsiste.
> Lance les tests à la fin pour confirmer que tout fonctionne.

# Claude Code va :
# 1. grep tous les imports de utils.database
# 2. Renommer le fichier
# 3. Modifier tous les fichiers concernés
# 4. Lancer pytest pour validation
# 5. Vous demander confirmation avant chaque étape risquée

> Lis l'issue #247 sur notre repo, identifie le commit
> qui a introduit la régression, et propose un correctif.

# Claude Code (avec MCP GitHub) va :
# 1. Lire l'issue #247 via le serveur MCP GitHub
# 2. Analyser le git log pour trouver le commit coupable
# 3. Lire les fichiers concernés
# 4. Écrire le correctif
# 5. Proposer de créer une PR avec description automatique

# .github/workflows/code-review.yml (extrait)
- name: Claude Code review
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
  run: |
    git diff origin/main...HEAD > diff.txt
    claude -p "Revue ce diff. Liste les problèmes potentiels,
    les améliorations de performance et les risques de sécurité.
    Formate la réponse en Markdown." \
      --output-format text \
      < diff.txt > review.md
    cat review.md

> Lis src/services/payment.py et génère des tests unitaires
> exhaustifs dans tests/test_payment.py.
> Couvre : cas nominaux, cas limites, erreurs de validation,
> et mock les appels à l'API Stripe externe.

# Claude Code lit le service, identifie les méthodes publiques,
# génère les tests avec pytest + unittest.mock, et lance
# pytest pour vérifier que les tests passent.

Critère	Claude Code	Cursor	Windsurf	GitHub Copilot
Interface	Terminal CLI	IDE (VS Code fork)	IDE (VS Code fork)	Extension IDE
Modèle principal	Claude Sonnet/Opus 4	Claude + GPT-4o	GPT-4o + Claude	GPT-4o
Tâches autonomes longues
Complétion inline
MCP natif	Natif	Variable	Variable
Hooks / Automatisation	Complet
Contexte projet (CLAUDE.md)	CLAUDE.md	.cursorrules	.windsurfrules	Limité
CI/CD (non-interactif)	--print			API seule
Prix	API usage-based	20$/mois	15$/mois	10$/mois
Courbe d'apprentissage	Modérée (CLI)	Faible (IDE)	Faible (IDE)	Très faible

Conseil pratique : beaucoup de développeurs utilisent Cursor + Claude Code ensemble — Cursor pour l'édition quotidienne et la complétion inline, Claude Code pour les refactorings lourds, la génération depuis des specs, ou les workflows automatisés via hooks et MCP. Les deux outils sont complémentaires, pas exclusifs.

Comment installer Claude Code ?

Installez Node.js 18+ puis exécutez npm install -g @anthropic-ai/claude-code. Vérifiez avec claude --version. Sur macOS, Homebrew simplifie la gestion de Node.js. Sur Windows 10+, Claude Code fonctionne nativement — WSL2 reste recommandé si vous utilisez des hooks shell Bash ou des outils Unix dans votre workflow.

Claude Code est-il gratuit ?

Non. Deux options : (1) clé API Anthropic avec facturation à l'usage — Sonnet : $3/$15 input/output par million de tokens, Opus : $5/$25 — ; (2) abonnement Claude.ai Pro (20$/mois) ou Max (100$ ou 200$/mois selon les limites d'usage) qui incluent un quota mensuel. Pour une utilisation quotidienne intensive, l'abonnement Max est souvent moins cher que la facturation API directe. Utilisez /cost en session pour suivre votre consommation.

Qu'est-ce que le fichier CLAUDE.md ?

Un fichier Markdown à la racine de votre projet que Claude Code charge automatiquement à chaque session comme contexte système. Documentez-y les commandes du projet (make test, npm run dev), les conventions de code, l'architecture, et les contraintes importantes. Utilisez /init pour le générer automatiquement depuis votre codebase.

Comment connecter Claude Code à GitHub ou une base de données ?

Via le protocole MCP. Pour GitHub : exportez votre Personal Access Token dans GITHUB_PERSONAL_ACCESS_TOKEN, puis exécutez claude mcp add github -- npx -y @modelcontextprotocol/server-github. Pour PostgreSQL : claude mcp add postgres -- npx -y @modelcontextprotocol/server-postgres postgresql://user:pass@localhost/dbname. Claude Code pourra ensuite lire vos issues, créer des PRs, requêter votre base, etc.

Claude Code vs Cursor : lequel choisir en 2026 ?

Claude Code est optimal pour les tâches autonomes longues : refactoring multi-fichiers, génération depuis des specs, pipelines CI/CD, workflows avec hooks et MCP. Il requiert d'être à l'aise dans le terminal. Cursor est une IDE complète avec complétion inline, diff en temps réel et Composer — idéal pour l'édition quotidienne. Les deux sont souvent utilisés ensemble : Cursor pour l'édition, Claude Code pour les transformations complexes.

Pour démarrer : installez Claude Code (npm install -g @anthropic-ai/claude-code), lancez claude dans un projet existant, tapez /init pour générer le CLAUDE.md, puis demandez-lui de résumer l'architecture du projet. En 10 minutes vous aurez une idée précise de ce que l'outil peut faire sur votre codebase.

Pour aller plus loin, lisez notre article sur le protocole MCP pour comprendre comment étendre Claude Code, et notre guide sur les agents IA en 2026 pour situer Claude Code dans le paysage plus large des agents autonomes.

Articles liés