Aller au contenu

Claude Code — Installation et customization sur Windows

Dernière mise à jour : 16 avril 2026.

Guide complet pour installer Claude Code sur Windows 11 (via un script automatisé ou la méthode officielle npm), puis le customiser à fond : settings, hooks, skills, subagents, slash commands, CLAUDE.md, mémoire, keybindings, serveurs MCP.

À quoi ça sert ?

Claude Code est le CLI officiel d'Anthropic : un agent Claude qui tourne dans le terminal, lit et édite les fichiers du projet, exécute des commandes, appelle des outils, et peut orchestrer du travail complexe sur un repo (refactor, tests, review, docs, déploiement). Il s'utilise comme un collègue développeur : on lui parle en langage naturel, il opère directement sur le système de fichiers avec un système de permissions granulaires.

Principales différences avec claude.ai en navigateur :

  • Accès local au code : lecture/écriture réelle des fichiers, exécution de scripts, git, tests.
  • Permissions explicites : chaque outil (Bash, Write, WebFetch...) est soumis à un système allow/ask/deny.
  • Extensible : hooks (avant/après chaque outil), skills (playbooks réutilisables), subagents spécialisés, serveurs MCP pour brancher Gmail, Slack, une base de données, etc.
  • Intégration éditeur : extensions VS Code et JetBrains, mais tout fonctionne aussi en terminal pur.

Ce guide cible développeurs / power-users déjà à l'aise avec le terminal, Node.js, JSON et Git.

