Voici ma configuration Claude Code, affinée après des mois d'usage quotidien sur plusieurs projets. Dernière mise à jour : avril 2026.

Architecture de la configuration

Claude Code s'appuie sur un système de mémoire à 3 niveaux :

Niveau	Fichier	Quand c'est chargé
Global	`~/.claude/CLAUDE.md`	Toutes les conversations, tous les projets
Projet	`./CLAUDE.md` à la racine du projet	Chaque conversation dans ce projet
Sous-dossier	`./CLAUDE.md` dans un sous-dossier	Quand Claude lit un fichier dans ce dossier

Fichiers supplémentaires :

~/.claude/rules/ : règles globales (chargées selon le contexte)
~/.claude/commands/ : skills et commandes custom
~/.claude/agents/ : sub-agents autonomes
~/.claude/scripts/ : scripts d'automatisation pour les hooks
~/.claude/settings.json : plugins, deny list, permissions globales, hooks
~/.claude/settings.local.json : status line et permissions locales
.claude/ dans chaque projet : rules et settings spécifiques au projet

Les modèles que j'utilise en 2026

Modèle	Quand je l'appelle	Comment
Opus 4.7 (1M context)	Feature importante, refacto large, lecture de codebase entière	Par défaut dans `/model`
Sonnet 4.6 (1M context)	Workflows longs, édition de 10+ fichiers, quand Opus est trop lent	`/model sonnet`
Haiku 4.5	Tâches courtes, scripts, exploration rapide, sub-agents	`/model haiku`
Opus 4.6 (Fast mode)	Itération rapide avec la qualité Opus	`/fast` en cours de session

Le 1M de contexte change la donne : je peux charger un monorepo entier avant de commencer à réfléchir. En pratique je reste sur Opus 4.7 pour tout ce qui demande de la qualité, je bascule sur Haiku pour les sub-agents d'exploration où seul le volume compte, et je passe en /fast quand j'ai besoin d'itérer vite sans perdre la tête d'Opus.

Mon CLAUDE.md global (~50 lignes)

Chargé dans TOUTES les conversations. Contient :

Identité : dev Next.js + Supabase + shadcn/ui + Tailwind v4, réponses en français, code en anglais
Coding standards : TypeScript strict, Server Components par défaut, Server Actions + RLS + Zod
UI/UX : shadcn/ui obligatoire, Tailwind v4 CSS vars, pattern Recharts SSR
Git : commits conventionnels en anglais, jamais push ni force push sans demander
Outils : pnpm par défaut, Prettier via hook

Mes règles globales (`~/.claude/rules/`)

safety.md, ce qui est INTERDIT

rm -rf : utiliser trash
sudo sans confirmation
Suppression de migrations SQL
supabase db reset (détruit données et credentials)

supabase.md, patterns obligatoires

createClient() (anon+RLS) pour les pages user
createAdminClient() UNIQUEMENT pour admin et scripts
Pattern server action : "use server" → createClient() → getUser() → Zod → query

nextjs.md, conventions Next.js

Server Components par défaut, Client Components seulement si state/events
LIRE 3 FICHIERS SIMILAIRES avant de créer un nouveau composant/route/action
URL search params pour les filtres (SSR-friendly), pas de useState
Ne jamais créer middleware.ts sans vérifier l'existant

quality.md, standards de qualité

Ne jamais marquer une tâche terminée sans preuve que ça marche
Demand elegance pour les changements non-triviaux
Simplicity first, no laziness, minimal impact

workflow.md, gestion des sessions

Plan mode pour toute tâche 3+ étapes
Subagents pour garder le contexte propre
/compact à 60%, STOP à 80%, /rewind si ça déraille

self-improvement.md, auto-amélioration

Après correction utilisateur : sauvegarder en mémoire (feedback)
Pattern manquant détecté : suggérer une mise à jour des rules

changelog.md, CHANGELOG automatique

Mise à jour de CHANGELOG.md après chaque changement de code

typescript-errors.md, scope multi-agent

Ne corriger que les erreurs TypeScript dans ses propres fichiers

writing-style.md, anti-patterns IA

Zéro tiret cadratin, zéro parallélisme, zéro formule sentencieuse

pdf-export.md, export PDF carrousel

Dimensions divisibles par 4 (standard : 1080x1348px)
Post-processing pypdf pour MediaBox exact

Mes hooks

Les hooks, c'est la partie "automatique" de Claude Code : ils s'exécutent à des moments précis (session start, avant un outil, après un outil, fin de session). Le chapitre 9 couvre le fonctionnement complet et comment les écrire. Voici ceux que j'ai branchés dans mon ~/.claude/settings.json :

