Comment réduire les tokens Claude Code efficacement ?

Résumer ce contenu avec :

Perplexity ChatGPT Claude Grok Mistral

Réduire les tokens Claude Code passe par une gestion stricte du contexte, des instructions courtes et des outils de suivi. J’explique comment nettoyer, compacter, scoper les règles, ajuster l’autocompaction et automatiser la surveillance pour diminuer la facture sans sacrifier la qualité.

Pourquoi le contexte fait monter la facture de tokens ?

Le coût augmente parce que chaque élément du contexte (fichiers ouverts, sorties de commandes, instructions système, historique de chat) est encodé en tokens et facturé au modèle ; plus le contexte est gros, plus la consommation et le coût augmentent.

Qu’est-ce qu’un token ? Un token est une unité de texte utilisée par le modèle pour encoder les entrées et sorties. En pratique, un token correspond en moyenne à environ 4 caractères ou ~0,75 mot en anglais. Chaque token consommé fait monter la facture puisque le modèle facture en fonction du volume de tokens traités.

Read moreLes frameworks LLM sont-ils dépassés par les Agent SDKs ?

Qu’est-ce que la fenêtre de contexte (context window) ? La fenêtre de contexte est la quantité maximale de tokens que le modèle peut considérer en une seule requête. Tout ce qui est envoyé — instructions système, fichiers, historique, sorties de commandes — est concaténé (additionné) et encodé dans cette fenêtre pour produire la réponse. La taille totale de ce contexte est recomptée et facturée à chaque requête.

Pourquoi tout est additionné à chaque requête ? Parce que les modèles ne conservent pas d’état externe implicite entre requêtes : ils reçoivent en entrée l’ensemble du contexte nécessaire pour générer la réponse. Ainsi, répéter de longues instructions ou renvoyer de gros fichiers multiplie les tokens envoyés et facturés.

Exemples concrets de sources de tokens :

• Fichiers sources (code, Markdown) : Peuvent être volumineux si on envoie des dépôts entiers.
• Logs de build et sorties de tests : Souvent verbeux et rarement utiles en intégralité.
• Instructions longues ou templates système : Instructions détaillées réinjectées à chaque requête.
• Historique de conversation : Chaque échange s’ajoute et pèse sur la fenêtre de contexte.

Read moreComment Google AI Studio intègre Firebase en production ?

Anthropic recommande de garder le fichier d’instructions principal court (moins de 200 lignes) et indique l’existence d’un seuil d’autocompaction par défaut d’environ 95% pour réduire automatiquement le contexte. Le compromis qualité/coût dépend du degré de détail nécessaire : résumer ou sélectionner réduit fortement les tokens mais peut enlever du contexte utile. Pour mesurer l’impact, utiliser les commandes /context et /usage comme outils de diagnostic afin d’observer quels éléments consomment des tokens et suivre les économies obtenues.

Comment nettoyer et compacter le contexte au quotidien ?

Nettoyer et compacter le contexte se fait en vidant les sessions entre tâches, en condensant l’historique utile et en abaissant les seuils d’autocompaction pour agir plus tôt.

Les tokens représentent l’espace mémoire utilisé par le modèle pour le contexte. Autocompaction désigne le processus automatique qui résume ou élimine l’historique quand l’utilisation atteint un certain pourcentage (seuil). J’applique cinq tactiques simples et répétables pour garder le contexte maîtrisé.

Read moreComment fonctionnent les Claude Code Skills ?

Voici les tactiques pratiques :

• Vider les sessions entre tâches : Utiliser /clear pour supprimer l’historique inutile et libérer immédiatement des tokens.
• Conserver un label utile : Faire un /rename avant de vider si l’on veut garder un repère lisible pour la session.
• Compacter l’historique utile : Utiliser /compact pour résumer l’historique tout en conservant objectifs, fichiers modifiés, erreurs et décisions.
• Abaisser le seuil d’autocompaction : Mettre une variable d’environnement pour déclencher la compaction plus tôt (ex. 70 %, 50 % pour workflows très bruyants).
• Surveiller l’usage : Contrôler régulièrement le contexte et l’usage avec /context et /usage, et afficher une ligne de statut live.

Exemples pratiques et snippets :

