Communitygithub.com

hookdump/UltraExplainer

Transformez du code, des systèmes, des diffs et des plans en pages HTML autonomes d'une clarté remarquable — graphes nœuds-liens, diffs annotés, tableaux de bord, illustrations SVG personnalisées et Mermaid thématisé. Un plugin Claude Code avec le système de design futuriste 'Aurora' (effet lumineux optionnel).

Qu'est-ce que UltraExplainer ?

UltraExplainer est un assistant de synthèse et de visualisation pour Claude Code qui transforme du code, des systèmes, des diffs, des plans, des données et des concepts en une seule page HTML autonome. L'idée maîtresse est de rendre une idée importante évidente dans le premier écran, puis de la prouver avec des preuves ancrées. L'outil combine trois éléments : une méthode de synthèse (le cerveau) qui décide quoi montrer, quoi souligner, quoi couper, et comment ne jamais dessiner de structure qui n'est pas dans la source ; le Chameleon Studio (l'artisanat) qui propose un contrat de composants stable, indépendant du langage de design, re-skiné par sept langages de design complets (Blueprint, Editorial, Terminal, Instrument, Notebook, Swiss, Luminous) ; et une couche d'interactivité (ux.js) qui alimente des curseurs, des toggles de scénarios, des pas-à-pas, des tris de tableaux, une navigation par scroll-spy et des graphes nœuds-liens routés. UltraExplainer impose une discipline stricte : la vérité prime sur la beauté et l'artisanat ; chaque nœud, lien ou nombre doit être ancré à une source réelle ; et la page doit être rendue et inspectée avant livraison. Il prend en charge deux modes : EXPLAIN (thèse d'abord, pour les décideurs) et TEACH (question d'abord, pour les apprenants), avec des références détaillées pour chaque besoin.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add hookdump/UltraExplainer

Demander à votre IA préférée

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

Documentation

Que fait UltraExplainer ?

