Communitygithub.com

budget-contexte

Audite la consommation de la fenêtre de contexte de Claude Code entre les agents, compétences, serveurs MCP et règles. Identifie le gonflement, les composants redondants et produit des recommandations de réduction de tokens priorisées.

Qu'est-ce que budget-contexte ?

Cette compétence permet d'auditer en détail la consommation de la fenêtre de contexte de Claude Code en analysant chaque composant chargé : agents, compétences, serveurs MCP, règles et fichiers CLAUDE.md. Elle est utile lorsque les performances de la session se dégradent, que la qualité des réponses baisse ou que vous prévoyez d'ajouter de nouveaux composants. Basée sur une approche en quatre phases (inventaire, classification, détection des problèmes, rapport), elle estime la charge en tokens, identifie les dépassements et les redondances, et produit un rapport priorisé avec des économies potentielles. Compatible avec les agents, compétences, serveurs MCP et règles, elle s'intègre via la commande `/context-budget` et propose un mode verbeux pour un débogage approfondi.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/affaan-m/ECC/tree/main/skills/context-budget

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Budget Contexte

Analysez la surcharge en tokens de chaque composant chargé dans une session Claude Code et proposez des optimisations actionnables pour récupérer de l'espace de contexte.

Quand l'utiliser

  • Les performances de la session semblent lentes ou la qualité des réponses se dégrade
  • Vous avez récemment ajouté plusieurs compétences, agents ou serveurs MCP
  • Vous voulez savoir combien de marge de contexte il vous reste réellement
  • Vous prévoyez d'ajouter plus de composants et devez savoir s'il y a de la place
  • Exécution de la commande /context-budget (cette compétence la prend en charge)

Comment ça fonctionne

Phase 1 : Inventaire

Scannez tous les répertoires de composants et estimez la consommation en tokens :

Agents (agents/*.md)

  • Comptez les lignes et les tokens par fichier (mots × 1.3)
  • Extrayez la longueur de la description dans le frontmatter
  • Drapeau : fichiers >200 lignes (lourds), description >30 mots (frontmatter gonflé)

Compétences (skills/*/SKILL.md)

  • Comptez les tokens par SKILL.md
  • Drapeau : fichiers >400 lignes
  • Vérifiez les copies en double dans .agents/skills/ — ignorez les copies identiques pour éviter le double comptage

Règles (rules/**/*.md)

  • Comptez les tokens par fichier
  • Drapeau : fichiers >100 lignes
  • Détectez les chevauchements de contenu entre fichiers de règles dans le même module linguistique

Serveurs MCP (.mcp.json ou configuration MCP active)

  • Comptez les serveurs configurés et le nombre total d'outils
  • Estimez la surcharge du schéma à ~500 tokens par outil
  • Drapeau : serveurs avec >20 outils, serveurs qui encapsulent des commandes CLI simples (gh, git, npm, supabase, vercel)

CLAUDE.md (projet + utilisateur)

  • Comptez les tokens par fichier dans la chaîne CLAUDE.md
  • Drapeau : total combiné >300 lignes

Phase 2 : Classification

Classez chaque composant dans un groupe :

GroupeCritèreAction
Toujours nécessaireRéférencé dans CLAUDE.md, prend en charge une commande active, ou correspond au type de projet actuelConserver
Parfois nécessaireSpécifique à un domaine (ex. motifs linguistiques), non référencé dans CLAUDE.mdEnvisager une activation à la demande
Rarement nécessaireAucune référence de commande, contenu en double, ou aucune correspondance évidente avec le projetSupprimer ou charger à la demande

Phase 3 : Détection des problèmes

Identifiez les motifs problématiques suivants :

  • Descriptions d'agents gonflées — description >30 mots dans le frontmatter chargée à chaque invocation de l'outil Task
  • Agents lourds — fichiers >200 lignes qui gonflent le contexte de l'outil Task à chaque déclenchement
  • Composants redondants — compétences qui dupliquent la logique d'un agent, règles qui dupliquent CLAUDE.md
  • Souscription excessive MCP — >10 serveurs, ou serveurs encapsulant des outils CLI disponibles gratuitement
  • Gonflement CLAUDE.md — explications verbeuses, sections obsolètes, instructions qui devraient être des règles

Phase 4 : Rapport

Produisez le rapport de budget contexte :

Rapport de Budget Contexte
═══════════════════════════════════════

Surcharge totale estimée : ~XX,XXX tokens
Modèle de contexte : Claude Sonnet (fenêtre de 200K)
Contexte disponible effectif : ~XXX,XXX tokens (XX%)

Répartition des composants :
┌─────────────────┬────────┬───────────┐
│ Composant       │ Nb     │ Tokens    │
├─────────────────┼────────┼───────────┤
│ Agents          │ N      │ ~X,XXX    │
│ Compétences     │ N      │ ~X,XXX    │
│ Règles          │ N      │ ~X,XXX    │
│ Outils MCP      │ N      │ ~XX,XXX   │
│ CLAUDE.md       │ N      │ ~X,XXX    │
└─────────────────┴────────┴───────────┘

ATTENTION : Problèmes trouvés (N) :
[classés par économie de tokens]