Prérequis

  • Windows 10 ou 11 64 bits.
  • Node.js 20+ (le script d'install le gère, sinon winget install OpenJS.NodeJS.LTS).
  • Un terminal décent : Windows Terminal (pré-installé sur Windows 11, sinon winget install Microsoft.WindowsTerminal).
  • Un compte Anthropic (Claude.ai Pro/Max/Team, ou Claude Console avec facturation API). La connexion se fait à la première commande claude.
  • Git installé et configuré (winget install Git.Git), indispensable pour les projets versionnés.

WSL ou Windows natif ?

Claude Code fonctionne parfaitement en Windows natif depuis fin 2024. WSL reste intéressant pour les workflows très Unix (Makefile compliqué, outils POSIX), mais n'est plus requis. Ce guide cible le Windows natif.

Partie A — Installation

Deux chemins, selon les préférences :

Méthode Pour qui Ce qu'elle installe en plus du CLI
A1. Script automatisé Première install, veut tout prêt Node.js, police, profil Windows Terminal, icône, menu contextuel, raccourci Start
A2. npm manuel Déjà équipé, veut le strict minimum Rien — juste claude dans le PATH

A1 — Script automatisé (recommandé pour une fresh install)

Un script PowerShell tout-en-un, distribué sous forme d'archive ZIP :

Téléchargement

Contenu du ZIP :

Fichier Rôle
Install.bat Lance le script PowerShell (double-clic)
Uninstall.bat Retire les customisations (ne désinstalle pas Claude Code lui-même)
SetupClaudeCodeEnv.ps1 Le script principal, 7 étapes

Inspecter avant d'exécuter

Un script PowerShell récupéré sur le web mérite une lecture. SetupClaudeCodeEnv.ps1 est non-obfusqué, largement commenté, et modifie uniquement des emplacements utilisateur (jamais HKLM, jamais Program Files, pas d'élévation UAC). Ouvrir le fichier dans un éditeur avant de lancer Install.bat si un doute subsiste.

Ce que fait le script — les 7 étapes

  1. Node.js — installé via winget install OpenJS.NodeJS.LTS si absent.
  2. PATH utilisateur — ajoute %APPDATA%\npm (wrappers claude.cmd) et %USERPROFILE%\.local\bin (claude.exe).
  3. Claude Code CLI — npm install -g @anthropic-ai/claude-code.
  4. Police CaskaydiaCove Nerd Font — téléchargée depuis les releases officielles de nerd-fonts, installée pour l'utilisateur courant (aucun droit admin requis).
  5. Icône Claude — téléchargée puis convertie en .ico dans %USERPROFILE%\Pictures\Icons\claude.ico.
  6. Windows Terminal — ajoute un profil Claude Code (guid fixe {a1b2c3d4-e5f6-7890-abcd-ef1234567890}), deux thèmes Claude / Claude Theme, la police Nerd Font, et un script d'accueil RunClaude.ps1 dans le home.
  7. Menu contextuel + Start Menu — clic droit dans un dossier → « Ouvrir dans Claude Code CLI » (registre HKCU:\SOFTWARE\Classes\Directory\shell\ClaudeCLI), plus un raccourci Claude Code dans le menu Démarrer.

Fichiers créés / touchés

  • %USERPROFILE%\.claude\settings.json — créé avec {"model": "opus", "language": "French", "effortLevel": "high"} uniquement s'il n'existe pas (sinon laissé intact).
  • %USERPROFILE%\RunClaude.ps1 — bannière d'accueil lancée par le profil Windows Terminal.
  • %LOCALAPPDATA%\ClaudeCode\ — dossier de travail temporaire (téléchargements).
  • Sauvegarde settings.json.backup_<timestamp> du Windows Terminal avant modification.
  • Log détaillé à côté du script : ClaudeCodeSetup_YYYYMMDD_HHMMSS.log.

Lancer l'installation

  1. Télécharger le ZIP depuis le lien ci-dessus et l'enregistrer dans un dossier accessible, par exemple %USERPROFILE%\Desktop\.
  2. Clic droit → Extraire tout... (ne pas lancer les scripts depuis le ZIP ouvert, PowerShell a besoin d'un chemin disque réel).
  3. Double-cliquer sur Install.bat. Une fenêtre PowerShell s'ouvre, sept étapes défilent, chacune préfixée [+] (succès), [i] (info), [!] (warning) ou [x] (erreur).
  4. À la fin, le résumé indique les quatre manières de lancer Claude :
  5. Touche Windows → taper Claude → Entrée.
  6. Clic droit sur un dossier → « Ouvrir dans Claude Code CLI ».
  7. Windows Terminal → nouvel onglet Claude Code (dans la liste déroulante).
  8. N'importe quel terminal : claude.

Premier lancement

Au premier claude, une URL OAuth s'ouvre dans le navigateur pour la connexion au compte Anthropic. Après authentification, retour au terminal : invite > prêt à recevoir une consigne.

Vérifier que tout marche

node --version        # v20.x ou supérieur
claude --version      # 2.x
claude doctor         # diagnostic complet du setup

claude doctor valide la présence des dépendances, des fichiers de config, et les chemins PATH. En cas de pépin, consulter le log .log généré à côté de Install.bat.

Désinstaller

Double-cliquer sur Uninstall.bat. Ce que le script retire :

  • Entrées de registre du menu contextuel.
  • Raccourci Start Menu.
  • Profil et thèmes Claude de Windows Terminal.
  • %USERPROFILE%\RunClaude.ps1 et %LOCALAPPDATA%\ClaudeCode\.

Ce qu'il ne touche pas (volontairement, pour préserver les données personnelles) :

  • Node.js (à désinstaller via winget uninstall OpenJS.NodeJS.LTS si souhaité).
  • Claude Code CLI (npm uninstall -g @anthropic-ai/claude-code).
  • La police CaskaydiaCove Nerd Font (retirable via Paramètres Windows → Polices).
  • Le dossier %USERPROFILE%\.claude\ (settings, sessions, skills, agents, mémoire).

A2 — Installation manuelle via npm

Pour qui a déjà son terminal, sa police et son Node.js :

# Vérifier Node.js (20+ requis)
node --version

# Installer Claude Code globalement
npm install -g @anthropic-ai/claude-code

# Vérifier
claude --version
claude doctor

Le binaire atterrit dans %APPDATA%\npm\claude.cmd (wrapper) et le vrai claude.exe dans %USERPROFILE%\.local\bin\. S'assurer que ces deux chemins sont dans le PATH utilisateur.

Curl one-liner officiel

Anthropic propose aussi un installeur curl — pour Windows, passer par npm reste plus simple et plus prévisible.

Partie B — Customization

Toute la customization passe par le dossier %USERPROFILE%\.claude\ (portée User, tous projets) et .claude\ à la racine du projet (portée Project, partagée avec l'équipe via git).

B1 — Les fichiers de configuration et leur hiérarchie

Claude Code utilise un système de scopes classés par priorité :

Scope Emplacement Affecte Committed ?
Managed Registre Windows / C:\Program Files\ClaudeCode\managed-settings.json Tous les utilisateurs de la machine Oui (déployé par IT)
User %USERPROFILE%\.claude\settings.json L'utilisateur, tous projets Non
Project .claude/settings.json à la racine du repo L'équipe sur ce repo Oui
Local .claude/settings.local.json L'utilisateur, ce projet seulement Non (gitignoré auto)

Ordre de résolution (du plus fort au plus faible) : Managed → flags CLI → Local → Project → User.

Fichier ~/.claude.json

À ne pas confondre avec settings.json. ~/.claude.json stocke les préférences UI (thème, mode éditeur), la session OAuth, les serveurs MCP en portée user et local, et du cache projet. Ne pas l'éditer à la main — Claude le réécrit, et une clé inconnue provoque une erreur de schéma. Le modifier via /config dans une session.

B2 — settings.json — structure et clés principales

Fichier JSON strict. Squelette typique (projet) :

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "model": "claude-opus-4-6",
  "effortLevel": "high",
  "language": "french",
  "permissions": {
    "allow": [
      "Bash(npm run test *)",
      "Bash(npm run lint)",
      "Bash(git diff:*)",
      "Read(~/.zshrc)"
    ],
    "ask": [
      "Bash(git push *)"
    ],
    "deny": [
      "Bash(curl *)",
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "WebFetch"
    ],
    "defaultMode": "default"
  },
  "env": {
    "NODE_ENV": "development"
  },
  "includeCoAuthoredBy": true,
  "cleanupPeriodDays": 30
}

La ligne $schema active l'autocomplétion et la validation dans VS Code et tout éditeur compatible JSON Schema.

Clés utiles (liste non exhaustive, voir documentation officielle pour l'ensemble) :

Clé Rôle
model Modèle par défaut ("claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5"...)
effortLevel "low" / "medium" / "high" (et "max" sur Opus 4.6)
language Langue de réponse ("french", "spanish", "japanese"...)
permissions Voir ci-dessous
env Variables d'environnement injectées à chaque session
hooks Voir section B4
statusLine Commande custom affichée en bas du terminal
outputStyle Style de réponse ("Explanatory", "Concise"...)
cleanupPeriodDays Durée de rétention des transcripts (défaut 30 j)
enabledMcpjsonServers Serveurs MCP du projet auto-approuvés
includeCoAuthoredBy Trailer Co-Authored-By: Claude dans les commits (défaut true)
attribution Personnaliser les attributions commit/PR (remplace includeCoAuthoredBy)

B3 — Permissions (allow / ask / deny)

Chaque règle suit le format Tool ou Tool(specifier). Les règles sont évaluées dans l'ordre : deny d'abord, puis ask, puis allow. La première qui matche gagne.

Exemples courants :

{
  "permissions": {
    "allow": [
      "Read",                          // Tout Read
      "Bash(npm run *)",               // Seulement "npm run ..."
      "Bash(git diff:*)",              // Git diff et sous-commandes
      "Edit(src/**)",                  // Édition limitée à src/
      "WebFetch(domain:github.com)"    // Seulement github.com
    ],
    "ask": [
      "Bash(git push *)",              // Demander avant de push
      "Bash(rm *)"
    ],
    "deny": [
      "Read(./.env)",                  // Jamais lire .env
      "Read(./secrets/**)",
      "Bash(curl *)",                  // Pas de curl ad hoc
      "WebFetch(domain:internal.corp)" // Pas vers l'intranet
    ],
    "defaultMode": "default"           // ou "acceptEdits", "plan", "auto"...
  }
}

Patterns Bash : attention aux limites

Les patterns Bash(git *) font du matching sur la ligne complète telle que Claude l'émet. Un utilisateur motivé peut contourner via sh -c '...'. Les règles de permission sont un garde-fou, pas un sandbox — pour isoler vraiment, activer "sandbox": { "enabled": true } (macOS/Linux/WSL, pas dispo en Windows natif à date).

Modes de permission

Cyclables via Shift+Tab dans une session interactive :

  • default : Claude demande pour chaque action risquée.
  • acceptEdits : accepte auto les écritures de fichiers.
  • plan : mode plan (lecture seule, produit un plan avant d'agir).
  • auto : classifier automatique (accepte/refuse selon contexte).
  • bypassPermissions : tout autoriser (⚠️ pour dev isolé uniquement).

B4 — Hooks

Les hooks sont des scripts déclenchés par Claude Code à des moments précis de son cycle de vie. Exemples d'usage : lancer le linter après chaque Write, bloquer un rm -rf, injecter du contexte git dans chaque nouvelle session, faire sonner l'ordi quand Claude a fini.

Events disponibles

Ordre du cycle de vie :

Event Moment Bloquable
SessionStart Début / reprise de session Non
UserPromptSubmit Juste avant que Claude traite le prompt Oui
PreToolUse Juste avant l'exécution d'un outil Oui
PostToolUse Après succès d'un outil Non
PostToolUseFailure Après échec d'un outil Non
Notification Notifications (permission, idle...) Non
SubagentStart / SubagentStop Lancement / fin d'un subagent Partiel
Stop Claude termine une réponse Oui
PreCompact / PostCompact Avant/après compaction auto du contexte Partiel
SessionEnd Fin de session Non

Structure JSON

Les hooks se déclarent dans settings.json :

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "powershell.exe -NoProfile -File C:\\Users\\<user>\\.claude\\hooks\\guard-rm.ps1",
            "timeout": 30
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint --silent"
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "powershell.exe -c \"[console]::beep(800, 200)\""
          }
        ]
      }
    ]
  }
}