SessionStart : charge automatiquement ~/Claude OS/brain/INDEX.md et ~/Claude OS/brain/memory/MEMORY.md quand j'ouvre une session dans ~/Claude OS/. Mon knowledge base est déjà en contexte, je n'ai rien à rappeler.
PostToolUse (Prettier) : après chaque édition de fichier, lance npx prettier --write. Le code reste formaté sans y penser.
PostToolUse (console warn) : alerte si un console.log est glissé dans du TypeScript.
PreToolUse (config protection) : bloque les modifications sauvages de .eslintrc, .prettierrc, biome.json. Force à corriger le code plutôt qu'à affaiblir les règles.
PreToolUse (TypeScript pré-commit) : npx tsc --noEmit avant chaque git commit, commit bloqué si erreur.
Stop : notification macOS cliquable avec projet, branche et durée de session.

Voici le squelette JSON du fichier :

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "~/Claude OS/**",
        "command": "cat ~/Claude\\ OS/brain/INDEX.md ~/Claude\\ OS/brain/memory/MEMORY.md"
      }
    ],
    "PostToolUse": [
      { "matcher": "Edit|Write", "command": "npx prettier --write \"$FILE\"" },
      {
        "matcher": "Edit|Write",
        "command": "~/.claude/scripts/console-warn.sh \"$FILE\""
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "command": "~/.claude/scripts/config-protection.sh \"$FILE\""
      },
      { "matcher": "Bash(git commit*)", "command": "npx tsc --noEmit" }
    ],
    "Stop": [{ "command": "~/.claude/scripts/notify-session-end.sh" }]
  }
}

Mes plugins actifs

Les plugins ajoutent des workflows pré-configurés, installables via le marketplace officiel.

superpowers : framework complet avec brainstorming 4 rounds, TDD, debugging structuré, plans, code review parallèle, worktrees.
claude-seo : audit SEO full-site, technique, schema, GEO (AI Overviews), images, sitemap.
claude-blog : moteur éditorial (write, rewrite, analyze, outline, audit, repurpose) avec scoring 100 points ranking Google + citations IA.
ralph-loop : tâches répétées pendant une session (monitoring, polling, itération contrôlée).
claude-carbon : empreinte carbone des sessions et cartes de rapport partageables.

Mes serveurs MCP

Les serveurs MCP connectent Claude Code à des services externes via le Model Context Protocol.

Local

nano-banana : génération et édition d'images via Gemini (chapitre 15)

Cloud (connectés via claude.ai)

Notion : lire, créer et modifier des pages et bases de données
Gmail : rechercher, lire et rédiger des emails
Google Calendar : gérer l'agenda
Supabase : exécuter du SQL, migrations, edge functions, types
Vercel : déploiements, logs, configuration projet
Stripe : paiements, webhooks, authentification
Sentry : monitoring et alertes
Context7 : documentation à jour de n'importe quelle librairie
Canva : création et édition de designs
Excalidraw : diagrammes et schémas techniques

Résultat : pousser un carousel dans Notion, checker un déploiement Vercel, exécuter du SQL sur Supabase, rechercher un email. Sans quitter le terminal.

Mon workflow /code, Prompt Discovery

Le problème, Lost in the Middle

Les LLMs donnent plus d'attention aux tokens en début et en fin de contexte. Un gros prompt initial se retrouve "au milieu" après l'exploration, le modèle le suit moins bien.

La solution, Prompt Discovery : chaque étape est lue JUSTE AVANT son exécution, les instructions restent fraîches en fin de contexte.

Comment utiliser /code

/code Ajouter une page profil utilisateur

Explore la codebase, exécute, vérifie (TypeScript, build).

/code --plan Ajouter un système de notifications

Explore, crée un plan, validation utilisateur, exécute, vérifie.

/code --plan --test --branch --pr Refactorer le système de crédits

Explore, plan, branche git, exécute, tests, PR.

Les 4 étapes

Étape	Fichier	Ce qui se passe
Explore	`01-explore.md`	Lance des sub-agents pour analyser la codebase, lit 3+ fichiers similaires
Plan	`02-plan.md`	Crée un plan structuré, identifie les décisions (si `--plan`)
Execute	`03-execute.md`	Code dans l'ordre : migrations → types → actions → UI
Verify	`04-verify.md`	TypeScript check, lint, build, tests (si `--test`), PR (si `--pr`)

Les commandes que j'utilise en flux tendu

En plus de /code, trois commandes intégrées rythment mes sessions :

