10 repos GitHub pour alléger Claude Code (et faire fondre votre facture de tokens)

Claude Code, c'est génial. Mais ça coûte cher.

Si vous utilisez Claude Code au quotidien — et si vous êtes dev, vous devriez — vous avez probablement déjà vu votre facture Anthropic grimper. Une session de 30 minutes peut consommer 150 000 tokens. Multipliez par 20 jours de travail et vous êtes à 3 millions de tokens par mois. À $15/M tokens en input et $75/M en output sur Opus, ça chiffre.

Mais l'écosystème open source autour de Claude Code a explosé en 2026. Des centaines de repos GitHub proposent des optimisations — du filtrage de tokens au stockage persistant, en passant par des hooks qui transforment le comportement du CLI.

J'ai testé, installé, cassé et réparé les principaux. Voici les 10 qui valent vraiment le coup, classés par impact réel sur votre facture.

#1 — claude-mem : l'un des repos les plus populaires, la mémoire de Claude (thedotmack)

Le repo le plus populaire de tout l'écosystème Claude Code. Et pour cause : il résout le problème le plus frustrant du CLI — l'amnésie.

Claude Code oublie tout entre les sessions. Vous passez 10 minutes à lui réexpliquer l'architecture de votre projet, vos conventions, vos décisions. C'est du token brûlé à chaque session.

claude-mem ajoute une mémoire persistante cross-session via un système hybride : SQLite FTS5 pour la recherche par mots-clés + ChromaDB pour la recherche sémantique vectorielle. Les deux en local — aucun appel API externe pour les embeddings.

Le workflow en 3 couches est conçu pour économiser les tokens : search retourne un index compact (~50-100 tokens par résultat), timeline donne le contexte chronologique, et get_observations fetche les détails complets uniquement quand c'est nécessaire. Résultat : 10x moins de tokens qu'un RAG naïf qui enverrait tout d'un coup.

Mais la vraie pépite, ce sont les outils Smart Explore basés sur tree-sitter : smart_search parse l'AST de votre code dans 24 langages, smart_outline montre la structure en une vue pliée, et smart_unfold extrait uniquement les symboles demandés. Les benchmarks montrent 10 à 55x d'avantage en efficacité par rapport à la lecture de fichiers classique.

Depuis la v12.1.0, le Knowledge Agent permet de compiler des corpus de connaissances interrogeables — vous construisez une base de questions-réponses grounded sur vos observations passées.

10 à 55x plus efficace que la lecture de fichiers classique. claude-mem ne donne pas juste de la mémoire à Claude — il lui donne de l'intelligence sur votre codebase.

• 01L'un des repos les plus populaires de l'écosystème (voir les stats GitHub live pour les chiffres à jour)
• 025 hooks lifecycle : SessionStart, UserPromptSubmit, PostToolUse, Stop, SessionEnd
• 03Stockage hybride : SQLite FTS5 (mots-clés) + ChromaDB (vecteurs sémantiques)
• 04Smart Explore : tree-sitter AST, 24 langages, 10-55x plus efficace que Read
• 05Knowledge Agent : corpus compilables et interrogeables avec réponses sourcées
• 06Attention : peut atteindre 25 Go sur les gros projets — prévoir du nettoyage

#2 — RTK : le Rust Token Killer (rtk-ai)

Le deuxième repo le plus populaire, et le plus simple à comprendre. RTK est un proxy CLI écrit en Rust qui intercepte les sorties de commandes et les compresse avant qu'elles n'atteignent la fenêtre de contexte.

Le principe : quand Claude Code exécute git status, la sortie passe d'abord par RTK qui filtre le bruit — commentaires, whitespace, boilerplate, lignes dupliquées. Le LLM reçoit uniquement le signal. Moins de 10ms de latence ajoutée.

Quatre stratégies de filtrage : Smart Filtering (supprime le superflu), Grouping (agrégation par type), Truncation (garde le contexte pertinent), et Deduplication (collapse les lignes répétées avec un compteur).

Le mécanisme repose sur un hook PreToolUse dans le settings.json de Claude Code. Chaque appel Bash est réécrit de manière transparente : git status devient rtk git status. Le binaire Rust contient toute la logique — les nouvelles commandes arrivent via des mises à jour du binaire, pas du hook.

186 releases à ce jour. Compatible avec Claude Code, Cursor, Aider, Gemini CLI, Codex, Cline, Windsurf et GitHub Copilot. Créé par Patrick Szymkowiak.

Un utilisateur rapporte avoir économisé un volume considérable de tokens sur ses commandes (exemple personnel, non généralisable). Installation rapide via curl ou brew.

