🧠 Ma configuration complète

Architecture de la configuration

Claude Code utilise un système de mémoire à 3 niveaux :

Fichiers supplémentaires :

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

Mon CLAUDE.md global (~50 lignes)

Fichier chargé dans TOUTES les conversations. Contient :

• Identité : dev fullstack 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, Recharts SSR pattern
• Git : commits conventionnels en anglais, jamais push/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
• Supprimer des migrations SQL
• supabase db reset (détruit données + credentials)

supabase.md, patterns obligatoires

• createClient() (anon+RLS) pour les pages user
• createAdminClient() UNIQUEMENT pour admin/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 mise à jour des rules

changelog.md, CHANGELOG automatique

• Mise à jour du 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 (6 scripts custom)

Les hooks s'exécutent automatiquement à certains moments. Configurés dans settings.local.json, ils utilisent des scripts dans ~/.claude/scripts/.

Après chaque édition de fichier (PostToolUse)

• Prettier auto-format : npx prettier --write sur le fichier modifié
• Console warn : alerte si console.log détecté dans du TypeScript/JavaScript
• Suggest compact : suggère /compact à 40 appels d'outils, puis tous les 25

Avant certaines actions (PreToolUse)

• Config protection : bloque les modifications des configs linter/formatter (.eslintrc, .prettierrc, biome.json). Force à corriger le code source au lieu d'affaiblir les règles.
• Pre-commit TypeScript : lance npx tsc --noEmit avant chaque git commit. Bloque le commit si erreur.

Fin de session (Stop)

• TypeScript check : vérifie les types et affiche max 15 erreurs
• Notification macOS : son + notification cliquable avec projet, branche et durée de session

Mes plugins (19 actifs)

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

Développement

• superpowers : framework complet, brainstorming 4 rounds, TDD, debugging structuré, plans, code review parallèle, worktrees
• commit-commands : /commit, /commit-push-pr, nettoyage de branches
• typescript-lsp : serveur de langage TypeScript intégré
• frontend-design : design d'interfaces production-grade

Intégrations

• vercel : déploiement, env vars, status, marketplace, AI SDK
• supabase : gestion DB, migrations, types, edge functions
• stripe : paiements, test cards, erreurs
• sentry : monitoring d'erreurs
• playwright : screenshots, tests E2E, automatisation navigateur
• Notion : lecture/écriture de pages et bases de données

Productivité

• claude-md-management : audit et amélioration des CLAUDE.md
• ralph-loop : tâches récurrentes en session
• skill-creator : création de nouveaux skills custom

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, ou 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 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, gardant les instructions 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

Mes sub-agents custom (16 agents)

Un sub-agent est un "mini-Claude" dispatché pour une tâche spécifique. 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.

Mes skills et commandes (43 commands)

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

Développement (21 commands)

/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 (18 commands)

/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

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
4. Réduire le CLAUDE.md à ~100-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 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 significativement 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. Très utile quand tu explores un codebase inconnu.

Ces réglages sont aussi accessibles via :

• /model pour changer l'effort level
• /config pour l'output style

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.6] mon-projet | 45% ctx | $1.23. Et quand le contexte dépasse 60% : [Opus 4.6] 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
  }
}

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. Cela garantit la cohérence des patterns sans avoir à 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

/compact et /rewind, les 2 commandes les plus sous-estimées

/compact : résume la conversation et libère du contexte. Lancer manuellement dès 50-60% de contexte. N'attends pas 80%, c'est la "dumb zone" où Claude perd en qualité. Après un /compact, relis les fichiers clés de ta tâche en cours.

/rewind (Esc Esc) : annule les dernières modifications de code ET revient en arrière dans la conversation. Quand Claude part dans la mauvaise direction, /rewind est 3x plus efficace que corriger manuellement (le contexte est déjà pollué par la mauvaise approche).

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 toujours "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 activés
├── settings.local.json                ← Hooks (Prettier + notification)
├── 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