Documentation interne

Claude Code —
Guide de personnalisation avancée

Les mécanismes de configuration pour adapter Claude Code à votre projet, et les pratiques d'équipe issues de nos retours d'expérience (réunion développeurs du 26/06/2026).

Mis à jour juillet 2026  ·  lajungle.fr
CLAUDE.md
Skills
Hooks
MCP
Commands
Agents
Bonnes pratiques
Contexte
Permissions
Playwright
Confidentialité

Structure des fichiers

.claude/ ├── settings.json # hooks, MCP, permissions ├── settings.local.json # config locale (ne pas commiter) ├── skills/ # *.md — savoir-faire invocables ├── commands/ # *.md — slash commands réutilisables └── agents/ # types d'agents personnalisés CLAUDE.md # instructions projet (racine) ~/.claude/CLAUDE.md # instructions globales utilisateur

CLAUDE.md

Instructions contextuelles

Le fichier CLAUDE.md est chargé automatiquement par Claude Code à chaque session. Il joue le rôle des custom instructions de Copilot, mais avec une portée hiérarchique basée sur l'emplacement des fichiers plutôt que sur des globs.

↑ Copilot : applyTo glob — Claude : hiérarchie de répertoires

Portée et priorité

Emplacement Portée Cas d'usage
~/.claude/CLAUDE.md Tous les projets Préférences personnelles, style de réponse
CLAUDE.md (racine) Projet entier Conventions, stack, architecture globale
src/api/CLAUDE.md Fichiers dans ce dossier Instructions spécifiques à un domaine

Imports avec @

Un CLAUDE.md peut inclure d'autres fichiers via la directive @, ce qui permet de découper les instructions par thème.

CLAUDE.md
# Conventions du projet

@.claude/conventions/typescript.md
@.claude/conventions/api.md
@.claude/conventions/tests.md

## Contexte général
Stack : Next.js 15, tRPC, Drizzle ORM, PostgreSQL.
Toujours typer explicitement les retours de fonctions.
Préférer les Server Components sauf si l'interactivité l'exige.

Contrairement à Copilot, il n'y a pas de frontmatter YAML. Le fichier est du Markdown pur. La portée est déterminée uniquement par l'emplacement dans l'arborescence.

Skills

Savoir-faire spécialisé

Les skills encapsulent un domaine d'expertise et sont invoqués automatiquement par Claude quand la description correspond au contexte, ou manuellement via une commande slash.

Emplacement

.claude/skills/nom-du-skill.md

Structure

.claude/skills/api-rest.md
---
name: api-rest
description: "Conception REST : nommage des routes, versioning,
  pagination, gestion d'erreurs RFC 7807, OpenAPI."
whenToUse: "Lorsqu'on crée ou révise des endpoints API."
---

# Expertise API REST
Contenu décrivant le domaine : conventions, exemples,
anti-patterns à éviter, décisions architecturales...

La qualité du champ description est déterminante. Plus elle contient de mots-clés précis, plus Claude invoquera le skill de manière autonome au bon moment.

Hooks

Déclencheurs automatiques

Les hooks exécutent des commandes shell en réaction aux événements de Claude Code. Ils sont configurés dans .claude/settings.json.

↑ Copilot : hook.json séparé — Claude : dans settings.json avec matcher

Événements disponibles

UserPromptSubmit
Avant l'envoi d'un message
PreToolUse
Avant l'exécution d'un outil
PostToolUse
Après l'exécution d'un outil
Stop
Quand Claude a terminé une tâche
SubagentStop
Quand un sous-agent se termine
Notification
Sur notification Claude Code

Configuration

.claude/settings.json
{
  "hooks": {
    "UserPromptSubmit": [
      {
        "matcher": "",            // "" = toujours
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint --silent"
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",        // matcher sur le nom de l'outil
        "hooks": [
          {
            "type": "command",
            "command": "echo 'running shell command'"
          }
        ]
      }
    ]
  }
}
!

Préférer des commandes rapides (linting, formatage). Éviter les opérations longues dans les hooks — elles bloquent l'interaction.

MCP

Model Context Protocol

Le protocole MCP connecte Claude à des outils et services externes. La configuration se fait dans .claude/settings.json (projet) ou ~/.claude/settings.json (global).

Serveurs populaires

GitHub
Issues, PRs, repos — accès authentifié à l'API GitHub
Filesystem
Lecture/écriture sur des chemins autorisés du système
PostgreSQL
Requêtes SQL en lecture sur une base de données
Brave Search
Recherche web depuis Claude
Slack
Lecture de canaux, envoi de messages

Configuration

.claude/settings.json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
               "${DATABASE_URL}"]
    }
  }
}
!