Commande          Tokens avant    Tokens apres    Economie
──────────────────────────────────────────────────────────
cargo test         48 200          3 950           91,8%
git status         2 100           403             80,8%
find . -name       12 400          2 690           78,3%
npm test           31 000          4 030           87,0%
grep -r            8 600           4 340           49,5%
──────────────────────────────────────────────────────────
MOYENNE sur 2 900+ commandes réelles              89,2%

$ rtk gain
  Saved: 138M tokens across 15,720 commands

#3 — context-mode : une compression massive du contexte (mksglu)

Si RTK optimisé les sorties CLI, context-mode optimisé tout le reste. C'est un serveur MCP + système de hooks créé par Mert Koseoglu qui empêche les données brutes d'entrer dans la fenêtre de contexte.

Le problème quantifié : un snapshot Playwright fait 56 Ko. 20 issues GitHub font 59 Ko. Un fichier de logs fait 45 Ko. Après 30 minutes, 40% de votre contexte est consommé par du bruit.

context-mode intercepte tout ça via une architecture "sandwich" — hooks en amont (PreToolUse, PostToolUse, PreCompact, SessionStart) + outils MCP en aval. Les données brutes sont exécutées dans un subprocess sandbox, indexées dans une base SQLite FTS5, et seuls les extraits pertinents sont renvoyés via un ranking BM25.

Exemple d'usage : une session volumineuse fortement comprimée (résultats variables selon le contenu).

L'outil clé est ctx_batch_execute : vous lancez plusieurs commandes en un seul appel, tout est auto-indexé, et la recherche se fait par mots-clés avec stemming Porter. Les titres et headings sont pondérés 5x pour les requêtes de navigation.

Sur /compact ou /clear, les données restent dans FTS5. Rien n'est perdu. Compatible avec 15 plateformes. Sans hooks (Zed, etc.) : 60% d'économie. Avec hooks : 98%.

Licence Elastic License 2.0 — gratuit, open source, aucun compte requis.

• 01Architecture sandwich : 6 hooks + 11 outils MCP dont ctx_batch_execute, ctx_search, ctx_fetch_and_index
• 02Stockage : SQLite FTS5 par projet dans ~/.context-mode/content/
• 03Ranking : BM25 avec stemming Porter et pondération des titres 5x
• 04Cache : TTL 24h, nettoyage automatique à 14 jours, hit = 0,3 Ko au lieu de 48 Ko+
• 0515 plateformes : Claude Code, Gemini CLI, Cursor, VS Code Copilot, JetBrains, Codex, Kiro...
• 06Installation : npm install -g context-mode + ajout MCP config

#4 — Caveman : le skill qui force Claude à parler comme un homme des cavernes (JuliusBrussee)

Ça paraît ridicule. Et pourtant, c'est l'optimisation avec le meilleur ratio impact/effort de cette liste.

Caveman est un vrai skill Claude Code créé par Julius Brussee. Il force Claude à répondre en prose télégraphique — supprime les articles, les formules de politesse, les reformulations de questions, les sign-offs. Laisse le code, les tool calls et les termes techniques intacts.

Trois niveaux d'intensité : lite (supprime le filler, garde les phrases), full (phrases fragmentées), ultra (abréviations + flèches). Il y a même un mode wenyan en chinois classique pour les puristes.

Pourquoi ça marche si bien : les tokens de sortie coûtent 5x plus cher que les tokens d'entrée ($75/M vs $15/M sur Opus). Et Claude Code, par défaut, est bavard. Un test sur quelques tâches de dev montre une réduction marquée des tokens de réponse par rapport au mode normal (exemple de test, non garanti).

Bonus : le sub-skill caveman-compress réécrit votre CLAUDE.md et vos fichiers mémoire en format compressé, économisant des tokens d'input à chaque future session. Les originaux sont sauvegardés en .original.md.

Une alternative encore plus simple : drona23/claude-token-efficient — un seul fichier CLAUDE.md drop-in qui impose un style terse. Benchmark à 63% de réduction moyenne sur l'output.

Réduction marquée des tokens de réponse (exemple de test, non garanti). Les tokens de sortie coûtent plus cher que ceux d'entrée. Faites le calcul.

# Installation du skill Caveman
npx skills add JuliusBrussee/caveman

# Activation
/caveman           # Mode full par defaut
/caveman lite      # Moins agressif
/caveman ultra     # Maximum compression

# Avant caveman (52 tokens) :
# "J'ai mis a jour le fichier. Voici les changements effectues :
#  j'ai modifie la ligne 42 pour corriger le bug de typage,
#  j'ai aussi ajuste l'import en ligne 3."

# Apres caveman (9 tokens) :
# "Fixed. Line 42 type error + import."

#5 — CodeGraph : votre codebase en graphe de connaissances

Catégorie émergente et probablement la plus prometteuse de 2026 : les outils qui pré-indexent votre codebase dans un graphe, pour que Claude puisse le requêter au lieu de lire les fichiers un par un.

