Communitygithub.com

Context Master

Gestion universelle du contexte et système de planification. Activez-le PROACTIVEMENT pour : (1) toute tâche complexe nécessitant une planification, (2) les projets multi-fichiers / sites web / applications, (3) les décisions architecturales, (4) les tâches de recherche, (5) le refactoring, (6) les longues sessions de codage, (7) les tâches avec 3+ étapes séquentielles. Fournit : ordre de création de fichiers optimal, workflows économes en contexte, délégation de réflexion étendue (~23x d'efficacité de contexte), architecture d'analyse approfondie passive, décomposition progressive des tâches. Indépendant de l'environnement — fonctionne aussi bien sur le Web, l'API et Claude Code CLI.

Qu'est-ce que Context Master ?

Context Master est une compétence (skill) pour agents d'IA comme Claude Code, Cursor ou Codex, conçue pour optimiser la gestion du contexte lors de tâches complexes, de longues sessions de codage et de projets multi-fichiers. Elle est indépendante de l'environnement et fonctionne à l'identique sur le Web, l'API et la CLI de Claude Code (avec des bonus spécifiques à la CLI). Avant toute création, la compétence impose un workflow en 5 étapes : STOP (ne rien créer), PLAN (utiliser la réflexion étendue ou un document de planification), ANNONCER (communiquer l'ordre des fichiers à l'utilisateur), CRÉER (écrire les fichiers dans l'ordre optimal : fondations avant dépendances), VÉRIFIER (s'assurer que toutes les références sont valides). Cela évite les refontes, les exportations inutiles et les liens cassés. L'un des mécanismes clés est l'architecture de réflexion approfondie passive : le raisonnement complexe est délégué à un espace isolé (sous-agent dans la CLI, artefact sur le Web/API) pour ne consommer que quelques centaines de tokens dans le thread principal, contre plusieurs milliers si fait en ligne (~23x d'efficacité). Cela permet de multiplier par 2 la capacité effective d'une fenêtre de contexte de 200K tokens. Les principes fondamentaux incluent la planification avant l'écriture, la création des fondations en premier, la délégation de l'analyse approfondie, le nommage des phases, l'utilisation d'artefacts pour le contenu long, la divulgation progressive, les signaux de réinitialisation, et la réflexion post-projet. Des anti-patrons sont également documentés pour éviter les gaspillages de contexte. La compétence fait référence à de nombreux fichiers dans le répertoire `references/` pour des détails plus poussés.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/JosiahSiegel/claude-plugin-marketplace/tree/HEAD/plugins/context-master/skills/context-master
Voir l'original→Voir toutes les compétences

Demander à votre IA préférée

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

OpenAIChatGPTClaudeClaudeGeminiGeminiGrokGrokPerplexityPerplexityDeepSeekDeepSeek

Documentation

Que fait Context Master ?

Compétence universelle de gestion du contexte et de planification pour les tâches complexes, les longues sessions et les projets multi-fichiers. Fonctionne de la même manière que vous soyez dans l'application Web, l'API ou Claude Code CLI ; les bonus spécifiques à la CLI se trouvent dans references/claude-code-cli.md.

Ce SKILL.md est intentionnellement court. Le matériel détaillé se trouve dans references/ — chargez uniquement ce dont vous avez besoin.

Quand activer

Activez-la de manière proactive chaque fois que la demande correspond à l'un des cas suivants :

  • Projet multi-fichiers (3+ fichiers liés, sites web, applications, API, ensembles de documentation).
  • Décision d'architecture ou de technologie (« devrait-on utiliser X ou Y », « quelle approche… »).
  • Recherche / comparaison / analyse de compromis.
  • Travail de refactoring ou de migration.
  • Longue session de codage où l'efficacité du contexte est importante.
  • Toute tâche comportant 3+ étapes séquentielles ou des dépendances partagées.

Si la demande concerne un seul fichier sans dépendances, ignorez cette compétence.

Le workflow en 5 étapes (mémorisez-le)

Pour tout projet multi-fichiers — sites web, applications, API, ensembles de documentation — exécutez ces cinq étapes dans l'ordre :

  1. STOP — ne créez encore aucun fichier.
  2. PLAN — utilisez la réflexion étendue ou un document de planification (les deux sont également valides ; voir references/multi-file-planning.md).
  3. ANNONCE — communiquez la liste des fichiers et l'ordre de création à l'utilisateur.
  4. CRÉEZ — écrivez les fichiers dans l'ordre optimal (fondations avant dépendances).
  5. VÉRIFIEZ — assurez-vous que chaque référence se résout ; corrigez les problèmes avant de déclarer terminé.

Exemple pratique (site web portfolio)

Utilisateur : « Crée un portfolio avec des pages accueil, à propos, projets et contact. »

Étape 1 STOP    -- ne commencez pas par index.html.
Étape 2 PLAN    -- « Réfléchissez bien à l'architecture : 5 fichiers nécessaires,
                  styles.css est la dépendance partagée. »
Étape 3 ANNONCE -- « Je vais créer :
                  1. styles.css       (style partagé)
                  2. index.html       (référence styles.css)
                  3. about.html
                  4. projects.html
                  5. contact.html »
Étape 4 CRÉEZ   -- écrivez les fichiers dans cet ordre.
Étape 5 VÉRIFIEZ -- chaque fichier HTML lie styles.css ; la navigation se résout.

Résultat : pas de refactoring, pas de ré-exportation, pas de liens cassés.

Le modèle complet, les modèles d'ordre optimal par type de projet (site web / React / API backend / etc.) et les listes de vérification se trouvent dans references/multi-file-planning.md.

Principes fondamentaux (une ligne chacun)

  1. Planifiez avant d'écrire — réflexion étendue ou document de planification, jamais les deux omis.
  2. Les fondations d'abord — les dépendances partagées (CSS, config, classes de base, schémas) précèdent les dépendances.
  3. Déléguez l'analyse approfondie à des contextes isolés — les sous-agents (CLI) ou les artefacts de réflexion (Web/API) gardent le thread principal propre.
  4. Limites de phase — nommez chaque phase (« Phase 1 terminée ; passage à la Phase 2 : … ») pour que le contexte ne se brouille pas.
  5. Des artefacts plutôt que du contenu en ligne — le code ou la documentation long se trouve dans des artefacts/fichiers, pas dans l'historique de chat.
  6. Divulgation progressive — demandez une tranche à la fois ; ne regroupez pas des étapes non liées.
  7. Signaux de réinitialisation — dites « je mets de côté l'approche précédente… » lorsque vous changez de direction.
  8. Réfléchissez après les grands projets — était-ce planifié ? Les références ont-elles cassé ? Utilisez la liste de vérification post-projet dans references/multi-file-planning.md.

Justifications complètes et exemples pour chaque principe : references/universal-best-practices.md.

Règle empirique d'économie de tokens

Taille du projetSans planificationAvec planificationÉconomie
Petit (3-4 fichiers)~6 000 tokens~2 500 tokens~58%
Moyen (7-8 fichiers)~12 000 tokens~4 500 tokens~63%
Grand (20+ fichiers)~35 000 tokens~12 000 tokens~66%

Une fenêtre de contexte de 200 000 tokens contient environ 16 à 17 projets moyens avec planification, 7 à 8 sans — une augmentation effective de 2,1x. Chiffres et méthodologie dans references/multi-file-planning.md.

Architecture de réflexion approfondie passive

Le modèle le plus puissant pour l'efficacité du contexte : acheminez le raisonnement profond dans un espace isolé et renvoyez un bref résumé au thread principal.

  • Claude Code CLI : /agent deep-analyzer « Ultrason sur [décision] » — ~5 000 tokens de raisonnement se déroulent hors bande ; le contexte principal reçoit un résumé d'environ 200 tokens (~23x d'efficacité).
  • Web / API : « Crée un artefact d'analyse approfondie et ultrasonne sur [décision] » — même idée, artefact au lieu de sous-agent.

Déclencheurs, anti-patrons et prompts prêts à l'emploi : references/thinking-delegation.md.

Workflows courants (pointeurs uniquement)

Chacun d'eux a une procédure étape par étape dans references/workflows.md :

  • Workflow 0 — Création de site web/projet multi-fichiers (le défaut — mêmes 5 étapes ci-dessus avec des détails supplémentaires).
  • Workflow 1 — Prise de décision complexe (architecture, choix technique).
  • Workflow 2 — Développement de fonctionnalité complexe (analyse → conception → implémentation → test → intégration).
  • Workflow 3 — Recherche et évaluation de technologie.
  • Workflow 4 — Génération et itération de code via des artefacts.
  • Workflow 5 — Refactoring avec analyse isolée.

Anti-patrons (à éviter)

Liste rapide — exemples et correctifs dans references/anti-patterns.md :

  1. Créer des fichiers avant la planification — gaspille du contexte sur des refontes.
  2. Tout demander en une seule fois — surcharge le contexte et produit un résultat superficiel.
  3. Intégrer du code/de la documentation long dans le chat — alourdit l'historique ; utilisez des artefacts/fichiers.
  4. Laisser le raisonnement profond se faire dans le thread principal — coûte environ 5 000 tokens qui pourraient être ~200.
  5. Pas de limites de phase — le contexte se brouille entre des sous-tâches non liées.

Dépannage

Lorsque les sessions dérivent (réponses floues, conversations trop longues, code régénéré au lieu d'être édité, réflexion étendue non engagée), consultez references/troubleshooting.md pour un tableau symptôme → remède couvrant le Web/API et la CLI séparément.

Bonus Claude Code CLI

Si vous exécutez ceci dans Claude Code CLI, vous bénéficiez également de :

  • /clear, /compact, /continue — contrôles de contexte intégrés.
  • /agent <nom> — déléguez à un sous-agent isolé.
  • CLAUDE.md — mémoire persistante du projet.
  • Scripts d'aide pour générer CLAUDE.md et les définitions de sous-agents.

Détails, invocations de scripts et modèles de délégation d'analyse approfondie : references/claude-code-cli.md.

Les modèles d'intégration compétence-sous-agent (lorsque les deux sont disponibles) se trouvent dans references/agent-skills-integration-2025.md. Stratégies de contexte de longue durée et modèles de prompts pour sous-agents : references/context_strategies.md et references/subagent_patterns.md.

Carte des références

FichierQuand l'utiliser
references/multi-file-planning.mdModèle de planification, modèles d'ordre optimal par type de projet, listes de vérification, réflexion post-projet.
references/universal-best-practices.mdBesoin de la justification ou d'exemples pour l'un des 8 principes fondamentaux.
references/workflows.mdBesoin d'une procédure étape par étape pour un scénario spécifique (décision, fonctionnalité, recherche, refactoring).
references/thinking-delegation.mdConception d'une délégation d'analyse approfondie ou rédaction du prompt de réflexion.
references/anti-patterns.mdVérification si l'approche actuelle gaspille du contexte.
references/troubleshooting.mdLa session dérive, est lente ou produit trop d'explications.
references/claude-code-cli.mdExécution dans Claude Code CLI et besoin des outils sous-agent / CLAUDE.md.
references/agent-skills-integration-2025.mdCombinaison de compétences avec des sous-agents dans la CLI.
references/context_strategies.mdNotes de stratégie de longue durée.
references/subagent_patterns.mdModèles de prompts pour sous-agents.

Indicateurs de succès

  • Vous avez annoncé le plan avant de créer un fichier.
  • Les fichiers de fondation (CSS, config, schémas) ont été écrits avant les dépendances.
  • Aucune référence n'a cassé au premier lancement ; aucun refactoring n'a été nécessaire.
  • Le raisonnement approfondi a eu lieu dans un sous-agent ou un artefact, pas dans le thread principal.
  • Les phases ont été nommées au fur et à mesure que vous les traversiez.

Si l'un de ces points a échoué, revenez sur references/anti-patterns.md et la section post-projet de references/multi-file-planning.md avant la prochaine tâche.

Skills associés

steipete/sag

ElevenLabs text-to-speech with mac-style say UX.

community

steipete/oracle

Oracle CLI second-model review/debug/refactor/design with selected files, dry-run token checks, API or browser engine.

community

steipete/peekaboo

Capture and automate macOS UI with the Peekaboo CLI.

community

mattpocock/design-an-interface

Generate multiple radically different interface designs for a module using parallel sub-agents. Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice".

community

mattpocock/prototype

Build a throwaway prototype to flesh out a design — a runnable terminal app for state/business-logic questions, or several radically different UI variations toggleable from one route.

community

mattpocock/grill-me

Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".

community