# CLAUDE.md — Bootstrap environnement Claude Code

> Contexte spécialisé pour Claude Code. Reconstitue un environnement complet sur un nouvel ordinateur : `~/.claude/CLAUDE.md`, `go-best-practices.md`, `settings.json`, statusline, plugins et mémoires persistantes.

Prérequis système : `bash 4+`, `jq`, `tmux`, `python3`

---

## Quand utiliser ce contexte

- ✅ Nouveau poste de travail ou réinstallation OS
- ✅ Premier setup Claude Code sur une machine sans configuration existante
- ✅ Audit de l'environnement actuel — vérifier que tout est en place
- ✅ Partager sa configuration avec un autre développeur
- ❌ Modifier la configuration d'un projet existant — utiliser le CLAUDE.md du projet

---

## Section 1 : ~/.claude/CLAUDE.md

```markdown
# Global Claude Code Instructions

## Mise à jour CLAUDE.md & mémoire
**Quoi ajouter** : ce qui n'est pas déductible du code — gotchas, contraintes métier invisibles, conventions déviantes, décisions d'archi non-évidentes.
**Quoi ne pas ajouter** : ce que Claude redécouvre en lisant le code.
**Format** : 1 règle = 1 ligne. Cible : < 80 lignes par fichier.
**Segmentation** : `CLAUDE.{domaine}.md` pour les sections rarement utiles ; référencer en texte brut.
**`.claudeignore`** : exclure vendor/, node_modules/, assets/, tmp/, fichiers générés et binaires.
**MAJ auto CLAUDE.md** : en fin de tâche, signaler ce qui mérite d'être ajouté. Filtre : (1) non-déductible du code, (2) se reproduira en future session, (3) pas spécifique au contexte immédiat.
**MAJ auto mémoire** : même déclencheur. Test : *"Si je supprime et relis le code, manquera-t-il quelque chose ?"* Types : user, feedback (Règle → Why → How to apply), project, reference. Ne pas sauvegarder : état temporaire, ce qui est déjà dans CLAUDE.md.

## Références
Go : `~/.claude/go-best-practices.md`

## Plugins disponibles
Plugins installés : superpowers, code-simplifier, frontend-design, playground, context7, playwright, gopls-lsp.
Si un besoin spécifique émerge (ex: revue sécurité, gestion CLAUDE.md), installer via `claude plugins install <nom>@claude-plugins-official`. Plugins connus disponibles : feature-dev, code-review, security-guidance, claude-md-management.

## Restrictions
- **INTERDIT** lire `.env`/`.env.*` — exception `.env.example`, `.env.local.example`
- **INTERDIT** `git add` sans permission explicite — l'utilisateur contrôle le staging
- **INTERDIT** mentionner Claude/AI dans commits, PR, branches, commentaires code
- **AUCUN** `Co-Authored-By: Claude ...`

## Principes Conception
**Règle d'or** : toujours la solution la plus simple qui fonctionne. Équilibre : Simplicité > Testabilité > Robustesse (sauf composants critiques).

**4 Questions AVANT refactoring** : (1) Simplifie vraiment ? (2) Testabilité vaut la complexité ? (3) Même résultat plus simplement ? (4) Sur-ingénierie "au cas où" ? → Si oui, stop.

**YAGNI** : abstraire seulement si 3+ implémentations existent, logique complexe (50+ lignes), ou mock apporte vraie valeur.

**Red flags → STOP** : struct pour grouper fonctions, interface à 1 implémentation, séparation multi-fichiers sans raison, abstraction prématurée, code plus complexe après refactoring.

## Délégation Opus / Sonnet
Opus = tech lead : analyse, planifie, décide, review, délègue via Agent tool.
Sonnet (Agent) = exécution : écriture code > 5 lignes, recherche large, refacto, tests.

**Opus directement** : Read/Grep/Glob < 3 fichiers, modifications < 5 lignes, décisions archi, review résultats, réponses conversationnelles.
**Opus délègue** : code > 5 lignes, recherche exploratoire, refactoring, tests, tâches mécaniques. Indépendantes → parallèle.
**Règles** : prompt Sonnet = contexte complet ; relire résultat avant présentation ; ne jamais déléguer une décision d'archi ; ne pas lire fichiers > 200 lignes dans contexte Opus.
```

---

## Section 2 : ~/.claude/go-best-practices.md

> Référence — consulter lors de reviews ou en cas de doute.