CodeGraph (colbymchenry) est le plus mesuré du lot : 57% de tokens en moins, 71% de tool calls en moins, 46% plus rapide. Au lieu de laisser Claude faire 20 Read successifs pour comprendre une architecture, il interroge un graphe qui connaît déjà les relations entre fichiers, classes et fonctions.

Graphify (MindStudio) va plus loin avec des claims de 70x réduction de coût sur les gros repos. Code-review-graph promet 6,8x moins de tokens en moyenne et jusqu'à 49x sur les monorepos.

Le principe est le même partout : on échange des lectures de fichiers (coûteuses, linéaires) contre des requêtes de graphe (compactes, structurées). C'est du RAG appliqué au code, mais avec un index sémantique plutôt que textuel.

Cette catégorie est encore jeune — les repos changent vite — mais la direction est claire : le futur de Claude Code, c'est de ne plus jamais lire un fichier en entier.

Outil                Tokens       Tool calls    Vitesse     Source
─────────────────────────────────────────────────────────────────
CodeGraph            -57%         -71%          +46%        colbymchenry
Graphify             -70x coût    n/a           n/a         MindStudio
Code-review-graph    -6,8x avg    n/a           -49x mono   n/a
Codebase Memory MCP  -99% claim   n/a           n/a         n/a

#6 — awesome-claude-code : le catalogue de référence (hesreallyhim)

Le repo hesreallyhim/awesome-claude-code est le point d'entrée de l'écosystème. Liste curatée de tous les plugins, hooks, MCPs et outils construits autour de Claude Code.

Organisé par catégories — token optimization, memory, hooks, MCP servers, workflows — c'est la première chose à bookmarker si vous voulez explorer. La plupart des repos de cette liste ont été découverts via awesome-claude-code.

À côté, rohitg00/awesome-claude-code-toolkit est la version maximaliste : 135 agents, 35 skills, 42 commandes, 176+ plugins, 20 hooks, 15 règles, 7 templates, 14 configs MCP, 26 apps compagnon. C'est un lot-in-one qu'il faut explorer avec prudence — tout n'est pas de la même qualité.

Et pour les skills et plugins spécifiquement : jeremylongshore/claude-code-plugins-plus-skills liste 425 plugins, 2 810 skills, 200 agents, avec un CLI package manager (ccpi) pour installer ce que vous voulez.

#7 — claude_code_agent_farm : 20+ agents en parallèle (Dicklesworthstone)

Pour les projets ambitieux, lancer un seul Claude Code ne suffit pas. claude_code_agent_farm est un framework d'orchestration qui fait tourner 20+ agents Claude Code en parallèle, chacun sur une tâche spécifique.

Cas d'usage : vous lancez un audit de code avec 8 agents spécialisés (sécurité, performance, style, tests, types, deps, docs, accessibilité). Chaque agent travaille dans son propre contexte, sur sa propre branche. Un coordinateur merge les résultats.

Le monitoring se fait via tmux en temps réel — vous voyez chaque agent travailler en direct. La coordination utilise un système de locks pour éviter les conflits sur les fichiers partagés.

Dans la même catégorie : VoltAgent/awesome-claude-code-subagents propose 100+ sous-agents spécialisés pré-configurés avec un installeur.

Pour l'optimisation de tokens : le pattern subagent est crucial. Chaque sous-agent a sa propre fenêtre de contexte (200k ou 1M tokens). Les données intermédiaires restent dans le sous-agent — seul le résultat final remonte. C'est de la compression par isolation.

Le pattern subagent divise naturellement la consommation. 4 sous-agents en Haiku coûtent moins cher qu'un seul agent Opus qui fait tout.

#8 — Le système de hooks natif : l'arme nucléaire

Claude Code supporte nativement des hooks — des commandes shell exécutées en réponse à des événements (PreToolUse, PostToolUse, SessionStart, Stop, etc.). C'est le mécanisme sur lequel RTK et context-mode s'appuient.

Mais vous pouvez créer vos propres hooks sans installer quoi que ce soit. Le repo disler/claude-code-hooks-mastery propose un tutoriel complet + collection de hooks réutilisables. decider/claude-hooks fournit des scripts Python pour enforcer des pratiques de code propre.

Les hooks les plus utiles pour l'optimisation : un hook PreToolUse qui compresse les sorties longues, un hook qui bloque les git push --force, un hook SessionStart qui injecte du contexte projet, et un hook PostToolUse qui log chaque commande pour analyse.

Les hooks se configurent dans .claude/settings.json — du JSON, pas du code. Accessible même aux non-devs.

// .claude/settings.json — hook RTK
{
  "hooks": {
    "PreToolUse": [{
      "matcher": "Bash",
      "command": "rtk rewrite \"$TOOL_INPUT\""
    }]
  }
}