Top 3 Optimisations :
1. [action] → économie ~X,XXX tokens
2. [action] → économie ~X,XXX tokens
3. [action] → économie ~X,XXX tokens

Économies potentielles : ~XX,XXX tokens (XX% de la surcharge actuelle)

En mode verbeux, affichez également le nombre de tokens par fichier, la ventilation ligne par ligne des fichiers les plus lourds, les lignes redondantes spécifiques entre composants qui se chevauchent, et la liste des outils MCP avec l'estimation de la taille du schéma par outil.

Exemples

Audit de base

Utilisateur : /context-budget
Compétence : Scanne la configuration → 16 agents (12 400 tokens), 28 compétences (6 200), 87 outils MCP (43 500), 2 CLAUDE.md (1 200)
             Drapeaux : 3 agents lourds, 14 serveurs MCP (3 remplaçables par CLI)
             Économie principale : supprimer 3 serveurs MCP → -27 500 tokens (47% de réduction de la surcharge)

Mode verbeux

Utilisateur : /context-budget --verbose
Compétence : Rapport complet + ventilation par fichier montrant planner.md (213 lignes, 1 840 tokens),
             liste des outils MCP avec tailles par outil, lignes de règles dupliquées côte à côte

Vérification avant extension

Utilisateur : Je veux ajouter 5 serveurs MCP supplémentaires, ai-je de la place ?
Compétence : Surcharge actuelle 33% → ajouter 5 serveurs (~50 outils) ajouterait ~25 000 tokens → pousse à 45% de surcharge
             Recommandation : supprimer d'abord 2 serveurs remplaçables par CLI pour rester sous les 40%

Bonnes Pratiques

  • Estimation des tokens : utilisez mots × 1.3 pour le texte, caractères / 4 pour les fichiers contenant beaucoup de code
  • MCP est le plus gros levier : chaque schéma d'outil coûte ~500 tokens ; un serveur de 30 outils coûte plus que toutes vos compétences combinées
  • Les descriptions d'agents sont toujours chargées : même si l'agent n'est jamais invoqué, son champ description est présent dans chaque contexte de l'outil Task
  • Mode verbeux pour le débogage : utilisez-le lorsque vous devez identifier exactement les fichiers responsables de la surcharge, pas pour des audits réguliers
  • Auditez après les changements : exécutez après avoir ajouté un agent, une compétence ou un serveur MCP pour détecter la dérive tôt

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

accessibility

Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support.

affaan-m/content-engine

Create platform-native content systems for X, LinkedIn, TikTok, YouTube, newsletters, and repurposed multi-platform campaigns. Use when the user wants social posts, threads, scripts, content calendars, or one source asset adapted cleanly across platforms.

affaan-m/ECC

Multi-platform content distribution across X, LinkedIn, Threads, and Bluesky. Adapts content per platform using content-engine patterns. Never posts identical content cross-platform. Use when the user wants to distribute content across social platforms.

affaan-m/fal-ai-media

Unified media generation via fal.ai MCP — image, video, and audio. Covers text-to-image (Nano Banana), text/image-to-video (Seedance, Kling, Veo 3), text-to-speech (CSM-1B), and video-to-audio (ThinkSound). Use when the user wants to generate images, videos, or audio with AI.

affaan-m/manim-video

日本語翻訳:このファイルは manim-video 用の日本語翻訳が必要です

affaan-m/remotion-video-creation

Remotion のベストプラクティス - React で動画を作成する。3D、アニメーション、音声、字幕、チャート、トランジションなどをカバーするドメイン固有の29のルール。

affaan-m/video-editing

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

agent-architecture-audit

Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.

agent-eval

Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.

agent-harness-construction

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent

agentic-engineering

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

agentic-os

Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

agent-introspection-debugging

Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.

agent-payment-x402

Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.

agent-self-evaluation

Use after completing any non-trivial task. The agent self-rates its output on 5 axes — accuracy, completeness, clarity, actionability, conciseness — with concrete evidence per criterion. Produces a structured 1-5 scorecard with specific improvement suggestions.

agent-sort

Build an evidence-backed ECC install plan for a specific repo by sorting skills, commands, rules, hooks, and extras into DAILY vs LIBRARY buckets using parallel repo-aware review passes. Use when ECC should be trimmed to what a project actually needs instead of loading the full bundle.

ai-first-engineering

Engineering operating model for teams where AI agents generate a large share of implementation output. Use when setting team process, review gates, or ownership rules for a codebase largely written by agents.

ai-regression-testing

Regression testing strategies for AI-assisted development. Sandbox-mode API testing without database dependencies, automated bug-check workflows, and patterns to catch AI blind spots where the same model writes and reviews code. Use when adding regression coverage to AI-assisted code, or when the same model both wrote and reviewed a change.

android-clean-architecture

Clean Architecture patterns for Android and Kotlin Multiplatform projects — module structure, dependency rules, UseCases, Repositories, and data layer patterns. Use when structuring modules, layers, or data flow in an Android or KMP project.

angular-developer

Generates Angular code and provides architectural guidance. Trigger when creating projects, components, or services, or for best practices on reactivity (signals, linkedSignal, resource), forms, dependency injection, routing, SSR, accessibility (ARIA), animations, styling (component styles, Tailwind CSS), testing, or CLI tooling.

Skills associés