### Simplicité d'abord
- Fonctions courtes (20-30 lignes max), 2-3 params max, sinon struct
- Early return + guard clauses, jamais de nesting profond
- Accept interfaces, return structs
- "A little copying is better than a little dependency" — ne pas abstraire pour 2 usages
- Make the zero value useful
- 1 fichier si < 500 lignes et cohésion forte
- Newspaper layout : publics en haut, helpers privés en bas

### Error Handling

```go
// ✅ Wrapper avec contexte
return fmt.Errorf("failed to process item %s: %w", itemID, err)
// ✅ errors.Is / errors.As — pas type assertions
// ❌ return err — perd le contexte
// ❌ panic(err) — sur erreurs normales
```

**Resilient Execution** (partial success > total failure) :

```go
for _, item := range items {
    if err := process(item); err != nil {
        slog.Error("Failed item, continuing", "item", item.ID, "error", err)
        continue
    }
    successCount++
}
```

### Concurrency

```go
// Goroutine avec exit propre
go func() {
    for {
        select {
        case val := <-ch: process(val)
        case <-ctx.Done(): return
        }
    }
}()

// Mutex pour shared data
type SafeCounter struct {
    mu    sync.Mutex
    count int
}
func (c *SafeCounter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}
```

### PostgreSQL

```go
// ✅ Prepared statements (jamais string concatenation)
err := db.GetContext(ctx, &user, "SELECT * FROM users WHERE email = $1", email)
// Transaction : defer tx.Rollback() avant les opérations, tx.Commit() à la fin
```

### Context
- Toujours propager `ctx` — jamais remplacer par `context.Background()`

### Testing

```go
// Stdlib testing uniquement — PAS testify — assertions manuelles
// Table-driven avec → dans les noms
tests := []struct {
    name    string
    input   string
    wantErr bool
}{
    {"valid → ok", "ok", false},
    {"empty → error", "", true},
}
```

