Comment j'ai réduit les jetons Codex de 245M à 28M par jour gratuitement (à vitesse égale)

Après la fin de la promo Codex et l'arrivée des quotas réels, j'ai vu mes limites quotidiennes de tokens Codex fondre bien plus vite.

J'ai donc trouvé un système pour réduire le nombre de tokens que je dépense sans ralentir.

Un jour : 245 millions de tokens

Le lendemain, après avoir verrouillé mon système : 28 millions

Voici exactement ce que j'ai changé :

Étape 1 : Ne jamais alimenter avec des données brutes, toujours les pré-compacter d'abord

Codex n'a pas besoin de ton énorme fichier de trades de 40 Mo, d'un dump JSON massif du marché ou d'un repo entier à chaque tour. Maintenant, je lui fais générer des scripts jetables qui créent des « cartes d'aiguilles » :

• compact_logs.py → filtre par timestamp/symbole/mot-clé et ne sort que les N premières anomalies
• summarize_data.py → extrait les colonnes pertinentes, le nombre de lignes, des échantillons et les statistiques clés
• repo_map.py → construit une vue d'ensemble propre des points d'entrée, de la config, des flux principaux (en ignorant venv, node_modules, builds, etc.)

Alimente-le avec 200 à 500 tokens d'information distillée au lieu de 10k+ de bruit.

Construis une fois, réutilise pour toujours.

Étape 2 : Limiter agressivement chaque sortie de commande

La sortie par défaut est mortelle :

• git status
• ls -la
• cat file
• python script.py

peut exploser le contexte instantanément.

Maintenant, j'intègre des limites dans chaque instruction :

1head -n 50, tail -n 50, grep "ERROR" | head -n 30
2
3Écris les résultats complets dans des fichiers temporaires et inspecte seulement des plages
4
5Ajoute des flags --limit 100 partout

Étape 3 : Créer un fichier de passation vivant (le cerveau de ton projet)

Arrête de laisser les agents redécouvrir tout à chaque session.

Je conserve un fichier HANDOFF.md serré (moins de 1k tokens) qui contient :

• Objectif actuel + indicateurs de succès
• Fichiers clés & décisions récentes
• Commandes déjà exécutées + résultats
• Problèmes connus et liste « à ne pas relire »
• Prochaines étapes

Termine chaque session par : « Compresser les conclusions actuelles dans HANDOFF.md, éliminer les impasses, ne garder que les faits exploitables. »

Étape 4 : Les instructions explicites « À ne pas faire » économisent des tonnes de tokens

Les agents adorent divaguer, alors je fixe des murs infranchissables :

• « Ignore node_modules, .venv, dist, logs/archive, les fichiers générés et tous les dossiers de cache »
• « Résume avant d'ouvrir un nouveau fichier »
• « Ne colle jamais le code source complet sauf si je le dis explicitement »
• « Inspecte uniquement les fichiers nécessaires à cette tâche précise »

Intègre ces règles dans ton AGENTS.md une fois et regarde les relectures s'effondrer.

Étape 5 : Exiger des résumés, des diffs et des extraits

Mauvaise invite :

1Lis ce fichier et explique-le.

Bonne invite :

1Localise la logique de dimensionnement des positions du moteur de risque. Affiche uniquement cette fonction + 3 lignes au-dessus/en dessous. Explique le cas limite en un paragraphe.

Ou

1Construis une carte du repo en 1 page : points d'entrée, config, principaux flux de données et commandes de backtest. Ignore les dossiers vendor.

Des demandes ciblées = des fenêtres de contexte minuscules

Étape 6 : Faire en sorte que Codex compresse périodiquement son propre contexte

Tous les 4-5 tours, j'ajoute :

1Résume notre progression dans une note de passation serrée. Supprime les répétitions et les chemins échoués. Ne garde que ce qui est nécessaire pour continuer.

La conversation reste légère même en s'allongeant.

Étape 7 : Tuer la verbosité par défaut

1Sois concis. Ne produis que le correctif + une phrase d'explication. Ne répète pas le plan sauf s'il a changé. Pas de fioritures.

Cette seule règle réduit considérablement les tokens de sortie.

Commandes utiles et scripts d'aide que j'utilise quotidiennement

Voici les one-liners et scripts exacts que je copie-colle ou que je fais générer par Codex dès le premier jour de tout projet.

Commandes de limitation de base que j'impose à chaque appel d'outil :

1# Safe file inspection
2head -n 80 somefile.py | cat
3tail -n 80 somefile.py | cat
4grep -n "KEYWORD" file.py | head -n 40
5
6# Git without the firehose
7git status --porcelain | head -n 30
8git log --oneline -15
9git diff --name-only | head -n 20
10
11# Data & logs (trading-specific)
12tail -n 200 market_log.json | jq '.[-50:]' | head -n 100
13python -c "import pandas as pd; df = pd.read_csv('trades.csv'); print(df.head(20).to_string())" | head -n 150
14
15# Write-then-inspect pattern
16python analyze_backtest.py > temp_results.txt 2>&1
17head -c 8000 temp_results.txt   # byte cap for safety

**

Scripts d'aide que je demande toujours à Codex de créer en premier (puis que j'exécute moi-même) :**

• compact_logs.py → python compact_logs.py --symbol BTC --hours 24 > summary.txt
• repo_map.py → python repo_map.py > HANDOFF.md (met à jour le fichier cerveau)
• scan_errors.py → python scan_errors.py --limit 30 > errors.txt
• summarize_json.py → python summarize_json.py market_snapshot.json > needle.txt

Une règle AGENTS.md imparable que je respecte (byte-caper tout ce qui est inconnu) :

1## Protection des sorties de commandes
2Toute commande dont la sortie est inconnue ou potentiellement volumineuse DOIT être limitée en octets.
3Par défaut : COMMAND 2>&1 | head -c 6000
4Si plus est nécessaire, écrire dans un fichier temporaire et je n'inspecterai que des plages.

Modèle d'invite que je réutilise pour les tâches lourdes en données :

1Exécute d'abord compact_logs.py ou summarize_data.py pour créer une carte d'aiguille de moins de 500 tokens. Analyse ensuite uniquement cela. Ne lis jamais le fichier brut directement.

Ces commandes et scripts réduisent à eux seuls ma consommation quotidienne de 30 à 40 % supplémentaires, en plus des grands changements de workflow.

Ma nouvelle règle d'or :

Ne laisse pas Codex lire des données brutes si un résumé de 50 lignes suffit

Les assistants que j'ai construits la première semaine se rentabilisent toutes les heures.

L'efficacité des tokens n'était pas un problème de modèle, c'est un problème de système : maîtrise la discipline du contexte et tu feras 8 à 10 fois plus de choses dans le même quota.

Je construis aussi www.RedLeads.app pour trouver plus vite des utilisateurs pour ce que je lance. Rejoins-moi pour accélérer jusqu'à 10k $ de MRR en vibecodant des systèmes et des outils sympas.

Merci :)