Protocole de communication

  • Input : JSON via stdin avec session_id, cwd, tool_name, tool_input, etc.
  • Output :
  • exit 0 → succès. Si la sortie stdout est du JSON, Claude parse le champ hookSpecificOutput.
  • exit 2 → blocage. Le hook refuse l'action, stderr est renvoyé à Claude.
  • Autre code → warning non bloquant, stderr affiché à l'utilisateur.

Exemple de script guard-rm.ps1 qui bloque les rm -rf destructeurs :

$input = [Console]::In.ReadToEnd() | ConvertFrom-Json
$cmd = $input.tool_input.command

if ($cmd -match 'rm\s+-rf\s+[/~]') {
    @{
        hookSpecificOutput = @{
            hookEventName       = "PreToolUse"
            permissionDecision  = "deny"
            permissionDecisionReason = "rm -rf sur / ou ~ interdit"
        }
    } | ConvertTo-Json -Depth 5
    exit 0
}
exit 0

Scope des hooks

Les hooks définis en User scope (~/.claude/settings.json) s'exécutent sur tous les projets — donc attention à ne pas y mettre un script qui suppose un package.json à la racine. Préférer le scope Project pour les hooks spécifiques à un repo.

B5 — Skills (et slash commands)

Depuis octobre 2025, les slash commands ont fusionné avec les skills. Un fichier .claude/skills/deploy/SKILL.md et un .claude/commands/deploy.md produisent tous deux la commande /deploy. La forme skill est recommandée car elle supporte des fichiers annexes.

