Ma configuration complète

Architecture de la configuration

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

Fichiers supplémentaires :

• ~/.claude/rules/ : règles globales, chargées à chaque session
• ~/.claude/commands/ et ~/.claude/skills/ : mes commandes et skills (les deux créent une /commande depuis janvier 2026)
• ~/.claude/agents/ : sub-agents autonomes
• ~/.claude/scripts/ : scripts appelés par les hooks
• ~/.claude/settings.json : plugins, deny list, permissions globales, hooks, status line
• ~/.claude/projects/<projet>/memory/ : l'auto-memory, que Claude écrit lui-même
• .claude/ dans chaque projet : rules et settings spécifiques au projet

Les modèles que j'utilise en octobre 2026

En pratique je reste sur Opus 5.5 pour tout ce qui demande de la qualité, et je bascule sur Haiku pour les sub-agents d'exploration où seul le volume compte.

Attention, /fast ne rétrograde pas vers un modèle plus petit. Tu restes sur Opus 5.5, il répond plus vite, et tu le paies (8 $/40 $ par million au tarif API, le double du normal).

L'effort par défaut est medium sur les modèles 5.5. Plus l'effort monte, plus Claude réfléchit avant de répondre, et cette réflexion est facturée comme de la sortie. Sur les modèles 5.5 et Fable, le thinking ne se coupe pas : l'effort est le seul levier.

Mon CLAUDE.md global (~90 lignes)

Chargé dans toutes les conversations. Contient :

• Identité : builder solo, stack Next.js + Supabase + shadcn/ui + Tailwind v4, réponses en français, code en anglais
• Brain : où se trouve ma base de connaissances et comment l'interroger sans halluciner
• Coding standards : TypeScript strict, jamais de any, imports @/, pas de console.log dans le code final
• UI/UX : shadcn/ui obligatoire, Tailwind v4 en CSS variables, pattern Recharts SSR
• Git : commits conventionnels en anglais, jamais de push sans demander, jamais de force push sur main
• Style d'écriture et design : les anti-patterns IA à éliminer dans tout ce que Claude rédige
• Outils : pnpm par défaut, Prettier via hook

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

Cinq fichiers, chargés à chaque session.

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)
• Écraser un .env ou un fichier de credentials

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 de 3 étapes ou plus, découpée en tranches verticales (DB + service + UI d'un bout de feature), plan relu par un deuxième agent
• Subagents pour garder le contexte principal propre
• Avec la fenêtre de 1M, pas de seuil chiffré à surveiller. /compact intentionnel entre deux grosses features, avec une consigne, plutôt qu'un auto-compact au milieu d'une tâche. J'ai coupé l'auto-compact
• /rewind si ça déraille

self-improvement.md, auto-amélioration

• Après une correction de ma part : Claude sauvegarde la leçon en mémoire (type feedback)
• Pattern manquant détecté : il propose une mise à jour des rules

writing-style.md, anti-patterns IA

• La liste des tournures qui trahissent un texte généré : tirets cadratins, parallélismes, formules sentencieuses

Ce qui est sorti des rules

Mes patterns Next.js, Supabase, CHANGELOG, TypeScript multi-agent et export PDF sont maintenant dans des skills (nextjs-patterns, supabase-patterns, project-changelog...). La différence compte : une rule est chargée à chaque session, un skill seulement quand le sujet arrive.

Mes hooks

Les hooks sont des scripts qui s'exécutent à des moments précis (démarrage de session, avant ou après un outil, fin de tour). Le chapitre 9 couvre le fonctionnement. Voici ceux de mon ~/.claude/settings.json :

• SessionStart (brain) : injecte un pointeur vers ma base de connaissances et les dernières entrées de son journal. Au départ, ce hook collait l'index complet et MEMORY.md à chaque session. Doublon avec l'auto-memory, et le dump était tronqué de toute façon. La version courte fait le même travail.
• SessionStart (conflit) : m'avertit si une autre session Claude Code tourne déjà sur le même checkout.
• PreToolUse (config protection) : bloque les modifications de .eslintrc, .prettierrc, biome.json. Claude corrige le code au lieu d'affaiblir les règles.
• PostToolUse (Prettier) : formate chaque fichier édité avec le Prettier du projet. Jamais un Prettier téléchargé à la volée.
• PostToolUse (contrôles) : alerte sur un console.log glissé dans du TypeScript, et bloque les tirets cadratins dans mes contenus.
• Stop (TypeScript) : quand Claude a fini son tour, lance tsc --noEmit. S'il a touché des fichiers .ts et qu'il reste des erreurs, le hook lui renvoie les erreurs et il corrige avant de rendre la main.
• Stop (notification et mesure) : notification macOS, et envoi des chiffres de la session vers TokenClimate.
• SessionEnd et PreCompact : écrivent un résumé de la session dans le brain.

Le squelette JSON, au format actuel (chaque script reçoit le contexte de l'événement en JSON sur son entrée standard) :

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          { "type": "command", "command": "~/.claude/scripts/session-start.sh" }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/scripts/config-protection.sh"
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/scripts/prettier-file.sh"
          },
          { "type": "command", "command": "~/.claude/scripts/console-warn.sh" }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/scripts/stop-typecheck.sh"
          }
        ]
      }
    ]
  }
}