Transformez du code, des systèmes, des diffs, des plans, des données et des concepts en une seule page HTML autonome qui rend une idée importante évidente dans le premier écran — puis la prouve avec des preuves ancrées. UltraExplainer est trois choses qui travaillent ensemble :

  1. Une méthode de synthèse (le cerveau) — comment décider quoi montrer, quoi souligner, quoi couper, et comment ne jamais dessiner de structure qui n'est pas dans la source. Voir references/synthesis-method.md.
  2. Le Chameleon Studio (l'artisanat) — un contrat de composants stable et indépendant du langage de design (assets/core.css) re-skiné par sept langages de design complets (assets/themes.css). Le même diff s'affiche comme une gouttière IDE sous Terminal, un encadré réglé sous Blueprint, une figure sous Editorial. Vous choisissez le langage en fonction du sujet ; l'effet lumineux est une option (Luminous), jamais la valeur par défaut. Voir references/aesthetic-languages.md et references/component-contract.md.
  3. Une couche d'interactivité (assets/ux.js) — un moteur état→rendu partagé alimentant des curseurs, des toggles de scénarios, des pas-à-pas, des tableaux triables/filtrables, une navigation scroll-spy et des graphes nœuds-liens routés. Voir references/interactivity.md.

Identité : vérité + le bon langage de design + un artisanat vérifié. Pas "tout brille," pas "soupe de boîtes et de flèches," pas "un mur de cartes identiques."

Quand utiliser cette compétence

Utilisez une page HTML chaque fois que la sortie est intrinsèquement visuelle, relationnelle ou manipulable et que l'ASCII/Markdown la déformerait :

  • Un diagramme, une vue d'architecture ou un graphe nœuds-liens montrant comment quelque chose se connecte ou circule.
  • Un diff / review de PR (code modifié + pourquoi c'est important + rayon d'impact).
  • Un plan / audit d'exigences ou une matrice de comparaison.
  • Un tableau de bord de métriques, ou tout tableau avec 4+ lignes / 3+ colonnes.
  • Un explicateur de concept qui enseigne un mécanisme, ou un modèle interactif que le lecteur doit ressentir en changeant une entrée.
  • Un diaporama, ou un récapitulatif de projet pour un changement de contexte.

Si la réponse honnête tient en une phrase ou un seul chiffre, dites-la dans le chat — ne fabriquez pas de page (la règle de l'explicateur minimal viable). Quand vous construisez, donnez un résumé d'une ligne dans le chat et livrez le fichier.

Deux modes — décidez lors de la charte

Indiquez dans quel mode vous êtes (pour que l'utilisateur puisse le corriger) :

  • EXPLAIN (par défaut) — thèse d'abord, pour les relecteurs / décideurs / changeurs de contexte qui ont besoin de la conclusion rapidement. Des plafonds de saillance s'appliquent (T0 ≤ 3, T1 ≤ 7).
  • TEACH — question d'abord, pour les apprenants qui ont besoin d'un modèle mental exécutable. Concret avant abstrait, prédire puis révéler, se termine par une vérification du transfert. Voir references/teaching.md.

La méthode, en bref

Lisez references/synthesis-method.md avant de générer quoi que ce soit de non trivial. La version courte :

  1. Charte — une phrase : "Ceci explique <artefact> à l'altitude <A0–A4> pour <public> afin qu'il/elle puisse <tâche>," plus le mode (EXPLAIN/TEACH). Maintenez une altitude.
  2. Thèse avec tension — une affirmation déclarative que le lecteur ne connaît pas encore (pas un sujet). Choisissez l'épine dorsale (l'axe unique que l'œil suit).
  3. Registre de preuves — lisez la source réelle ; pour chaque nœud/lien/étiquette/chiffre, enregistrez {affirmation, ancre (fichier:ligne / symbole / ref git / métrique+date), confiance (vérifié|inféré|supposé)}. Pas d'ancre → ça ne s'affiche pas comme fait. Pour les modèles interactifs, chaque plage/valeur par défaut de curseur et la fonction entrée→sortie est ancrée ou estampillée "modèle illustratif, non mesuré."
  4. Réconciliez — confrontez la thèse aux preuves contradictoires ; révisez, cadrez, ou montrez-la. Ne la laissez jamais tomber en silence.
  5. Vérification minimale viable — ne sur-rendez pas. Réponse simple → phrase héroïque + un visuel.
  6. Hiérarchisation de saillance — T0 (thèse + épine dorsale, ≤3) / T1 (support porteur, ≤7) / T2 (preuves, dans <details>/survol). Au-dessus d'un plafond → divisez ou rétrogradez, ne réduisez jamais pour faire rentrer. (Le mode TEACH échange les plafonds contre un budget de difficulté souhaitable.)
  7. Choisissez le langage de design — évaluez les 7 langages sur le sujet × le public × le support et enregistrez une ligne : LANGUAGE: <nom> parce que <sujet + public + support>. Voir ci-dessous.
  8. Représentez — posez d'abord la question de la manipulabilité ("le lecteur doit-il ressentir une relation en changeant une entrée ?") ; si oui, optez pour un modèle/stepper/scénario. Sinon, choisissez la forme statique la moins encreuse. Codez la magnitude quantitativement (taille/longueur/position), pas avec des boîtes égales.
  9. Compressez — l'omission est l'art ; réduisez la répétition ("×12 gestionnaires") ; extrayez les lignes porteuses, pas des fichiers entiers.
  10. Portes — passez les trois avant de livrer (ci-dessous).

Trois portes de livraison — la vérité prime sur tout

  • TRUTH — chaque nœud/lien/chiffre remonte à une ancre réelle ; le contenu inféré/supposé est visiblement nuancé ; la thèse a été réconciliée avec les preuves contradictoires ; vous avez rouvert les ancres. Un "je n'ai pas pu confirmer X" clairement marqué vaut mieux qu'une fabrication confiante. Un mensonge interactif (un curseur qui manipule une relation fabriquée) est le péché cardinal.
  • CRAFT — le test du plissement d'yeux : de l'autre côté de la pièce, ça se lit comme un langage de design délibéré, pas un template recolorié. Exactement un point focal T0.
  • OBSERVED — vous avez effectivement rendu la page et regardé. Construisez-la, ouvrez-la (capture d'écran headless à ~1280 et ~360), capturez les erreurs console, assurez-vous qu'il n'y a pas de défilement horizontal et que la thèse est dans le premier viewport, puis corrigez-vous. Arrêtez d'affirmer des propriétés de checklist que vous n'avez jamais mesurées.

Comment construire une page (assemblage)

Les pages sont assemblées par scripts/build.mjs à partir d'un fragment de corps dans templates/_src/<nom>.body.html. Le chemin le plus rapide : copiez le template le plus proche, changez le preset et adaptez le contenu.

  • Directive ligne 1 (JSON dans un commentaire HTML) sélectionne le langage et le réglage : <!--ux: {"title":"…","preset":"blueprint","theme":"light","fx":"flat","head":"<style>…</style>"} -->
    • preset : blueprint | editorial | terminal | instrument | notebook | swiss | luminous (par défaut luminous)
    • presets: ["…","…"] → émet un fichier par langage (démos chameau)
    • theme : light | dark (par défaut le réglage naturel du preset)
    • fx : glow | flat (Luminous uniquement)
    • head / foot : balisage supplémentaire ; les sidecars <nom>.head.html / <nom>.foot.html sont également fusionnés
  • La construction intègre core.css + themes.css + ux.js, lie les polices du preset, définit data-theme-preset / data-theme / data-fx avant le rendu (sans FOUC), et émet templates/<nom>.html.
  • Exécutez : node scripts/build.mjs <filtre-nom> (le filtre est une sous-chaîne ; omettez pour tout construire).
  • Les seules requêtes externes de la page sont Google Fonts (avec des polices de secours système — la mise en page n'en dépend jamais) et, pour les pages Mermaid, le CDN Mermaid. La page doit toujours être correcte si celles-ci échouent.

CRITIQUE lors de l'intégration de tout JS contenant la chaîne littérale </script> (par exemple, un extrait d'exemple) : échappez-la en \<\/script> ou elle ferme la balise prématurément et déverse la source sur la page.

Choisir le langage de design

Acheminez selon le mérite, enregistrez la raison. Grille d'évaluation complète + profils par langage dans references/aesthetic-languages.md.

SujetLangage par défaut
Architecture, schémas, protocoles, topologie infrastructureBlueprint
Concepts, ADR, post-mortems, récits exécutifsEditorial
Diffs, PRs, outils CLI, pipelines CI, logsTerminal
Métriques, benchmarks, audits, tableaux de bordInstrument
Enseignement, procédures pas à pas, intégration, explicateurs douxNotebook
Comparaisons, pages de principes/manifestes, rapports d'étatSwiss
Démonstrations de flux système, vision produit, briefs effet waouhLuminous (jamais par défaut)

Départages : honorez les demandes explicites des utilisateurs ("fais-en un terminal") ; alternez pour éviter la monotonie de la session ; ne choisissez jamais Luminous juste parce que c'est clinquant.

Choisir la représentation

Acheminez selon la tâche cognitive et la forme des données, pas le type de contenu. Manipulabilité d'abord. Catalogue complet + routage dans references/representations.md ; graphiques honnêtes dans references/charts-honesty.md.

TâcheReprésentation (composant)
Une conclusion dominante / oui-nonHéros typographique de thèse (.ux-thesis), peut-être un visuel en dessous
Le lecteur doit ressentir une relationModèle paramétrique ([data-playground]) — curseurs + affichages liés
L'ordre / l'état intermédiaire est le sensPas-à-pas ([data-stepper]) — code↔données en synchronisation
Se comporte différemment selon les configurationsBascule de scénario (.ux-seg[data-scenario-ctl]) ré-illumine un diagramme
Séquence linéaire vraieListe numérotée / bande de flux (.ux-spine) — pas un organigramme
Flux ramifié / fusionné / cycliqueGraphe nœuds-liens (.ux-graph, ≤12 nœuds) ou Mermaid thématisé
Relations par paires densesCarte de chaleur matricielle (.ux-matrix) — bat un graphe en boule de poils
Changement de code / PRDiff annoté + verdict (.ux-diff + .ux-verdict) + rayon d'impact
Concept / idée faussePanneaux naïf-vs-correct (.ux-compare) + un exemple travaillé
Comparaison / audit / matriceTableau triable et filtrable (.ux-table, th[data-sort], data-ux-filter)
Métriques quantitativesLigne de KPI orientée delta (.ux-kpis) + graphique honnête le plus simple (.ux-bars/.ux-linechart)
Plan / feuille de routeBloc actuel→cible + chronologie par risque (.ux-timeline)
PrésentationDiaporama (templates/slides)
Rien ne correspondSVG personnalisé en ligne utilisant les tokens du thème

Templates (templates/, avec sources dans templates/_src/)

TemplateLangageDémontre
chameleon.<preset>.htmltous les 7la MÊME explication rendue dans chaque langage — le test du plissement d'yeux
blueprint → playgroundBlueprintmodèle paramétrique (curseurs, KPI/barres liés, presets)
terminal-diffTerminalreview de PR : diff annoté + verdict + rayon d'impact
instrument-dashboardInstrumentmât de KPI + graphiques lignes/barres honnêtes + tableau triable/filtrable
editorial-conceptEditorialexplicateur de concept : navigation scroll-spy + SVG personnalisé + naïf-vs-correct + notes marginales
notebook-teachNotebookmode TEACH : pas-à-pas + prédire puis révéler + vérification du transfert
swiss-comparisonSwissmatrice de décision : chiffres surdimensionnés + tableau de comparaison triable
luminous-flowLuminousbascule de scénario (réussite/échec) + graphe routé + effet lumineux optionnel
mermaidn'importe lequelMermaid thématisé avec zoom / panoramique / extension
slidesn'importe lequeldiaporama plein écran avec navigation clavier/défilement

Routage des références — lisez uniquement ce dont la sortie actuelle a besoin

BesoinLisez
Comment décider quoi/comment montrer (le cerveau)references/synthesis-method.md
Les 7 langages, grille d'évaluation, test du plissement d'yeuxreferences/aesthetic-languages.md
Niveaux de tokens, chaque composant .ux-, construction/assemblagereferences/component-contract.md
Catalogue des représentations + routage forme des données × tâchereferences/representations.md
Curseurs, toggles de scénarios, steppers, graphes, scroll-spy — l'API JSreferences/interactivity.md
Graphiques honnêtes : registre des nombres, classement des canaux, règles des axesreferences/charts-honesty.md
Mode TEACH : état de l'apprenant, concret d'abord, prédire-révéler, transfertreferences/teaching.md
Livrets par tâche (review de PR, post-mortem, ADR, profil de performance, …)references/playbooks.md
Autonomie, sécurité du débordement, boucle de vérification, checklist de livraisonreferences/self-contained.md
Mermaid thématisé (quand + comment)references/mermaid.md
Diaporamasreferences/slides.md

Invariants

  • La vérité prime sur la beauté et l'artisanat. Ancrez ou omettez ; nuancez le contenu inféré/supposé ; n'inventez jamais de couches, de symétries, de liens ou de justifications. Les plages/fonctions interactives sont ancrées ou estampillées "modèle illustratif."
  • Un langage par page, choisi selon le mérite et enregistré. Il doit passer le test du plissement d'yeux. L'effet lumineux est réservé à Luminous, routé via --fx-* afin que data-fx="flat" le supprime proprement ; pas de respiration/pulsation continue sur du contenu statique.
  • Pas de défilement horizontal de la page. min-width:0 sur les enfants grid/flex ; le contenu large (diffs, tableaux, Mermaid) défile dans son propre conteneur overflow-x:auto. Vérifiez à 360px.
  • Les deux thèmes sont composés. Le thème clair est réajusté, pas inversé. La page s'ouvre dans son thème choisi et le lecteur peut basculer (persisté par preset) ; respectez prefers-reduced-motion ; gardez le focus clavier visible ; sûr pour l'impression.
  • Les composants consomment uniquement des tokens sémantiques + --fx-* — jamais de hex. Les nouveaux looks proviennent de packs de thèmes, pas de couleurs en ligne.
  • Ne définissez jamais de classe .node au niveau de la page — Mermaid l'utilise en interne. Toutes les classes UltraExplainer sont préfixées par .ux-.
  • Observez avant de livrer. Rendez la page, regardez-la, corrigez ce qui ne va pas. N'affirmez pas ce que vous n'avez pas mesuré.

Checklist finale

Document autonome au bon chemin · construit avec le preset choisi · aucune erreur console · aucun débordement horizontal sur desktop ou à 360px · les polices se dégradent gracieusement · la thèse est évidente dans le premier viewport avec exactement un point focal · les tableaux/diffs/diagrammes défilent dans leurs propres conteneurs · les bascules de thème (et d'effet lumineux Luminous) fonctionnent · chaque affirmation est ancrée ou nuancée · la page a été effectivement rendue et inspectée.

Skills associés