#9 — Firecrawl MCP : le web sans le bloat

Quand Claude Code fait un WebFetch, la page HTML brute entre dans le contexte. Une page moderne fait facilement 200 Ko de markup. C'est du suicide contextuel.

Firecrawl est un serveur MCP qui crawle et scrape les pages web, convertit le HTML en Markdown propre, et retourne uniquement le contenu utile. Au lieu de 200 Ko de HTML avec des scripts, des styles et des trackers, vous recevez 5 Ko de texte structuré.

C'est particulièrement utile pour la recherche documentaire : au lieu de lire 10 pages de doc à 200 Ko chacune (2 Mo dans le contexte), Firecrawl les convertit en 50 Ko total de Markdown pertinent.

L'intégration avec Claude Code est native via MCP. Les outils crw_scrape (page unique), crw_crawl (site entier) et crw_map (plan de site) sont disponibles directement dans la conversation.

#10 — Context7 : la doc toujours fraîche

Les connaissances de Claude s'arrêtent à mai 2025. Si vous utilisez Next.js 16, Tailwind v4 ou n'importe quelle lib récente, Claude va halluciner des APIs dépréciées. Vous corrigez, il retente, vous recorrigez — chaque aller-retour brûle des tokens.

Context7 est un serveur MCP qui fetche la documentation à jour de n'importe quelle librairie directement depuis la source. resolve-library-id pour trouver la lib, puis query-docs pour obtenir la doc à jour.

Au lieu de 3 allers-retours (hallucination > correction > re-essai > correction), vous avez 1 aller-retour avec la bonne réponse. Moins d'erreurs = moins de corrections = moins de tokens.

C'est de l'optimisation indirecte mais très réelle. Et ça évite le pattern toxique où Claude "invente" une API, vous déployez, ça casse en prod, vous debuggez pendant 30 minutes — 50 000 tokens brûlés pour un import incorrect.

La stack optimale : les 5 indispensables

Vous n'avez pas besoin des 10. Voici la combinaison que j'utilise au quotidien et qui divise ma consommation par 3 à 4 :

Quelques minutes d'installation. Une facture qui peut nettement baisser (résultats variables). Un excellent ROI pour un dev.

OUTIL               TYPE               ECONOMIE          INSTALL
────────────────────────────────────────────────────────────────
RTK                 CLI output filter   ~89% sur CLI      curl | sh
context-mode        Context compress    ~98% sur contexte  npm -g
Caveman             Output réduction    ~65% sur réponses  npx skills add
claude-mem          Memoire + AST       ~55x sur lectures  npx claude-mem
Context7            Doc fraiche         ~70% sur retries   MCP config
────────────────────────────────────────────────────────────────
COMBINE                                 Facture /3 a /4    ~15 min total

Bonus : mesurez avant d'optimiser

Trois repos pour voir où partent vos tokens avant de les optimiser.

phuryn/claude-usage : dashboard local avec Chart.js, filtrage par modèle, progress bar pour les abonnés Pro/Max. Léger et efficace.

hoangsonww/Claude-Code-Agent-Monitor : le monitoring temps réel avancé — SQLite, React, WebSockets. Suit les sessions, l'activité des agents, l'utilisation des outils, l'orchestration des sous-agents. App MacOS native + extension VS Code.

deshraj/Claud-ometer : zéro télémétrie, tout reste local. Visibilité complète sur les coûts, sessions et projets.

Et bien sûr, rtk gain --graph vous donne un graphe ASCII de vos économies RTK sur les 30 derniers jours.

La règle : on ne peut pas optimiser ce qu'on ne mesure pas. Commencez par là.

L'écosystème ne fait que commencer

En janvier 2026, il n'y avait quasiment rien autour de Claude Code. Quelques mois plus tard, claude-mem, RTK et context-mode comptent parmi les repos les plus populaires, et awesome-claude-code liste de nombreux projets.

L'open source fait ce qu'il fait de mieux : combler les trous laissés par l'éditeur. Anthropic a construit un excellent CLI. La communauté l'a rendu économiquement viable au quotidien.

Si vous utilisez Claude Code sans RTK et sans context-mode en 2026, c'est comme utiliser VS Code sans extensions en 2020. Ça marche. Mais vous passez à côté de 80% de l'expérience.

Installer ces outils prend 15 minutes. L'impact sur votre facture est immédiat et mesurable. Pas de promesse, pas de hype — juste du Rust, du SQLite et du bon sens.

Et si vous ne retenez qu'une seule chose de cet article : les tokens de sortie coûtent 5x plus cher que les tokens d'entrée. Tout ce qui réduit le bavardage de Claude est de l'or.

Les tokens de sortie coûtent 5x plus cher que les tokens d'entrée. Tout ce qui réduit le bavardage de Claude est de l'or.