Mes plugins actifs

Installés depuis le marketplace officiel, sauf le dernier (chapitre 16) :

• superpowers : brainstorming, plans, TDD, debugging systématique, revue, worktrees.
• commit-commands : /commit, /commit-push-pr, /clean_gone.
• claude-md-management : audit et mise à jour des CLAUDE.md.
• frontend-design : des consignes de design pour que les interfaces générées ne ressemblent pas à un template.
• typescript-lsp : Claude interroge le serveur de langage TypeScript au lieu de relire des fichiers entiers pour trouver une définition.
• vercel : skills et outils Vercel (déploiement, env, logs).
• claude-carbon : le mien. Je l'ai écrit pour voir le CO2 et le coût de chaque session dans ma status line.

Mes serveurs MCP

Les serveurs MCP connectent Claude Code à des services externes (chapitre 17).

Local

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

Cloud (connecteurs claude.ai)

• Notion : lire, créer et modifier des pages et bases de données
• Gmail et Google Calendar : emails et agenda
• Supabase : SQL, migrations, edge functions, types
• Vercel : déploiements, logs, configuration projet
• Sentry : erreurs en production
• PostHog : analytics produit
• Context7 : documentation à jour de n'importe quelle librairie
• Canva et Excalidraw : designs et schémas
• Claude Docs : documents partagés et commentables

Ils apparaissent tous dans /mcp. Avec le tool search par défaut, ils ne coûtent presque rien tant que Claude ne s'en sert pas. Je pousse un carousel dans Notion ou je checke un déploiement Vercel sans quitter le terminal.

Le principe Prompt Discovery (mon ancien workflow /code)

Pendant des mois, j'ai codé avec une commande /code en quatre étapes. Elle dort aujourd'hui dans mes archives, mais le principe reste valable pour écrire tes propres skills en plusieurs étapes.

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, et 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 je l'utilisais

/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.

Les 4 étapes

Les commandes natives que j'utilise en flux tendu

• /effort : je monte ou je baisse la réflexion selon la tâche, sans casser le cache.
• /code-review : revue du diff avant chaque commit. --fix applique les corrections.
• /loop et /goal : une tâche qui se répète, ou une condition à atteindre avant que Claude s'arrête (chapitre 18).
• /rewind (ou double Échap) : annule les dernières modifs de code et revient en arrière dans la conversation. Quand Claude part sur une mauvaise piste, c'est plus efficace que corriger à la main.
• /compact : entre deux features, avec une consigne de ce qu'il faut garder.
• /usage : en fin de session, pour voir ce qu'elle a coûté et si le cache a tenu.

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. Il peut lire 120K tokens et n'en renvoyer que 1 ou 2K.

Dans ~/.claude/agents/, j'en garde deux :

• code-reviewer : revue d'un diff contre mes règles de stack (TypeScript strict, App Router, Supabase, shadcn/ui), avec un verdict final.
• copy-anti-ia-linter : passe un texte français au crible des anti-patterns IA de mes rules et renvoie un tableau des infractions.

Pour l'exploration, je laisse Claude lancer ses propres sub-agents, sur Haiku 5.5 quand seul le volume compte.

Mes skills et commandes

Aucune de ces commandes n'est native : ce sont des fichiers .md à moi, dans ~/.claude/commands/ ou ~/.claude/skills/. Une commande inutilisée depuis plus de 60 jours part dans un dossier d'archives.

Développement