• settings.json snippet : {« statusLine »: true, « showModel »: true}
• env var : export CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=70
• bash sequence : claudectl /rename « Feature A » && claudectl /clear && claudectl /compact

Extrait de ~/.claude/settings.json pour activer la ligne de statut :

{
  "statusLine": true,
  "showModel": true
}

Read moreQuels AI agents faut-il construire pour progresser en IA ?

Exemple d’appel jq pour afficher le pourcentage de contexte et le modèle (jq est un utilitaire de traitement JSON).

claudectl /usage --json | jq -r '"Context: \(.context.percent)%  Model: \(.model)"'

Séquence bash simple :

claudectl /rename "Feature A" && claudectl /clear && claudectl /compact

Comment optimiser les instructions et les règles du projet ?

Réduire et scoper les instructions permet d’éviter de réinjecter des règles inutiles à chaque session et diminue fortement la consommation récurrente de tokens.

Garder le fichier global d’instructions (CLAUDE.md) court et centré sur les faits critiques évite des redondances coûteuses. Je limite CLAUDE.md à les politiques de sécurité, les contraintes légales et les données de contexte indispensables. L’objectif pratique est de rester sous 200 lignes pour rester lisible et économique en tokens.

Créer des règles scoped par chemin dans .claude/rules/ permet que seules les règles pertinentes se chargent lors de l’édition d’un sous-système. Scoped signifie lier une règle à un pattern de fichiers (ex : src/ui/**) pour n’activer que ce qui concerne l’UI et ne pas payer pour des règles backend inutiles.

Isoler les workflows spécialisés dans .claude/skills/<nom>/SKILL.md et ajouter un flag de désactivation évite le chargement systématique. Un « skill » (compétence ou module) est un ensemble d’instructions ou d’outils pour une tâche précise ; le front-matter permettra de l’activer à la demande.

Privilégier des instructions factuelles et éviter les longues consignes de style répétitives réduit le nombre de tokens et améliore la consistance. Remplacer « Sois concis, clair et empathique » par des règles opérationnelles et mesurer les effets.

Exemples concrets :

# Exemple minimal de CLAUDE.md (3-6 lignes)
Project: AcmeApp
Scope: Règles de sécurité et restrictions d'accès aux données sensibles.
Timezone: Europe/Paris

Structure de dossier exemple :

• .claude/rules/ui.md scoped to src/ui/**
• .claude/rules/api.md scoped to src/api/**
• .claude/skills/lint/SKILL.md

# Exemple de .claude/rules/ui.md
scope: "src/ui/**"
rules:
  - "Ne pas modifier le design system sans approbation"
  - "Valider l'accessibilité WCAG 2.1 (contraste, labels)"

--- 
enabled: false
name: "lint"
description: "Linting et corrections automatiques pour le JS/TS"
---
# SKILL: lint
Utiliser eslint + prettierrc. Ne s'exécute que si enabled: true.

Quels réglages, outils et templates utiliser pour automatiser les économies ?

Combinez seuils d’autocompaction adaptés, surveillance continue, templates de prompt minimalistes et mécanismes d’activation conditionnelle de skills pour automatiser les économies sans casser la qualité.

Automatiser les économies revient à appliquer des règles simples et traçables : compacter automatiquement le contexte quand il dépasse un seuil, alerter quand l’usage grimpe, tronquer ou résumer les logs, et n’activer les agents coûteux que sur conditions.

• 1) Règles pratiques pour choisir un seuil d’autocompaction : Utiliser 70% pour workflows modérés (réduction douce sans perte de contexte), 50% pour logs bruyants (troncature fréquente), et 85% pour opérations critiques où l’on préfère alertes humaines avant compaction.
• 2) Méthode pour ajouter une ligne de statut et alertes : Exposer un endpoint /context qui retourne l’usage en % et un dernier compactage. Lancer un cron qui récupère ce /context et envoie un message Slack si > X%. Exemple concret en bas.
• 3) Limites d’outils et outputs : Fixer un cap de longueur de réponse (ex : 2048 tokens), tronquer les dumps volumineux avant inclusion et préférer résumés (extractive ou abstractive) plutôt que dumps entiers. Éviter d’inclure pièces jointes ou blobs non nécessaires.
• 4) Stratégie modèle/agent : Limiter l’usage d’agents aux tâches précises et atomiques. Préférer exécutions séparées pour étapes coûteuses (par ex. résumé puis QA) afin de contrôler le coût par étape.
• 5) Template de prompt optimal minimal : Squelette de system instruction réutilisable en 4 lignes, direct et contraignant.

*/5 * * * * curl -s https://api.votre-service/context | jq '.usage_percent' | \
awk '{if($1>70) system("curl -X POST -H \"Content-type: application/json\" --data '\''{\"text\":\"Context usage "$1"%\"}'\'' https://hooks.slack.com/services/XXX/YYY")}'

