Context Guard -- Economie de tokens

Le contexte est une ressource finie (200k tokens). Les tool outputs representent ~84% de l'usage. Chaque Read, chaque Bash consomme du budget. Ce skill guide l'economie a chaque etape.

Regles permanentes

1. Ne pas relire ce qui est deja en contexte

• CLAUDE.md est charge automatiquement comme instructions projet -- ne JAMAIS le relire avec Read
• Un fichier lu dans cette conversation est deja en memoire -- ne pas le relire sauf si modifie entre-temps
• Avant un Read, se demander : "J'ai deja cette info ?"

2. Grep cible au lieu de Read entier

Besoin	Mauvais (tokens++)	Bon (tokens--)
Trouver une version	Read CHANGELOG.md (260 lignes)	Grep "## \\[" CHANGELOG.md (10 lignes)
Verifier une config	Read package.json (100 lignes)	Grep "version|name" package.json (2 lignes)
Chercher un pattern	Read fichier.ts (500 lignes)	Grep "functionName" fichier.ts (5 lignes)
Localiser un fichier	Read de plusieurs fichiers	Glob "**/*.test.ts" (liste de chemins)

Regle : si tu as besoin de < 20% du fichier, utilise Grep. Read entier seulement si tu as besoin de comprendre la structure complete.

3. Bash optionnels : toujours ; exit 0

Un Bash qui echoue dans un batch parallele annule TOUS les autres appels du batch (cascade).

# MAL -- si gh absent, cascade sur tout le batch
gh issue list --limit 5

# BIEN -- jamais d'erreur, resultat vide si echec
gh issue list --limit 5 2>/dev/null; exit 0

Regle : toute commande qui peut echouer (reseau, outil optionnel, fichier absent) → 2>/dev/null; exit 0.

4. Read sur fichier optionnel : jamais en parallele

# MAL -- si .continue-here.md absent, cascade
Read(TODO.md) + Read(.continue-here.md) + Bash(git status)

# BIEN -- fichier optionnel via Bash
Read(TODO.md) + Bash(cat .continue-here.md 2>/dev/null; exit 0) + Bash(git status)

Regle : Read uniquement sur les fichiers qui existent a coup sur. Fichier incertain → Bash(cat ... 2>/dev/null; exit 0) ou Glob d'abord.

5. Paralleliser au maximum, sequentialiser au minimum

• Appels independants → un seul batch parallele
• Resultats necessaires pour la suite → batch sequentiel
• Objectif : 2 rounds max (collecter → ecrire), pas 4+

Seuil 70% -- mode economie

Quand le contexte depasse ~140k tokens (70% de 200k), appliquer des mesures plus agressives :

Action	Normal	Mode economie (>70%)
Explorer du code	Read fichiers	Subagent Explore (contexte isole)
Recherche large	Grep + Read	Agent en fond (resultat resume)
Fichier > 200 lignes	Read entier	Read avec offset/limit sur la zone cible
Plan d'implementation	Texte en conversation	Ecrire dans plans/ (hors contexte)

Subagents pour les explorations

Les subagents ont leur propre contexte isole. Utiliser un Agent pour :

• Explorer un codebase large (> 5 fichiers a lire)
• Rechercher des patterns dans beaucoup de fichiers
• Lire de la documentation longue (CHANGELOG, README externes)
• Toute tache qui genererait > 10k tokens de tool output

Le subagent renvoie un resume compact → economie nette.

Placement strategique des infos

Le modele accorde plus d'attention au debut et a la fin du contexte (effet "lost-in-middle"). En pratique :

• Instructions critiques (STOP, regles absolues) → en haut du prompt
• Exemples, details → au milieu (OK si moins d'attention)
• Rappels, actions finales → en fin de prompt

Anti-patterns

Anti-pattern	Impact	Alternative
Lire CLAUDE.md avec Read	+5-10k tokens gaspilles	Deja en contexte
Read entier pour chercher un mot	+2-8k tokens	Grep cible
Bash sans ; exit 0 en parallele	Cascade = tous les appels annules	Toujours ; exit 0
Read sur fichier peut-etre absent	Cascade si absent	Bash cat ou Glob
Tout faire en conversation principale	Contexte sature en 15min	Subagents pour les taches lourdes
Relire un fichier deja lu	Doublon pur	Se fier au contexte existant
4+ rounds sequentiels	Lent + tokens	Tout paralleliser en 2 rounds

Ce skill ne fait PAS

• Ne bloque pas le travail -- signale et guide
• Ne force pas les subagents -- les recommande quand pertinent
• Ne s'applique pas aux conversations courtes sans outil