Claude Code : 3 actions pour éviter le plafond brutal

Contexte rapide

Anthropix impose des limites dures sur Claude Code, les agents et les GitHub Actions à partir du 15 juin. Sur le plan Max x20 (200 $/mois), une fois le quota atteint : tout s'arrête. Zéro output, zéro token, zéro agent. Pas un message d'avertissement clair — juste un mur.

Si tu fais tourner Claude Code en continu sur plusieurs repos, tu peux brûler ce budget en 10 jours sans t'en rendre compte.

Voici trois actions concrètes à poser maintenant.

Action 1 — Compresse tes prompts système

Un prompt mal écrit, c'est 30 à 40 % de tokens gaspillés sur chaque appel. Multiplie ça par 50 sessions par jour et tu comprends où part ton quota.

Pourquoi tes prompts sont trop lourds

Les instructions système par défaut de la plupart des agents contiennent :

Des répétitions de contexte (re-expliquer le rôle à chaque message)
Des formules de politesse inutiles ("Please make sure to...", "It's important that you...")
Des blocs de règles redondants copiés-collés sans nettoyage
Du contexte statique qui ne change jamais mais est renvoyé à chaque appel

Comment réécrire tes instructions système

Prompt de compression à copier-coller dans Claude :

Voici mon instruction système actuelle :
[COLLE TON PROMPT ICI]

Récris-la en :
1. Supprimant toute redondance
2. Remplaçant les phrases longues par des bullet points courts
3. Éliminant toute formule de politesse ou méta-commentaire
4. Gardant 100% du comportement attendu

Objectif : réduire le nombre de tokens d'au moins 35% sans perte de précision.
Affiche le prompt optimisé, puis le ratio de compression estimé.

Exemple avant / après :

Avant (~180 tokens) :

You are a helpful assistant that helps developers write clean code. It's very important that you always follow best practices. Please make sure to explain your reasoning clearly and provide examples when relevant. You should always be concise but thorough.

Après (~60 tokens) :

Assistant: expert code review. Rules: best practices only, reasoning in bullet points, examples si nécessaire, réponses denses.

Gain : 67 % de tokens en moins sur chaque appel système.

Ce qu'il faut faire ce soir

Liste tous tes fichiers CLAUDE.md et instructions système dans tes repos
Passe chacun dans le prompt de compression ci-dessus
Remplace et commite — tu récupères de la marge immédiatement

Action 2 — Configure un routing automatique de fallback

Quand Claude est à court de quota, tu veux que tes agents basculent sur un autre modèle sans intervention manuelle. Ça se configure en moins d'une heure.

Les modèles de fallback viables

Modèle	Forces	API
Kimi (Moonshot)	Long context, code solide	moonshot.cn
Gemma 2 27B (via Groq)	Rapide, gratuit, bon en code	console.groq.com
GLM-4 (Zhipu)	Multilingue, context 128k	open.bigmodel.cn
Mistral Large	Proche Claude en qualité	mistral.ai

Structure de routing en Python

import anthropic
import os
from openai import OpenAI  # compatible avec Groq/Mistral/Moonshot

def call_with_fallback(messages: list, system: str) -> str:
    # Tentative Claude en premier
    try:
        client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
        response = client.messages.create(
            model="claude-opus-4-5",
            max_tokens=2048,
            system=system,
            messages=messages
        )
        return response.content[0].text

    except anthropic.RateLimitError:
        print("[ROUTING] Claude quota atteint → fallback Groq/Gemma")
        return call_groq_fallback(messages, system)

def call_groq_fallback(messages: list, system: str) -> str:
    client = OpenAI(
        api_key=os.environ["GROQ_API_KEY"],
        base_url="https://api.groq.com/openai/v1"
    )
    all_messages = [{"role": "system", "content": system}] + messages
    response = client.chat.completions.create(
        model="gemma2-9b-it",
        messages=all_messages
    )
    return response.choices[0].message.content

Pour Claude Code spécifiquement

Claude Code ne supporte pas encore le routing natif. La solution : wrapper tes scripts d'automatisation avec la fonction ci-dessus plutôt que d'appeler l'API Anthropic directement.

Pour les GitHub Actions, tu peux aussi conditionner le modèle via une variable d'environnement :

- name: Run AI step
  env:
    MODEL_PROVIDER: ${{ vars.MODEL_PROVIDER || 'anthropic' }}
  run: python run_agent.py --provider $MODEL_PROVIDER

Tu switches manuellement ou programmatiquement selon ton quota restant.

Action 3 — Mets en place un tracker de consommation par repo

Tu ne peux pas piloter ce que tu ne mesures pas. Avant que le compteur tombe, tu dois savoir quel repo et quel agent brûle quoi.

Script de tracking minimal

import json
import os
from datetime import datetime
from pathlib import Path

TRACK_FILE = Path(".token_usage.json")

def log_usage(repo: str, agent: str, input_tokens: int, output_tokens: int):
    data = json.loads(TRACK_FILE.read_text()) if TRACK_FILE.exists() else {}
    
    key = f"{repo}/{agent}"
    if key not in data:
        data[key] = {"total_input": 0, "total_output": 0, "calls": 0, "last_call": None}
    
    data[key]["total_input"] += input_tokens
    data[key]["total_output"] += output_tokens
    data[key]["calls"] += 1
    data[key]["last_call"] = datetime.now().isoformat()
    
    TRACK_FILE.write_text(json.dumps(data, indent=2))

def print_report():
    if not TRACK_FILE.exists():
        print("Aucun tracking disponible.")
        return
    
    data = json.loads(TRACK_FILE.read_text())
    print("\n=== Consommation par repo/agent ===")
    for key, stats in sorted(data.items(), key=lambda x: x[1]["total_input"], reverse=True):
        total = stats["total_input"] + stats["total_output"]
        cost_estimate = (stats["total_input"] * 3 + stats["total_output"] * 15) / 1_000_000
        print(f"{key}: {total:,} tokens | ~${cost_estimate:.2f} | {stats['calls']} appels")

Intègre log_usage() après chaque appel API dans tes scripts. Lance print_report() chaque matin.

Seuils à surveiller

Alerte jaune : 60 % du budget mensuel atteint avant le 20 du mois
Alerte rouge : un seul repo/agent dépasse 30 % du budget total
Action immédiate : si un agent fait plus de 500 appels/jour, vérifie s'il tourne en boucle

Dashboard rapide dans le terminal

Ajoute un alias dans ton .zshrc ou .bashrc :

alias token-report="python -c 'from track import print_report; print_report()'"

Tu tapes token-report depuis n'importe quel repo et tu vois l'état de ta consommation instantanément.

Récap — Ce que tu fais ce soir

Action	Temps estimé	Impact
Compresser tes prompts système	30 min	-30 à 40 % de tokens
Configurer le routing de fallback	45 min	Zéro downtime si quota épuisé
Déployer le tracker	20 min	Visibilité totale avant la coupure

Ces trois actions ensemble te donnent de la marge, de la résilience et de la visibilité. Tu peux les poser en 2 heures chrono avant que le 15 juin arrive.

Le risque, c'est de les remettre à demain et de découvrir le mur en plein sprint.