### Checklist Code Review
- [ ] Pas de SQL string concatenation
- [ ] Erreurs wrappées avec contexte (`fmt.Errorf("... %w", err)`)
- [ ] Channels fermés, goroutines terminables (`ctx.Done()`)
- [ ] Mutex sur shared data, context propagé
- [ ] Pas de `panic` sur erreurs normales
- [ ] Tests passent, logging structuré `slog`
- [ ] Resilient execution (continuer sur erreur d'un item)

### Anti-Patterns
- `file, _ := os.Open(...)` — ne jamais ignorer les erreurs
- Naked returns dans fonctions > 10 lignes
- `close(ch)` oublié → goroutine leak
- Interface avec 1 seule implémentation (YAGNI)
- God object / struct qui fait tout
- `map[string]string` non trié → non-déterministe, `sort.Strings` avant join
- Magic numbers → constantes nommées
- Code mort/commenté → supprimer (Git garde l'historique)
- Logging `log.Printf` → `slog.Info("msg", "key", val)`

---

## Section 3 : ~/.claude/settings.json

```json
{
  "model": "sonnet",
  "hooks": {
    "SessionStart": [
      {
        "matcher": "startup|resume",
        "hooks": [
          {
            "type": "command",
            "command": "bash ~/.claude/hooks/statusline.sh < /dev/null"
          }
        ]
      }
    ]
  },
  "statusLine": {
    "type": "command",
    "command": "bash ~/.claude/hooks/statusline.sh"
  },
  "enabledPlugins": {
    "superpowers@claude-plugins-official": true,
    "code-simplifier@claude-plugins-official": true,
    "frontend-design@claude-plugins-official": true,
    "playground@claude-plugins-official": true,
    "context7@claude-plugins-official": true,
    "playwright@claude-plugins-official": true,
    "gopls-lsp@claude-plugins-official": true
  },
  "effortLevel": "medium",
  "autoUpdatesChannel": "latest"
}
```

---

## Section 4 : ~/.claude/settings.local.json

```json
{
  "permissions": {
    "allow": [
      "Bash(chmod +x:*)",
      "Bash(jq:*)",
      "Bash(curl:*)",
      "Bash(python3:*)",
      "Bash(touch:*)",
      "Bash(bash:*)",
      "Bash(kill:*)",
      "Bash(tmux send-keys:*)",
      "Bash(tmux kill-session:*)",
      "Bash(tmux ls)",
      "Bash(tmux capture-pane:*)",
      "Bash(gh api:*)",
      "Bash(gh auth:*)",
      "Bash(gh release:*)",
      "Bash(git config:*)",
      "Bash(git branch:*)",
      "Bash(git push:*)",
      "Bash(git tag:*)",
      "mcp__plugin_context7_context7__resolve-library-id",
      "mcp__plugin_context7_context7__query-docs",
      "WebSearch",
      "WebFetch(domain:github.com)"
    ]
  }
}
```

> **Note** : `Bash(bash:*)` autorise tout script bash — c'est très permissif. Volontaire.

---

## Section 5 : ~/.claude/hooks/statusline.sh

Repo : **https://github.com/ohugonnot/coder-proprement**

```bash
# Télécharger et installer
mkdir -p ~/.claude/hooks
curl -o ~/.claude/hooks/statusline.sh \
  https://raw.githubusercontent.com/ohugonnot/coder-proprement/main/statusline.sh
chmod +x ~/.claude/hooks/statusline.sh
```

Prérequis : `bash 4+`, `jq`, `tmux`, `python3`

---

## Section 6 : Mémoires persistantes

### ~/.claude/projects/\<projet\>/memory/MEMORY.md

```markdown
# MEMORY

## Feedback
- [Segmentation CLAUDE.md et .claudeignore](./feedback_claudemd_segmentation.md) — approche optimisation tokens
```

### ~/.claude/projects/\<projet\>/memory/feedback_claudemd_segmentation.md

```markdown
---
name: Segmentation CLAUDE.md et .claudeignore
description: Règles d'optimisation CLAUDE.md — cibles réelles, filtres et comportements
type: feedback
---

CLAUDE.md principal < 80 lignes ; sous-fichiers `CLAUDE.{domaine}.md` pour sections rarement utiles ; `.claudeignore` pour vendor/, node_modules/, assets/, fichiers générés.

**Why:** Testé sur gofab — 70 lignes suffisent. 150 lignes trop permissif. Tout ce qu'un `ls` ou lecture de fichier donne n'a pas sa place.

**How to apply:** Filtre : "Si je supprime cette ligne et relis le code, manquera-t-il quelque chose ?" Si non → ne pas ajouter. Références aux sous-fichiers en texte brut (jamais `@`).
```

---

## Section 7 : Installation

```bash
# 1. Créer l'arborescence
mkdir -p ~/.claude/hooks

# 2. Copier les fichiers (contenu des sections ci-dessus)
# ~/.claude/CLAUDE.md
# ~/.claude/go-best-practices.md
# ~/.claude/settings.json
# ~/.claude/settings.local.json
# ~/.claude/hooks/statusline.sh && chmod +x ~/.claude/hooks/statusline.sh

# 3. Créer ~/.claudeignore à la racine du projet
cat > .claudeignore <<'EOF'
# Données runtime
uploads/
scripts/.retro-state.json
scripts/.veille.lock

# Outils
.playwright-mcp/

# Plans/specs générés
docs/superpowers/

# Assets binaires
assets/images/
assets/plugins/

# Commentaires blog
blog/comments/
EOF

# 4. Créer ~/.claude/commands/audit-memory.md
mkdir -p ~/.claude/commands
cat > ~/.claude/commands/audit-memory.md <<'EOF'
Audite les fichiers mémoire dans `.claude/projects/.../memory/`
(et `~/.claude/memory/` pour la mémoire globale si elle existe).

Pour chaque fichier mémoire :
1. Le contenu est-il encore exact ?
2. Est-il non déductible du code ou du CLAUDE.md ?
3. Le type est-il correct ? (user / feedback / project / reference)
4. La description dans le frontmatter est-elle assez précise ?

Cohérence globale : doublons, contradictions, mémoires project obsolètes, MEMORY.md à jour ?

Résultat en tableau : Fichier | Problème | Action recommandée
Puis applique les corrections.
EOF

# 5. Installer les plugins
claude plugins install superpowers@claude-plugins-official
claude plugins install code-simplifier@claude-plugins-official
claude plugins install frontend-design@claude-plugins-official
claude plugins install playground@claude-plugins-official
claude plugins install context7@claude-plugins-official
claude plugins install playwright@claude-plugins-official
claude plugins install gopls-lsp@claude-plugins-official

# Plugins disponibles si besoin ponctuel :
# claude plugins install feature-dev@claude-plugins-official
# claude plugins install code-review@claude-plugins-official
# claude plugins install security-guidance@claude-plugins-official
# claude plugins install claude-md-management@claude-plugins-official

# 6. Prérequis système
sudo apt install jq tmux python3

```

---

*Last updated: 2026-03 — Contexte associé à l'article [Réinstaller son environnement Claude Code](https://www.web-developpeur.com/blog/reinstaller-env-claude-code).*