Structuré avec Claude

Coûts & tokens

Chaque couche qu’on a explorée — agents en parallèle, hooks, CLAUDE.md verbeux — a un coût en tokens. Cette page t’aide à piloter ça.

Chaque échange avec Claude consomme des tokens — les unités de mesure du texte traité. Ce ne sont pas que des unités de facturation : ce sont ta ressource principale. Bien les utiliser, c’est itérer plus, corriger moins, et produire plus de valeur par session.

Pourquoi ça compte

Le modèle économique de Claude Code est simple : tu paies par token. Mais l’enjeu dépasse la facture.

Un token mal utilisé, c’est un aller-retour correctif inutile, une session qui se dégrade parce que le contexte est saturé, ou une tâche qui prend 3 sessions au lieu d’une. La qualité de ton prompt est un investissement direct en tokens économisés.

Ce qui consomme des tokens

Le context window

Claude traite tout ce qu’il “voit” dans la conversation — fichiers lus, historique des échanges, instructions système. Plus le contexte est long, plus chaque réponse coûte cher.

• Un fichier de 500 lignes ouvert dans le contexte = des tokens à chaque échange, même si Claude n’en a besoin que d’une partie
• Une session longue accumule l’historique — après 30 échanges, Claude traite beaucoup de contexte qui n’est plus pertinent

CLAUDE.md verbeux

CLAUDE.md est relu à chaque session. Un fichier de 300 lignes avec des instructions floues coûte plus de tokens qu’un fichier de 50 lignes dense et précis — et donne de moins bons résultats.

Agents parallèles

Chaque agent a son propre context window. Lancer 4 agents en parallèle = 4 contextes simultanés. Puissant pour les tâches indépendantes, coûteux si mal utilisé.

Les allers-retours correctifs

C’est souvent là que se perd le plus de tokens. Un prompt vague génère une réponse approximative, tu corriges, Claude re-génère, tu ajustes… Chaque correction est un aller-retour qui coûte autant que la génération initiale.

Quel plan, quel modèle ?

Avant de parler d’optimisation, une question pratique que tout le monde se pose en démarrant.

Abonnement vs API

	Pro (~$20/mo)	Max (~$100/mo)	API (pay-per-token)
Claude Code inclus	✓	✓	Facturation séparée
Usage	Quotidien, limité	Quotidien intensif	Usage variable, intégrations
Pour qui	Démarrage, exploration	Développeurs full-time	Automatisations, CI/CD, apps

Claude Code fonctionne en abonnement Pro ou Max — c’est le point d’entrée recommandé. L’API est utile si tu construis quelque chose qui appelle Claude de façon programmatique.

Haiku / Sonnet / Opus — quand utiliser quoi

Modèle	Vitesse	Coût relatif	Utiliser quand
Haiku	⚡ Très rapide	$	Tâches simples, reformulations, exploration rapide
Sonnet	Rapide	$$	Usage quotidien — le bon défaut pour 90% des tâches
Opus	Plus lent	$$$$	Raisonnement complexe, architecture, décisions critiques

En pratique : commence avec Sonnet, passe à Opus quand tu bloques sur une décision difficile, utilise Haiku pour les tâches en volume (résumés, reformulations, scripts simples).

---

Comment suivre ta consommation

En session : /cost

Tape /cost à n’importe quel moment pour voir la consommation de la session en cours.

> /cost
Session cost: $0.23 (124k tokens)

Dashboard Anthropic

Le dashboard de ton compte Anthropic affiche la consommation par jour, par projet, et par modèle.

Ordres de grandeur indicatifs

Type de tâche	Consommation approximative
Question simple / explication	~$0.01–0.05
Implémentation d’une feature (fichier unique)	~$0.05–0.20
Refactor d’un module (plusieurs fichiers)	~$0.20–0.80
Session longue avec agents (1–2h)	~$1.00–3.00+

Ces chiffres varient selon le modèle, la longueur du contexte, et la complexité des fichiers.

Comment optimiser

Prompter précisément dès le départ

C’est le levier le plus puissant. Un prompt précis génère une bonne réponse du premier coup — pas de correction, pas de re-génération.

Au lieu de : “Améliore ce composant” Préfère : “Dans src/components/Card.astro, extrait la logique de formatage de date dans une fonction formatDate(date: string): string et documente-la avec un commentaire JSDoc.”

La précision coûte quelques secondes à l’écriture. Elle économise plusieurs échanges.

/compact — compresser l’historique

Quand la session devient longue, /compact résume l’historique en conservant l’essentiel. Le contexte se réduit, la qualité se maintient.

> /compact

À utiliser avant que la session sature, pas après.

Garder CLAUDE.md concis

Chaque ligne de CLAUDE.md est relue à chaque session. Viser : dense, actionnable, sans redondance. Supprimer ce qui est évident, garder ce qui change réellement le comportement de Claude.

→ Voir CLAUDE.md patterns avancés pour les bonnes pratiques.

Décomposer les grosses tâches

Une session marathon sur une grosse tâche accumule du contexte inutile et dégrade la qualité. Préférer plusieurs sessions courtes et ciblées — chaque nouvelle session repart avec un contexte propre.

Cibler les fichiers ouverts

Ne pas demander à Claude de lire un fichier dont il n’a pas besoin pour la tâche en cours. Chaque fichier dans le contexte coûte des tokens à chaque échange.

L’investissement qui se rentabilise

Mieux prompter, c’est produire plus avec le même budget. Un utilisateur qui maîtrise son contexte et écrit des prompts précis peut faire 3x plus d’itérations qu’un utilisateur qui corrige en boucle — avec le même coût total.

→ Voir aussi : Pièges & limites — notamment la section sur la saturation du context window.