System: Vous êtes un assistant concis.  
UserContext: {brief_context}  # Conserver seulement 3-4 lignes.  
Task: {task_description}  # Une phrase impérative.  
Output: {format_instructions}  # Par ex. JSON minimal, 2-4 champs.

Pouvez-vous fournir un tableau HTML de synthèse listant chaque réglage, commande ou template, le trigger d’usage et le bénéfice attendu (tokens économisés, maintenance) ?

Prêt à appliquer ces optimisations et réduire vos coûts tokens ?

En appliquant une stratégie combinée — nettoyage entre tâches, compaction régulière, instructions courtes, règles scoper et skills désactivables — vous maîtrisez l’explosion du contexte et réduisez la facture de tokens sans sacrifier la qualité. Mesurez via /context et /usage, ajustez les seuils (70→50% selon le bruit) et automatisez les alertes. Bénéfice concret : moins de consommation récurrente, workflows plus réactifs et coûts contrôlés.

FAQ

• Comment savoir ce qui consomme le plus de tokens ?
  Consultez les diagnostics /context et /usage pour identifier fichiers, logs ou instructions qui occupent le contexte. Priorisez la compaction des éléments volumineux (logs, dumps) et la mise en place de règles scoped.
• Quand utiliser /clear et /compact ?
  Utilisez /clear entre tâches distinctes pour repartir à zéro. Employez /compact quand l’historique contient des décisions essentielles à conserver sous forme résumée (objectifs, erreurs, fichiers modifiés).
• Quel seuil d’autocompaction choisir ?
  Réduisez le seuil par défaut (~95%) à environ 70% pour la plupart des workflows ; descendez à 50% pour les environnements très bruyants. Ajustez selon la fréquence d’édition et la sensibilité aux pertes d’historique.
• Comment scoper les règles pour payer moins de tokens ?
  Placez les règles spécifiques dans .claude/rules/ avec un scope par chemin (ex : src/ui/**). Seules les règles pertinentes se chargeront lors d’une édition locale, réduisant le contexte chargé.
• Les optimisations impactent-elles la qualité des réponses ?
  Pas nécessairement si vous conservez l’essentiel : objectifs, fichiers modifiés et décisions. La compaction préserve ces éléments. Testez les seuils et conservez des snapshots pour rétablir un contexte complet si besoin.

A propos de l’auteur

Franck Scandolera, expert & formateur en tracking server-side, Analytics Engineering, automatisation No/Low Code (n8n) et intégration de l’IA en entreprise. Responsable de l’agence webAnalyste et de l’organisme Formations Analytics. J’accompagne des clients comme Logis Hôtel, Yelloh Village, BazarChic, la Fédération Française de Football et Texdecor. Disponible pour aider votre équipe à optimiser vos flows et réduire vos coûts tokens — contactez-moi.

Franck Scandolera

⭐ Data Analyst, Analytics Engineer et expert dans l’automatisation IA  ⭐

Ref clients : Logis Hôtel, Yelloh Village, BazarChic, Fédération Football Français, Texdecor…

Mon terrain de jeu :

Data Analyst & Analytics engineering : tracking propre RGPD, entrepôt de données (GTM server, BigQuery…), modèles (dbt/Dataform), dashboards décisionnels (Looker, SQL, Python).
Automatisation IA des taches Data, Marketing, RH, compta etc : conception de workflows intelligents robustes (n8n, Make, App Script, scraping) connectés aux API de vos outils et LLM (OpenAI, Mistral, Claude…).
Engineering IA pour créer des applications et agent IA sur mesure : intégration de LLM (OpenAI, Mistral…), RAG, assistants métier, génération de documents complexes, APIs, backends Node.js/Python.