Pourquoi votre agent IA relit le même fichier 30 fois par session — et ce que ça vous coûte
Chaque agent IA de coding moderne brûle 34 à 88 % de son budget input en renvoyant des fichiers qu'il connaît déjà. Voici pourquoi la boucle existe, ce que ça pèse en dollars, et le correctif le moins cher.
Ouvrez vos logs Claude Code après une session refactor typique. Filtrez sur read app.py. Comptez.
Sur un fichier de 400 lignes, vous trouverez cette même ligne 22 à 34 fois sur une session de 90 minutes. Le fichier n'a presque pas bougé entre les lectures — un import ajouté, une fonction renommée, trois lignes déplacées. Mais l'agent a renvoyé chaque octet, à chaque fois.
C'est la boucle. Et c'est là que part 34 à 88 % de votre budget de tokens en entrée.
Le calcul
Un fichier Python de 400 lignes pèse environ 6 000 tokens une fois sérialisé comme les agents le font. Claude Sonnet 4.6 facture 3,00 $ par million de tokens en entrée.
| Reads / session | Tokens envoyés | Coût (par session) |
|---|---|---|
| 5 | 30 000 | 0,09 $ |
| 15 | 90 000 | 0,27 $ |
| 30 | 180 000 | 0,54 $ |
| 50 | 300 000 | 0,90 $ |
Multipliez par une semaine de sessions refactor et vous arrivez à 20 à 40 $ par dev et par semaine rien que pour ce même fichier renvoyé. Sur une équipe de 10, ça fait un discret 10 000 $/an pour du contenu que l'agent a déjà.
Pourquoi l'agent ne le mémorise pas ?
Trois raisons, par ordre d'importance.
1. L'agent n'a pas de mémoire de travail entre appels d'outil
Chaque appel read dans Claude Code est traité comme une opération indépendante. La "mémoire" de l'agent, c'est ce qui est dans sa fenêtre de contexte — et les fenêtres de contexte se compactent (tronquées, résumées, larguées) dès que la conversation s'allonge. Une fois la compaction passée, l'agent doit relire le fichier parce que sa copie en contexte a disparu.
2. L'écosystème de hooks suppose l'absence d'état
Les hooks PreToolUse / PostToolUse de Claude Code se déclenchent à chaque appel d'outil. Il n'y a pas de primitive native "j'ai déjà envoyé ce fichier il y a 4 minutes et il n'a pas changé". Chaque hook démarre à zéro.
3. La pression sur le pricing est côté modèle, pas côté tooling
Anthropic propose le prompt caching au niveau de l'API — mais le cache s'applique à la structure du payload de requête, pas au modèle mental que l'agent a de votre codebase. La clé de cache, c'est ce que vous avez envoyé, pas ce que vous avez envoyé qui n'a pas changé.
Donc le modèle n'a aucun incitatif à flagger les re-reads. Le tooling n'a aucune infrastructure pour les tracker. Vous payez à chaque fois.
Ce que veut dire "delta read interception"
DRIP se place entre votre agent et le système de fichiers avec trois règles :
- Première lecture d'un fichier → contenu complet (compressé sémantiquement quand possible).
- Re-read d'un fichier inchangé → un sentinel
[unchanged]d'environ 12 tokens. - Re-read d'un fichier modifié → un unified diff (
--- old / +++ new / @@ hunks) — typiquement 200 à 400 tokens, indépendamment de la taille du fichier.
Le modèle mental de l'agent ne change pas. Le protocole ne change pas. L'outil read de l'agent retourne exactement l'info nécessaire pour mettre à jour sa compréhension — ni plus, ni moins.
Un fichier de 400 lignes qui se prend 30 re-reads coûte maintenant :
1 × 6 000 tok (premier read)
+ 24 × 12 tok (sentinels unchanged)
+ 5 × 350 tok (deltas après édits)
= 7 738 tokens
Contre les 180 000 naïfs. Soit 96 % de réduction sur le même workflow.
Et les cycles d'édition ?
Les édits rendent le calcul plus intéressant. Quand l'agent écrit dans un fichier puis le re-lit (très courant — les agents aiment "vérifier" leurs propres écritures), DRIP renvoie un certificat d'édition : hash + plages de lignes touchées + noms de symboles. ~390 octets. L'agent obtient la confirmation que l'édit a atterri sans avoir à relire 600 lignes qu'il vient d'écrire.
Cette seule optimisation représente ~15 % des économies totales sur les sessions typiques — les agents vérifient leurs propres écritures bien plus souvent que les développeurs le réalisent.
Le correctif le moins cher
Il y a exactement deux façons d'arrêter de payer pour les re-reads :
- Arrêter d'utiliser des agents IA pour les refactors. (Personne ne va faire ça.)
- Intercepter les lectures au niveau du protocole avant qu'elles n'atteignent le modèle.
DRIP, c'est l'option 2. Un seul binaire Rust de 4 MB, tourne entièrement sur votre machine, zéro appel réseau, zéro télémétrie. brew install drip-cli/drip/drip && drip init -g le branche dans Claude Code en 8 secondes.
Vous pouvez vérifier les économies en direct dans votre barre de menus avec DripMeter, l'app macOS compagnon — ou juste drip meter depuis le terminal.