Graft : la couche de contexte qui rend Claude Code moins cher (et plus précis)

TL;DR — Graft en une minute

• Ce que c’est : Graft (trailhq, MIT, ~5,8k étoiles), une couche de contexte pour agents de code (Claude Code, Cursor, Codex, Gemini). Il mappe ton codebase en un graphe markdown persistant.
• Le principe : au lieu de laisser l’agent grep à l’aveugle à chaque session, Graft injecte les bons bouts de code dans le prompt + reconstruit le graphe après chaque tour. Câblage via hooks dans .claude/.
• Gain revendiqué (par le projet) : benchmark SWE-bench 33/50 vs 27 baseline, -23 % tokens, -32 % temps, « jusqu’à 4× moins cher ».
• Le catch : ce sont leurs chiffres (mesure chez toi) ; une couche de hooks de plus à maintenir ; utile sur gros codebase, overkill sur un script.
• Notre verdict : à tester — vrai ROI potentiel (tokens = argent) si tu tournes beaucoup de Claude Code sur des projets conséquents.

À chaque nouvelle session, ton agent de code repart à zéro : il grep à l’aveugle, tombe dans des impasses, redécouvre ton archi… et brûle des tokens pour ça. Graft attaque exactement ce gaspillage : il donne à l’agent une carte persistante de ton code, pour qu’il sache où regarder direct. Moins de tokens, plus de précision — c’est la promesse. On regarde ce qu’elle vaut.

Le problème : l’agent qui redécouvre ton code à chaque fois

Claude Code (ou Cursor, Codex) n’a pas de mémoire de ton codebase entre les sessions. Résultat, à chaque tâche : recherche aveugle, mauvais fichiers ouverts, câblage deviné, contexte perdu quand la fenêtre sature. Tu paies des tokens pour que l’agent réapprenne ce qu’il savait hier. Sur un gros repo, c’est du gaspillage massif.

Ce que fait Graft

• Il construit un graphe markdown persistant de ton codebase (graft init demande quels agents câbler, génère le dossier graft/, pose une statusline + des hooks dans .claude/).
• À chaque prompt, il injecte les nœuds pertinents (les bons bouts de code) au lieu de laisser l’agent chercher.
• Après chaque tour, il reconstruit le graphe en arrière-plan → le contexte reste frais.
• Agnostique : Claude Code, Cursor, Codex, Gemini. MIT, TypeScript.

Les chiffres (revendiqués par le projet)

Sur leur benchmark SWE-bench Verified : Graft résout 33/50 instances vs 27 pour Claude Code seul, avec -23 % de tokens et -32 % de temps ; ils annoncent « jusqu’à 4× moins cher et 3× plus rapide ». À prendre pour ce que c’est : des chiffres du projet, sur leur setup. Le vrai test, c’est le tien.

Le catch honnête

• Ce sont LEURS benchmarks. Les gains dépendent de ton codebase, tes tâches, ton modèle. Mesure chez toi (ccusage est parfait pour ça) avant de crier victoire.
• Encore une couche dans .claude/. Graft pose des hooks + une statusline + un dossier graft/. C’est de la complexité et une surface de confiance en plus dans ton setup Claude Code — à assumer.
• Utile SI ton codebase est conséquent. Sur un petit projet ou un script, l’agent trouve déjà tout seul : Graft = overkill. Le gain croît avec la taille du repo.
• Maintenance : le graphe doit rester à jour (Graft le reconstruit, mais c’est un process de plus qui tourne).

Pour qui c’est vraiment utile

• Tu tournes beaucoup de Claude Code sur de gros codebases (produits, monorepos) : le token = de l’argent ; -20 à -40 % à l’échelle, c’est concret.
• Tu en as marre que l’agent redécouvre ton archi à chaque session : c’est exactement le problème visé.
• Tu veux mesurer et optimiser ta conso Claude Code : Graft (le levier) + ccusage (la mesure) = bon duo.

À l’inverse : pour du one-shot, des petits repos, ou si tu n’as pas de problème de tokens/contexte, c’est de la complexité pour rien.

Notre verdict : à tester

Graft s’attaque à un vrai gaspillage — l’agent qui repart à zéro à chaque session — et le fait proprement (graphe persistant, injection ciblée, agnostique). Pour qui code beaucoup avec Claude Code sur des projets conséquents, le ROI potentiel est réel : les tokens, c’est de l’argent.

Les deux réserves : les gains annoncés sont ceux du projet (mesure chez toi), et c’est une couche de hooks de plus à installer et maintenir. Traité comme un levier d’optimisation sur gros codebase — pas comme un gadget à empiler — il mérite un vrai test.

Points de vigilance

• Benchmarks = ceux du projet : mesure ton gain réel (ccusage) avant de conclure.
• Couche en plus : hooks + statusline + dossier graft/ dans .claude/ = complexité + confiance à accorder.
• Rentabilité liée à la taille : gros codebase = gain réel ; petit projet = overkill.
• Attention aux miroirs : le repo canonique est trailhq/Graft (MIT) — plusieurs forks portent la même description.