Structure d'un skill

.claude/skills/
└── commit/
    ├── SKILL.md          (requis — instructions + frontmatter)
    ├── examples.md       (optionnel — exemples)
    └── scripts/
        └── pre-commit.sh (optionnel — script embarqué)

Exemple minimal SKILL.md :

---
name: commit
description: Stage and commit current changes with conventional message
disable-model-invocation: true
allowed-tools: Bash(git add *) Bash(git commit *) Bash(git status *) Bash(git diff *)
---

Commit les changements en cours :

1. `git status` pour voir ce qui est modifié.
2. `git diff --cached` et `git diff` pour comprendre le contenu.
3. Écrire un message au format `<scope>: <résumé impératif>`.
4. `git commit` avec le message.
5. Afficher `git status` final.

Appel : taper /commit dans la session. Les arguments sont accessibles via $ARGUMENTS, $0, $1, etc.

Clés frontmatter utiles :

Clé Rôle
name Nom du slash command (défaut : nom du dossier)
description Aide Claude à décider quand l'utiliser automatiquement
disable-model-invocation true pour que seul l'utilisateur puisse le déclencher
user-invocable false pour qu'il n'apparaisse pas dans le menu /
allowed-tools Outils pré-autorisés quand le skill est actif
model / effort Modèle et effort spécifiques
context: fork + agent: Explore Lance le skill dans un subagent isolé
argument-hint Hint d'autocomplétion, ex. [issue-number]

Portée

Emplacement Portée
~/.claude/skills/<name>/SKILL.md Personnelle, tous projets
.claude/skills/<name>/SKILL.md Ce projet (commité avec le repo)

Claude Code watch ces dossiers : l'ajout ou la modification d'un skill est pris en compte dans la session courante sans redémarrer.

B6 — Subagents

Un subagent est un agent spécialisé avec son propre system prompt, son propre jeu d'outils, son propre modèle, et son contexte isolé. Claude Code délègue à un subagent quand la tâche matche sa description.

Built-in : Explore, Plan, general-purpose (+ statusline-setup, claude-code-guide).