/loop : tâche qui doit se répéter (polling d'un déploiement, itération contrôlée sur un rendu). Je donne l'intervalle ou je laisse le modèle se temporiser.
/rewind (ou double Esc) : annule les dernières modifs de code ET revient en arrière dans la conversation. Quand Claude part dans une mauvaise piste, c'est 3x plus efficace que corriger à la main.
/compact : résume la conversation, libère du contexte. Je le lance vers 50-60%, jamais plus tard.

Mes sub-agents custom

Un sub-agent, c'est un "mini-Claude" dispatché pour une tâche précise. Il explore, analyse, puis renvoie un résumé au contexte principal. Avantage : il peut lire 120K tokens et n'en renvoyer que 1-2K.

Exploration

explore-codebase : structure du projet, stack, patterns, utilitaires (~500 mots)
explore-supabase : migrations SQL, policies RLS, server actions (~800 mots)
doc-lookup : documentation via Context7 MCP ou web search (~1000 mots)

Blog & contenu

blog-researcher : statistiques récentes, vérification de sources, images libres
blog-writer : rédaction d'articles optimisés SEO et citations IA
blog-reviewer : review qualité sur 5 catégories, scoring /100
blog-seo : optimisation SEO on-page

SEO (7 agents spécialisés)

seo-content · seo-technical · seo-schema · seo-geo · seo-performance · seo-sitemap · seo-visual

Chaque agent SEO couvre un domaine : contenu, technique, schema.org, citations IA, Core Web Vitals, sitemaps, rendu visuel.

Impact sur le contexte : un sub-agent peut lire 120K tokens et n'en renvoyer que 1-2K au contexte principal. Économie massive qui te permet de garder ton contexte propre pour les instructions qui comptent.

Mes skills et commandes

Chaque fichier .md dans ~/.claude/commands/ devient une commande /nom.

Développement

/code · /apex · /debug · /review · /component · /server-action · /form-builder · /migration-sql · /rls-policy · /refactor · /test-gen · /supabase-types · /codebase-map · /security-scan · /deploy-check · /push-prod · /pr · /clean-code · /explain · /perf-audit · /oneshot

Contenu & marketing

/carousel · /lk · /insta · /bip · /newsletter · /email · /veille · /image · /photo-gaetan · /banner · /video · /short · /deck · /content-repurpose · /recap · /ship · /metrics-share · /inbox-notion

Workflows multi-étapes

/code : Explore → Plan → Execute → Verify. Chaque étape est un fichier lu juste-à-temps (Prompt Discovery).
/apex : version avancée avec flags --auto, --plan, --branch, --pr, --test
/brainstorm : recherche profonde en 4 rounds (Exploration, Devil's Advocate, Synthèse, Cristallisation)
/debug : debugging structuré en 5 étapes (Init, Analyse, Solutions, Fix, Verify)
/review : code review parallèle avec 4 reviewers (Code, Best Practices, Security, Devil Advocate)

Checklist nouveau projet

Créer le projet et initialiser git
Lancer claude dans le dossier du projet
Lancer /init pour générer le CLAUDE.md automatiquement
Réduire le CLAUDE.md à ~100-200 lignes (garder l'essentiel)
Créer .claude/settings.local.json avec les permissions
Ajouter des rules scoped dans .claude/rules/ si nécessaire
Ajouter des code comments dans les fichiers utilitaires clés (coût zéro)

Configuration settings.json

Le fichier ~/.claude/settings.json contient des réglages qui améliorent la qualité des réponses. Ces 3 options sont recommandées par Boris Cherny (créateur de Claude Code) :

{
  "effortLevel": "high",
  "alwaysThinkingEnabled": true,
  "outputStyle": "Explanatory"
}

Ce que chaque option fait :

effortLevel: "high" : Claude utilise plus de tokens pour réfléchir. Plus lent, mais plus intelligent. Boris l'utilise sur tout.
alwaysThinkingEnabled: true : affiche le raisonnement de Claude. Tu vois pourquoi il fait chaque choix.
outputStyle: "Explanatory" : ajoute des boîtes "Insight" qui expliquent les patterns et frameworks utilisés. Utile quand tu explores un codebase inconnu.

Ces réglages sont aussi accessibles via :

/model pour changer le modèle et l'effort level
/config pour l'output style
/fast pour basculer en Opus 4.6 (Fast mode) en cours de session

Status line avec alerte contexte

La status line affiche des infos en temps réel sous le composer. Ma version ajoute un warning de contexte :

#!/bin/bash
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')
DIR=$(echo "$input" | jq -r '.workspace.current_dir')
PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')

FOLDER="${DIR##*/}"

if [ "$PCT" -ge 80 ]; then
  CTX=" [COMPACT NOW]"
elif [ "$PCT" -ge 60 ]; then
  CTX=" [compact soon]"
else
  CTX=""
fi

echo "[$MODEL] $FOLDER | ${PCT}% ctx${CTX} | \$$COST"

Résultat : [Opus 4.7] mon-projet | 45% ctx | $1.23. Et quand le contexte dépasse 60% : [Opus 4.7] mon-projet | 65% ctx [compact soon] | $2.10.

Pour l'activer, ajoute dans settings.local.json :

{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh",
    "padding": 2
  }
}

Auto-memory : ce qui est officiel, ce qui est personnel

La taxonomie 4-types que j'utilise pour mes mémoires (user, feedback, project, reference) est ma convention perso, pas une contrainte Anthropic. Le système officiel se limite à un MEMORY.md qui sert d'index. Tout le reste (les sous-fichiers, les catégories, les conventions de nommage) est de la structuration que j'ai ajoutée par-dessus pour que mon brain reste lisible. Tu peux l'adopter, la simplifier, ou ne rien formaliser du tout.

Concrètement dans mon setup, ~/Claude OS/brain/memory/MEMORY.md liste les mémoires typées et pointe vers des fichiers markdown individuels :

user : qui je suis, comment je collabore, ce que je sais déjà
feedback : guidance donnée sur comment approcher le travail
project : décisions, états d'initiatives, deadlines, contexte en cours
reference : pointeurs vers systèmes externes (Linear, Notion, Grafana, etc.)

Les hooks écrivent directement dans ce dossier, et Claude le lit au démarrage via le hook SessionStart. Le seul contrat vraiment officiel, c'est l'existence d'un MEMORY.md comme point d'entrée.

Deny list globale (filet de sécurité)

Dans ~/.claude/settings.json, la deny list bloque les commandes dangereuses partout, même en mode trust :

{
  "permissions": {
    "deny": [
      "Bash(rm -rf*)",
      "Bash(sudo*)",
      "Bash(supabase db reset*)",
      "Bash(git push --force*)",
      "Bash(git push -f*)",
      "Bash(git reset --hard*)",
      "Bash(git clean -f*)"
    ]
  }
}

Ces commandes sont les plus destructrices : suppression de fichiers, écrasement de l'historique git, destruction de base de données. Mieux vaut les bloquer une fois pour toutes.

Tips avancés

Règle des 3 fichiers

Avant de créer un nouveau composant/route/action, Claude doit LIRE au moins 3 fichiers similaires existants. Ça garantit la cohérence des patterns sans tout documenter dans le CLAUDE.md.

Code comments comme instructions

Ajouter des commentaires // CLAUDE: dans les fichiers utilitaires clés. Quand Claude lit ces fichiers pour comprendre les patterns, il hérite des instructions gratuitement, 0 token supplémentaire dans le contexte.

Exemples concrets :

supabase/server.ts : différence entre client anon et admin
ai/types.ts : comment ajouter un nouveau skill IA
stripe/client.ts : ne pas exposer la secret key côté client

Mot-clé "ultrathink"

Ajouter ultrathink dans un prompt force Claude à utiliser un raisonnement approfondi (extended thinking). Idéal pour les problèmes d'architecture complexes, les choix de design avec beaucoup de trade-offs, ou le debugging de problèmes subtils.

Prompt Discovery (anti "Lost in the Middle")

Ne jamais donner toutes les instructions d'un workflow en une seule fois. Découper en fichiers steps lus juste-à-temps pour que les instructions restent "fraîches" en fin de contexte.

Meta-prompt pour optimiser tes prompts

Le skill /meta-prompt génère des prompts optimisés en appliquant les best practices Anthropic : XML tags, few-shot examples, chain-of-thought, etc. Utile pour créer des prompts système pour tes skills IA.

Hook pre-commit TypeScript

Un hook PreToolUse qui intercepte les git commit et lance npx tsc --noEmit avant. Bloque le commit si erreur TypeScript, filet de sécurité automatique.

Arborescence type

~/.claude/
├── CLAUDE.md                          ← Préférences globales
├── settings.json                      ← Plugins, deny list, hooks
├── settings.local.json                ← Status line, permissions locales
├── rules/
│   ├── safety.md                      ← Interdictions (rm -rf, sudo, db reset)
│   ├── supabase.md                    ← Patterns Supabase obligatoires
│   ├── nextjs.md                      ← Conventions Next.js
│   ├── workflow.md                    ← Best practices /compact, /rewind, sessions
│   └── changelog.md                   ← Mise à jour CHANGELOG après chaque modif
├── commands/
│   └── code/
│       ├── skill.md                   ← Workflow /code (entry point)
│       └── steps/
│           ├── 01-explore.md          ← Étape exploration
│           ├── 02-plan.md             ← Étape plan (si --plan)
│           ├── 03-execute.md          ← Étape exécution
│           └── 04-verify.md           ← Étape vérification
└── agents/
    ├── explore-codebase.md            ← Sub-agent exploration projet
    ├── explore-supabase.md            ← Sub-agent schéma Supabase
    └── doc-lookup.md                  ← Sub-agent documentation

~/code/mon-projet/
├── CLAUDE.md                          ← ~100-200 lignes, spécifique au projet
└── .claude/
    ├── settings.local.json            ← Permissions projet
    └── rules/
        ├── db-schema.md               ← Schéma DB (si applicable)
        └── roadmap.md                 ← Phases et sprints