Ne jamais écrire de tokens ou mots de passe directement dans settings.json. Toujours utiliser des variables d'environnement. Ajouter .claude/settings.local.json au .gitignore pour les surcharges locales sensibles.

Retour d'expérience : les MCP de « mémoire » sont peu performants pour conserver le contexte entre sessions. Préférer des fichiers Markdown versionnés dans le repo (notes, plans, états des lieux) — voir la section Gestion du contexte.

Commands

Slash commands réutilisables

Les commandes slash sont des templates de prompts invocables via /nom dans le chat. Équivalent des Prompt Files de Copilot.

Emplacement

.claude/commands/nom.md

Structure

.claude/commands/create-component.md
---
description: "Crée un composant React selon le design system"
---

Crée un composant React nommé $ARGUMENTS.

Respecte les conventions de CLAUDE.md.
Utilise les tokens du design system dans src/tokens.ts.
Génère le fichier composant et son test unitaire associé.

Structure attendue :
- Props typées explicitement
- Storybook story si applicable
- Export nommé (pas default)

Variables disponibles

VariableValeur injectée
$ARGUMENTS Texte saisi après /commande
Référence fichier Utiliser #fichier.ts dans le chat pour attacher un fichier

Invocation : taper / dans le chat Claude Code pour afficher toutes les commandes disponibles du projet.

Agents

Modes conversationnels actifs

Claude Code peut déléguer des sous-tâches à des agents spécialisés, chacun avec ses propres instructions, outils, et contexte de travail. Les types d'agents personnalisés se définissent dans .claude/agents/.

Skill vs Agent : un skill injecte de la connaissance passive dans le contexte. Un agent est un sous-processus actif qui lit des fichiers, exécute des outils, et retourne un résultat — sans polluer le contexte principal.

Quand utiliser un agent

Préférer un agent pour les tâches longues ou exploratoires : audit de code, recherche dans le codebase, génération de rapports — toute opération dont le volume de sortie encombrerait la conversation principale.

Bonnes pratiques

Méthodologie d'équipe

La direction de l'agence : produire le moins de code possible manuellement. Pour y parvenir, il faut identifier les bons cas d'usage, appliquer les bonnes pratiques, et rester efficace — l'objectif est le gain de temps, pas l'IA pour l'IA.

Plan avant développement

Toujours faire un plan avant chaque développement (mode Plan : Shift+Tab ou /plan). Prendre le temps de le préparer : c'est un investissement qui fait gagner du temps par la suite. Un plan validé évite les allers-retours et limite le code cassé.

Structure d'un bon prompt

01
Un objectif clair
Ce qui doit exister à la fin, formulé en une phrase.
02
Un plan
Les étapes attendues, ou demander à Claude de le produire d'abord.
03
Un maximum de contexte
Environnement, historique, contraintes métier, décisions déjà prises.
04
Les contraintes
Stack imposée, périmètre à ne pas toucher, compatibilité.
05
Les fichiers utiles
Référencer explicitement les fichiers qui apportent du contexte.
06
Les critères de validation
Comment vérifier que c'est terminé : tests, lint, comportement attendu.

Laisser l'IA améliorer les prompts : elle formule généralement mieux les instructions qu'un humain. Demander à Claude de reformuler ou d'enrichir un prompt avant de lancer un développement important.

!

Ne pas tomber dans la surqualité. Éviter aussi les reviews trop complexes : une review doit rester lisible et actionnable. Challenger systématiquement les propositions de l'IA plutôt que de les accepter par défaut.

Cas d'usage validés par l'équipe

Comprendre
Explorer et expliquer un code existant
Corriger
Expliquer et corriger une erreur
Refactoriser
Restructurer du code sans changer le comportement
Documenter
Produire de la documentation technique
Préparer un ticket
Rédiger et cadrer un ticket avant développement
Tester
Écrire des tests unitaires et fonctionnels
Explorer des pistes
Prototyper plusieurs approches rapidement
Challenger
Confronter les propositions de l'IA
Analyser des logs
Notamment pour investiguer les attaques
Feature de bout en bout
Plan → développement → tests → validation
Rédiger une SFD
Concevoir une spécification fonctionnelle détaillée

Gestion du contexte

Efficacité & tokens

La qualité des réponses dépend directement de la qualité du contexte. Trois règles issues de nos retours d'expérience :

01
Markdown plutôt que MCP mémoire
Les MCP sont peu performants pour conserver le contexte. Privilégier des fichiers Markdown dans le repo : plans, notes de décisions, états des lieux.
02
Anglais autant que possible
Le code, les prompts techniques et les fichiers de contexte en anglais consomment moins de tokens. Les commentaires restent en français (convention projet).
03
Surveiller la taille du contexte
Quand le contexte devient trop important, demander un état des lieux (fichier Markdown), puis repartir sur une nouvelle session (/clear) en s'appuyant sur ce résumé.