/oneshot · /explain · /audit · /deploy-check · /perf-audit · /push-prod · /meta-prompt

Plus des skills qui se chargent seuls quand le sujet arrive : nextjs-patterns, supabase-patterns, project-changelog, multi-agent-typescript.

Contenu et marketing

/carousel · /lk · /newsletter · /email · /outreach · /image · /photo-gaetan · /deck · /yt · /yt-title · /thumbnail-yt · /voff · /caption · /lint-copy

Brain

/brain · /capture · /flush · /query · /lint · /emerge

Ce qui a remplacé mes anciens workflows maison

• Le brainstorming en plusieurs rounds : le skill brainstorming de superpowers.
• La revue de code : /code-review, natif.
• Commit, push et PR : /commit-push-pr du plugin commit-commands.

Checklist nouveau projet

1. Créer le projet et initialiser git
2. Lancer claude dans le dossier du projet
3. Lancer /init pour générer le CLAUDE.md automatiquement (s'il n'y a pas de CLAUDE.md, Claude Code lit un AGENTS.md existant)
4. Réduire le CLAUDE.md sous 200 lignes (garder l'essentiel)
5. Créer .claude/settings.local.json avec les permissions
6. Ajouter des rules scoped dans .claude/rules/ si nécessaire
7. Ajouter des commentaires dans les fichiers utilitaires clés

Les réglages qui comptent dans ~/.claude/settings.json

{
  "modelSettings": {
    "claude-opus-5-5": { "effortLevel": "high" },
    "claude-sonnet-5-5": { "effortLevel": "medium" }
  },
  "permissions": { "defaultMode": "auto" },
  "env": { "ENABLE_PROMPT_CACHING_1H": "1" }
}

Ce que chaque option fait :

• modelSettings : le niveau de réflexion enregistré modèle par modèle. Tu l'écris rarement à la main : quand tu valides un niveau avec /effort, Claude Code l'enregistre ici pour le modèle en cours. Attention : un effortLevel posé à la racine de tes settings utilisateur ne s'applique plus à Opus 5.5, qui repart sur son défaut medium tant que tu ne lui as pas fixé un niveau. max n'est accepté nulle part dans les settings, il se règle seulement pour une session avec /effort max.
• defaultMode: "auto" : l'auto mode (le mode par défaut, voir chapitre 9). Le poser explicitement le fige si le défaut change un jour. Attention : defaultMode: "auto" et les règles autoMode ne sont lus que dans ~/.claude/settings.json (ou les managed settings, ou --settings), pas dans le .claude/settings.json d'un projet. Un classifieur laisse passer ce qui est sûr et bloque le destructif et la prod.
• ENABLE_PROMPT_CACHING_1H : demande le cache d'une heure pour la conversation et pour les subagents. Sur abonnement, la conversation principale l'a déjà, mais tout passe à 5 minutes dès que tu bascules en crédits d'usage. L'écriture en cache coûte plus cher (2x le prix d'input au lieu de 1,25x). Utile si tu fais souvent des pauses de plus de 5 minutes.

Ces réglages se changent aussi en session :

• /effort pour le niveau de réflexion
• /config key=value pour changer un réglage précis sans ouvrir le fichier
• /output-style pour le style de réponse
• /fast pour passer en mode rapide, sans changer de modèle

Status line avec alerte contexte

La status line affiche des infos en temps réel sous la zone de saisie. Aujourd'hui j'utilise celle de claude-carbon (modèle, contexte, coût, CO2, quota sur 5 h). Si tu veux écrire la tienne, voici une version minimale avec 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 5.5] mon-projet | 45% ctx | $1.23. Et au-delà de 60 % : [Opus 5.5] mon-projet | 65% ctx [compact soon] | $2.10. Adapte les seuils : sur une fenêtre de 1M, 60 % c'est déjà 600 000 tokens relus à chaque message.

Le JSON reçu par le script contient aussi rate_limits.five_hour, rate_limits.seven_day et un objet prompt_cache, de quoi afficher ton quota et l'état du cache.

Pour l'activer, ajoute dans settings.json :

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

Auto-memory : le système officiel et ma convention perso

Le système officiel. Claude Code prend des notes tout seul dans ~/.claude/projects/<projet>/memory/. Un fichier MEMORY.md sert d'index, chargé au début de chaque session (les 200 premières lignes ou 25 KB). Tu le coupes avec autoMemoryEnabled: false ou CLAUDE_CODE_DISABLE_AUTO_MEMORY=1. Pour lui faire retenir quelque chose, dis-le-lui ("retiens que les migrations passent toujours par une branche Supabase"), ou ouvre /memory.

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 : les corrections que j'ai données sur la façon de travailler
• project : décisions, états d'initiatives, deadlines, contexte en cours
• reference : pointeurs vers des systèmes externes (Notion, dashboards, etc.)

Ce dossier est un lien symbolique vers le dossier auto-memory officiel du projet. Résultat : Claude Code le charge nativement, sans hook, et les mémoires qu'il écrit atterrissent directement dans mon brain.

Deny list globale (filet de sécurité)

Dans ~/.claude/settings.json, la deny list bloque les commandes dangereuses quel que soit le mode de permission, auto mode compris :

{
  "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*)",
      "mcp__claude_ai_Gmail__send_message",
      "mcp__claude_ai_Gmail__reply"
    ]
  }
}