Créer un subagent custom

Interactif : /agents → Create new agent.

Manuel : fichier Markdown dans .claude/agents/<name>.md (projet) ou ~/.claude/agents/<name>.md (user) :

---
name: security-reviewer
description: Audit de sécurité sur les changements en cours. Utiliser après une modif qui touche auth, input validation ou dépendances.
tools: Read, Grep, Glob, Bash
model: sonnet
color: red
---

Tu es un auditeur sécurité senior. Pour chaque fichier modifié :

1. Repérer les patterns OWASP Top 10 (SQLi, XSS, IDOR, desérialisation...).
2. Vérifier la gestion des erreurs (pas de leak d'info).
3. Contrôler les dépendances (`package.json`, `requirements.txt`).

Retourner un rapport Markdown structuré :
- `## Findings critiques`
- `## Findings moyens`
- `## Recommandations`

Garder le rapport sous 500 mots.

Appel : « lance l'agent security-reviewer sur le diff en cours ». Claude délègue automatiquement quand le prompt utilisateur matche la description.

Clé frontmatter Rôle
name Identifiant (lowercase, tirets)
description Critère d'invocation automatique
tools Liste d'outils autorisés (défaut : tous)
model opus, sonnet, haiku ou ID exact
color Pastille UI
permissionMode Override du mode de permission
hooks Hooks scopés au subagent
skills Skills préchargés au démarrage

Quand créer un subagent plutôt qu'un skill ?

Un skill est un playbook injecté dans le contexte courant. Un subagent tourne dans un contexte séparé et ne renvoie qu'un résumé. Préférer un subagent dès qu'une tâche génère beaucoup de résultats intermédiaires qu'on ne veut pas polluer la conversation principale (recherche massive, analyse de logs, exploration de codebase).

B7 — CLAUDE.md hiérarchiques

CLAUDE.md est le fichier de contexte projet automatiquement chargé par Claude au démarrage. Il contient les conventions du repo, les commandes utiles, les conventions de commit, tout ce qu'un nouveau contributeur humain devrait savoir.

Hiérarchie de chargement (tout est concaténé) :

~/.claude/CLAUDE.md              ← préférences perso
<racine-repo>/CLAUDE.md          ← conventions du projet (committé)
<racine-repo>/CLAUDE.local.md    ← local non committé
<sous-dossier>/CLAUDE.md         ← conventions spécifiques au sous-dossier

Quand Claude travaille dans packages/frontend/, il charge automatiquement packages/frontend/CLAUDE.md en plus du CLAUDE.md racine. Utile pour un monorepo.

Exemple de CLAUDE.md racine :

# Projet Saccodex

Site MkDocs Material déployé sur Cloudflare Workers. Source unique de vérité dans ce repo.

## Conventions

- Français partout (prose, commits, admonitions).
- kebab-case sans accent pour les noms de fichiers `.md`.
- Frontmatter obligatoire (voir README.md).
- Commits : `docs(<scope>): <verbe impératif>`.

## Commandes utiles

- `mkdocs serve` : preview locale.
- `pip install -r requirements.txt` : installer les deps.

## Identité git

Toujours commiter avec :

    git -c user.name="BurN-30" -c user.email="saccol.nathan@yahoo.fr" commit ...

B8 — Mémoire auto

Claude Code dispose d'un système de mémoire persistante entre sessions : ~/.claude/projects/<hash-du-projet>/memory/. Il y stocke des notes typées (user, feedback, project, reference) découvertes au fil des conversations. À la session suivante, MEMORY.md est automatiquement injecté dans le contexte.

Ne pas gérer ce dossier à la main. Claude l'alimente tout seul à partir des interactions. Pour supprimer une mémoire obsolète, le dire explicitement (« oublie cette note sur X »).

Clé settings associée :

{ "autoMemoryDirectory": "~/mon-dossier-memory" }

Par défaut, le chemin est déduit du projet courant.

B9 — Serveurs MCP (Model Context Protocol)

MCP est le protocole standardisé d'Anthropic pour brancher des outils externes à Claude (Gmail, Slack, Postgres, Playwright, Notion...). Un serveur MCP expose des tools, des ressources et des prompts que Claude peut invoquer.

Ajouter un serveur MCP

En ligne de commande (recommandé) :

# Serveur stdio (binaire local)
claude mcp add playwright -- npx @playwright/mcp@latest

# Serveur HTTP distant
claude mcp add --transport http notion https://mcp.notion.com/mcp

# Serveur SSE
claude mcp add --transport sse linear https://mcp.linear.app/sse

Portée :

Flag Stockage Portée
--scope user ~/.claude.json Tous projets de l'utilisateur
--scope local (défaut) ~/.claude.json (section projet) Ce projet, cet utilisateur
--scope project .mcp.json à la racine Partagé avec l'équipe via git

Via .mcp.json à la racine du projet (portée équipe) :

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

Au premier lancement dans le projet, Claude demande d'approuver chaque serveur. Pour auto-approuver :

// .claude/settings.json
{
  "enabledMcpjsonServers": ["playwright", "github"]
}

Exemples courants

  • Gmail / Google Calendar / Drive : intégrations officielles, OAuth via claude.ai.
  • Playwright : pilotage navigateur pour tests E2E ou QA UI.
  • GitHub : lecture/édition issues et PRs.
  • Postgres / SQLite : requêtes en lecture sur une base.

Différence avec Claude Desktop

Les serveurs MCP configurés dans Claude Desktop (claude_desktop_config.json) ne sont pas partagés avec Claude Code. Chaque app gère son propre registre. Pour utiliser les deux, configurer des deux côtés.

B10 — Keybindings

Claude Code permet de redéfinir ses raccourcis clavier dans ~/.claude/keybindings.json. Usage principal : assigner des chords à des actions fréquentes (submit, cancel, toggle mode, insertion de snippets).

Format minimal :

{
  "keybindings": [
    { "key": "ctrl+s", "command": "submit" },
    { "key": "ctrl+shift+p", "command": "open-command-palette" },
    { "key": "ctrl+k ctrl+c", "command": "clear-context" }
  ]
}

Dans une session, taper /keybindings pour ouvrir l'interface de personnalisation guidée, plus sûre que l'édition manuelle (elle liste les command disponibles et détecte les conflits).

B11 — Status line

Pour afficher en permanence le modèle courant, le dossier, la branche git, le token usage, etc. :

{
  "statusLine": {
    "type": "command",
    "command": "%USERPROFILE%\\.claude\\statusline.ps1"
  }
}

Le script reçoit du JSON sur stdin (session info) et doit écrire une ligne courte sur stdout.

Ou utiliser le skill bundled /statusline (subagent statusline-setup) qui génère le script interactivement.

Dépannage

claude introuvable après install

  • Fermer et rouvrir le terminal (le PATH utilisateur ne se propage pas à la session en cours).
  • Vérifier echo %PATH% : %APPDATA%\npm et %USERPROFILE%\.local\bin doivent être présents.
  • Lancer claude doctor dans un nouveau terminal pour un diagnostic.

Erreur EACCES ou EPERM au npm install -g

Windows ne nécessite pas sudo, mais le dossier %APPDATA%\npm peut être bloqué par l'antivirus. Exclure %APPDATA%\npm et %LOCALAPPDATA%\ClaudeCode des scans temps réel.

Hooks qui ne se déclenchent pas

  • Vérifier le scope : un hook en .claude/settings.json ne s'applique que dans ce repo.
  • Lancer claude --debug pour voir les hooks évalués.
  • disableAllHooks: true quelque part dans la hiérarchie bloque tout (utile en debug mais facile à oublier).

Skill pas détecté par l'autocomplétion /

  • Le frontmatter YAML doit être entre --- en haut du fichier, sans BOM.
  • Le dossier doit bien être .claude/skills/<name>/SKILL.md (nom de fichier exact, majuscules incluses).
  • Redémarrer Claude Code si le dossier top-level .claude/skills/ n'existait pas au lancement.

Serveur MCP qui ne se connecte pas

  • claude mcp list pour voir l'état.
  • claude mcp get <name> pour les logs de démarrage.
  • Vérifier que le binaire (ex. npx) est dans le PATH de la session Claude, pas seulement du terminal utilisateur.

Police bizarre dans Windows Terminal après install

La CaskaydiaCove Nerd Font est installée pour l'utilisateur courant. Si elle n'apparaît pas, ouvrir Paramètres Windows → Polices et chercher Caskaydia. En cas d'absence, re-télécharger manuellement depuis nerdfonts.com.

Windows Terminal ne liste pas le profil Claude Code

Le script modifie settings.json de Windows Terminal. S'il a été ouvert pendant l'install, le fermer et le relancer. Une sauvegarde horodatée (settings.json.backup_...) est faite avant modification dans le même dossier.

Liens utiles