Cycle de session recommandé

fin de session — handoff
# Quand le contexte devient trop lourd :
> Fais un état des lieux de notre avancement dans
  docs/handoff.md : ce qui est fait, ce qui reste,
  les décisions prises et les fichiers concernés.

# Puis nouvelle session :
/clear
> Lis docs/handoff.md et continue le développement.

Commandes utiles

CommandeUsage
/init Initialiser le projet : génère un CLAUDE.md à partir du codebase
/plan Passer en mode plan avant tout développement
/review Revue de code du diff courant ou d'une PR
/compact Résumer la conversation pour libérer du contexte
/clear Repartir sur une session vierge (après un état des lieux)

Permissions

settings.json

Objectif : laisser Claude travailler sans interruption sur les opérations courantes, tout en bloquant les commandes dangereuses. La configuration se fait dans .claude/settings.json (partagé équipe) ou settings.local.json (personnel).

Configuration type

.claude/settings.json
{
  "permissions": {
    "allow": [
      "Bash(npm run:*)",
      "Bash(composer:*)",
      "Bash(git diff:*)",
      "Bash(git log:*)",
      "Bash(npx playwright test:*)"
    ],
    "deny": [
      "Bash(rm -rf:*)",          // jamais de suppression récursive
      "Bash(git push --force:*)",
      "Read(.env*)",             // secrets hors de portée
      "Read(**/credentials*)"
    ]
  }
}

Un fichier de configuration de référence sera partagé à toute l'équipe pour homogénéiser les permissions (autoriser large, sauf commandes destructrices). En cas de doute sur une règle, utiliser /permissions pour inspecter la configuration active.

Playwright

Tests fonctionnels

Intégrer davantage Playwright dans nos développements. Claude est capable de lancer les tests Playwright lui-même, d'interpréter les échecs et de corriger — ce qui ferme la boucle développement → test → correction sans intervention manuelle.

Pourquoi Playwright avec Claude

01
Tests fonctionnels
Vérifier les parcours utilisateur réels, pas seulement les unités de code.
02
Détection des effets de bord
Très utile pour repérer ce qu'une modification casse ailleurs — le point faible historique des assistants IA.
03
Critère de validation objectif
Les tests Playwright servent de critère de validation dans les prompts : « la feature est terminée quand la suite passe ».
exemple de prompt
> Implémente le formulaire de contact selon le plan validé.
  Critère de validation : npx playwright test contact.spec.ts
  doit passer, et la suite existante ne doit pas régresser.

Confidentialité

Règles non négociables

Ne jamais transmettre à l'IA, quel que soit le canal (prompt, fichier, MCP) :

Credentials
Identifiants, tokens, clés API, mots de passe
Bases de données
Dumps de production ou de préproduction
Données clients
Toute donnée client sensible ou personnelle
!

Vérifier l'authenticité des fichiers avant de télécharger ou d'installer des skills, commands ou MCP tiers : un skill est du contenu exécuté dans votre session, avec vos permissions. N'installer que des sources vérifiées ou internes à l'agence.

Pour travailler sur des données réalistes, utiliser des jeux de données anonymisés ou générés. Les règles de permissions ci-dessus (deny sur .env*) sont un filet de sécurité, pas une excuse pour relâcher la vigilance.

Partage des connaissances

Culture d'équipe

Être moteur sur le sujet : partager au maximum les outils, astuces, prompts, skills et fichiers utiles avec l'équipe. Tout ce qui fonctionne pour un développeur doit être versionné dans .claude/ (skills, commands, settings) pour profiter à tous — c'est le principe même de ce guide.

Workflow recommandé

Nouveau projet
01
CLAUDE.md à la racine
Conventions globales, stack, décisions architecturales. Inclure les sous-fichiers par domaine via @import.
02
CLAUDE.md par domaine
Placer un fichier dans src/api/, src/components/ etc. pour des instructions contextuelles ciblées.
03
Skills pour l'expertise métier
Packager le savoir-faire spécialisé (sécurité, performance, accessibilité) dans .claude/skills/.
04
Hooks pour l'automatisation
Configurer linting, formatage, ou vérifications légères dans settings.json.
05
MCP pour les outils externes
Connecter GitHub, base de données, ou toute API via mcpServers dans settings.json.
06
Commands pour les tâches répétitives
Encoder les workflows récurrents (création de composant, revue de PR, migration) dans .claude/commands/.
07
Permissions partagées
Committer un settings.json d'équipe : autoriser les opérations courantes, bloquer les commandes destructrices et l'accès aux secrets.
08
Plan, puis développement validé par les tests
Pour chaque feature : plan validé → développement → tests (Playwright) → validation. Ne jamais coder sans plan.