Les lignes Bash couvrent les commandes les plus destructrices : suppression de fichiers, écrasement de l'historique git, destruction de base de données. Les deux dernières empêchent Claude d'envoyer un email depuis mon Gmail : il peut préparer un brouillon, l'envoi reste à moi. Mieux vaut les bloquer une fois pour toutes que compter sur le classifieur.

Tips avancés

Règle des 3 fichiers

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

Commentaires comme instructions

Ajouter des commentaires // CLAUDE: dans les fichiers utilitaires clés. Quand Claude lit ces fichiers pour comprendre les patterns, il récupère les consignes au passage. Contrairement au CLAUDE.md, ça ne coûte rien tant qu'il n'ouvre pas le fichier.

Exemples :

• 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

/effort plutôt qu'un mot magique

Le mot-clé "ultrathink" a longtemps servi à forcer une réflexion approfondie depuis le prompt. Aujourd'hui la profondeur se règle avec /effort : high ou xhigh pour un problème d'architecture ou un bug subtil, medium ou low pour une tâche mécanique. Sur les modèles 5.5, changer d'effort ne casse pas le cache, donc tu peux l'ajuster en cours de route.

Meta-prompt pour optimiser tes prompts

Mon skill /meta-prompt génère un prompt en appliquant les bonnes pratiques Anthropic : balises XML, exemples, raisonnement guidé. Je m'en sers pour écrire les prompts système des fonctions IA de mes apps.

Le typecheck en fin de tour plutôt qu'au commit

Mon hook TypeScript tourne sur Stop, pas sur git commit. Claude voit ses erreurs dès qu'il rend la main et les corrige dans la foulée, au lieu de les découvrir au moment de committer.

Arborescence type

~/.claude/
├── CLAUDE.md                          ← Préférences globales
├── settings.json                      ← Plugins, deny list, hooks, status line
├── rules/
│   ├── safety.md                      ← Interdictions (rm -rf, sudo, db reset)
│   ├── quality.md                     ← Preuve avant "terminé"
│   ├── workflow.md                    ← Plan mode, subagents, /compact, /rewind
│   ├── self-improvement.md            ← Boucle d'apprentissage
│   └── writing-style.md               ← Anti-patterns IA
├── skills/
│   ├── nextjs-patterns/SKILL.md       ← Chargé quand on touche à Next.js
│   └── supabase-patterns/SKILL.md     ← Chargé quand on touche à Supabase
├── commands/
│   ├── oneshot.md                     ← Petite feature sans plan
│   └── deploy-check.md                ← Checklist avant déploiement
├── scripts/                           ← Scripts des hooks
└── agents/
    ├── code-reviewer.md               ← Revue de diff
    └── copy-anti-ia-linter.md         ← Lint des textes FR

~/code/mon-projet/
├── CLAUDE.md                          ← Sous 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

Aller plus loin : ce que tout ça coûte

Ce que cette configuration consomme, je l'ai mesuré sur deux mois et 230 sessions dans la fiche « Claude Code sans gaspiller ».

La mécanique (cache, contexte, modèles, effort, reprise à froid) est au chapitre 19, avec les deux outils que j'utilise pour mesurer : claude-carbon et TokenClimate.

Sources

• Claude Code, configuration des modèles
• Claude Code, prompt caching
• Claude Code, status line
• Claude Code, gérer les coûts