Mes outils maison pour Claude Code : pourquoi je n’installe pas de skills tout faits
Depuis des mois, je construis mes propres outils pour Claude Code sans jamais les montrer. Ce soir, je passe le cap : quatre mods sur mesure, pourquoi je n’installe pas de skills tout faits, mes choix et les mesures.

Ça fait longtemps que je fais ça. Je ne l'avais jamais montré.
Depuis des mois, je construis mes propres outils autour de l'IA. J'ai une base de notes qui sert de mémoire à mon assistant, des recettes de travail écrites une à une, une équipe d'agents maison qui a remplacé un plugin pourtant très populaire. J'ai aussi ma barre d'état sur mesure. Mon premier mod remonte à octobre. Tout ça tourne chaque jour sur mon poste, pour les projets de mes clients.
Et je n'en avais jamais parlé. Ce n'était pas un secret, juste du travail d'atelier : un besoin, un outil, puis le besoin suivant. Je me disais que ça n'intéresserait que moi. En parallèle, je voyais passer chaque semaine des listes de « skills indispensables » à installer en une commande. À force, j'avais l'impression que bien travailler avec l'IA revenait surtout à collectionner les outils des autres.
Ce soir, j'en ai eu assez de garder ça dans mon coin. J'ai passé le cap : je vous montre comment je travaille vraiment.
Des outils taillés pour ma façon de travailler
Dans mon article sur ma façon de travailler avec l'IA au quotidien, je décrivais Claude Code comme un collègue très rapide qu'il faut encadrer. Il manquait un morceau à l'histoire : en plus de lui donner des règles, je lui construis ses propres outils.
Un tableau de bord du projet en cours, un moyen de faire dialoguer plusieurs sessions d'IA, un aiguillage vers le bon modèle selon la difficulté de la demande et un mode « chef d'orchestre » qui répartit le travail entre plusieurs agents.
J'ai imaginé chaque concept et tranché chaque choix. Claude, lui, a vérifié la faisabilité, proposé des améliorations, écrit le code et les tests, puis mesuré le résultat en conditions réelles. Je décide, il construit et vérifie.
Des « skills » et des plugins prêts à installer, il en existe des dizaines. Je n'en utilise aucun. Pour comprendre pourquoi, il faut d'abord que je vous explique ce que j'appelle un mod.
Un mot sur la forme. Cet article s'adresse autant à des chefs d'entreprise qu'à des développeurs : j'explique donc certaines choses simplement, c'est voulu. Si vous êtes du métier, les encadrés « Sous le capot » donnent le détail technique de chaque outil.
Un « mod », c'est quoi ?
Claude Code est l'assistant de programmation avec lequel je travaille tous les jours. Il intervient directement dans mes projets : il lit le code, le modifie et lance les tests. Pour l'étendre, plusieurs possibilités existent.
Les skills sont des recettes écrites en texte que l'IA suit pour une tâche, comme préparer un devis ou publier un plugin. Les connecteurs, aussi appelés MCP, la branchent sur un outil extérieur : ma base de notes, ce site ou mon agenda. Les mods, eux, sont de petits programmes qui modifient le comportement et l'interface de Claude Code lui-même.
Un mod peut ajouter un panneau à côté de la conversation, une bande d'information au-dessus de la saisie ou une commande. Il peut aussi intervenir au moment où je valide une demande, où l'IA s'apprête à interroger le modèle, où elle lance un sous-agent. C'est là que ça commence à m'intéresser : je ne décore plus l'outil, j'agis sur la façon dont le travail se déroule.
Sous le capot. Un mod est un module TypeScript qui enregistre des « hooks » sur des événements du moteur, sur le principe d'un middleware : chaque hook reçoit l'événement, peut le laisser passer, le modifier, ou répondre à sa place. Les miens s'accrochent à cinq moments : la validation d'une demande (
prompt.submit), le début d'un tour de travail (turn.start), chaque requête envoyée au modèle (turn.step), le lancement d'un sous-agent (agent.spawn) et l'affichage (ui.render). Tout ce qui touche l'extérieur (fichiers, processus, réseau, interface) passe par un objet unique fourni par le moteur : le mod n'a aucun accès direct au système, ce qui le garde lisible et vérifiable.
export const register: Register = on => {
// Avant chaque requête au modèle : laisser passer, ou modifier.
on('turn.step', async function* ($, e, next) {
return yield* next(e)
})
}
Pourquoi je n'installe pas de skills tout faits
1. Mes besoins ne sont pas ceux de tout le monde
Un skill public doit convenir à beaucoup de monde. De mon côté, je gère seul une quarantaine de projets, avec mes conventions, mes serveurs et mes habitudes. Il y a forcément des choses qui collent mal.
Pour l'aiguillage automatique des modèles, je ne suis donc pas parti d'une règle trouvée en ligne. Claude a étudié mes sessions des 60 derniers jours : 259 sessions, 2 323 demandes. Il a classé chaque demande par type, puis mesuré le travail qu'elle avait entraîné : nombre d'actions, volume de texte produit, durée. C'est cette étude qui a donné le tableau de décision.
Sous le capot. La source, ce sont les journaux bruts des sessions : des fichiers JSONL, une ligne par événement (ma demande, chaque réponse du modèle avec son compteur de tokens, chaque appel d'outil). Un script les parcourt, découpe la conversation en tours (d'une demande tapée à la suivante), additionne les appels d'outils et les tokens produits, puis classe la demande par motifs de texte. Les résultats sont exprimés en médiane et en 80e centile, pas en moyenne : quelques sessions marathon de plus de cent actions suffiraient à tirer une moyenne vers le haut et à fausser tout le tableau.
Elle a aussi fait ressortir des choses qu'un outil générique n'aurait pas devinées. Certaines m'ont surpris ; j'y reviens plus bas.
2. Un outil installé travaille aussi quand on l'oublie
Un plugin ajoute du texte au contexte de l'IA et déclenche des traitements, parfois à chaque action. J'ai eu des sessions anormalement lentes avant de pouvoir attribuer le problème, mesures à l'appui, à un plugin de revue automatique. Il relançait une analyse à chaque arrêt de l'IA. Une fois désactivé, le problème a disparu.
Avec un outil maison, je sais ce que je lui ai demandé de faire et ce qui tourne en arrière-plan. Ça évite de chercher pourquoi une conversation se traîne.
3. Je veux pouvoir comprendre et réparer
Quand un de mes outils se comporte mal, je sais ce qu'il fait, donc pourquoi il réagit ainsi. Chaque mod a ses tests automatiques : 15 pour l'aiguillage des modèles (écrits avant le code), 4 pour les sessions, 3 pour le tableau de bord. Je note les décisions dans ma base de connaissances et je documente les pièges rencontrés pour ne pas retomber dedans.
Ce suivi me sert aussi quand Anthropic change le fonctionnement de Claude Code. Je peux adapter mes outils dans l'heure, sans attendre la mise à jour de quelqu'un que je ne connais pas. Pour des outils dont je me sers chaque jour, cette autonomie compte.
4. Ce que j'installe a accès à mon travail
C'est ce qui pèse le plus dans mon choix. Un plugin, un skill ou une extension s'exécute avec les mêmes droits que moi. Il peut lire mes projets, mes notes et mes accès.
Lors de mes propres audits, j'ai découvert une application tierce qui ajoutait discrètement une consigne dans chaque demande envoyée à l'IA et se réinstallait à chaque lancement. J'ai aussi dû vérifier un par un mes projets et leurs dépendances lors de l'alerte sur un ver qui se propageait par des paquets npm.
Rien de catastrophique dans ces deux cas. Mais ça donne peu envie d'installer quelque chose simplement parce que tout le monde en parle. Moins j'ai de code étranger dans mon environnement, moins je m'expose aux surprises. Ce que j'utilise, je l'ai lu ou écrit.
Ma méthode : je propose, Claude construit, je tranche
Pour chaque outil, je commence par décrire l'idée. Parfois, elle tient en une phrase assez floue : « un mod qui permet de communiquer avec mes autres sessions ». Claude lit alors la documentation du moteur et vérifie ce qui est faisable. Il me répond : possible, impossible, ou possible avec telle limite.
Ensuite viennent les questions qui comptent, avec des choix et une recommandation. Je réponds en quelques clics. Il écrit les tests avant le code, écrit le code, puis vérifie que tout passe. Enfin, on essaie en conditions réelles, et il contrôle le résultat dans les journaux. Une interface qui a l'air de fonctionner ne suffit pas à valider ce qui se passe derrière. Un test automatique non plus, d'ailleurs : il simule le moteur, il ne prouve rien sur le vrai. Pour un agent, la preuve, c'est sa transcription : le modèle demandé (requestedModel) comparé au modèle qui a effectivement répondu.
Quatre principes guident tous ces outils, et ce sont des principes d'ingénierie avant d'être des principes d'IA :
- une seule décision par tour : le modèle ne change jamais au milieu d'une réponse ;
- le repli sûr : si un élément doute, échoue ou répond mal, rien ne change, on garde le comportement par défaut ;
- l'humain a le dernier mot : un réglage manuel suspend l'automatisme au lieu d'être écrasé ;
- tout est observable : chaque choix automatique s'affiche, avec sa raison.
En chemin, j'ai choisi d'afficher les décisions de l'IA sans devoir toutes les confirmer, d'autoriser le modèle le plus puissant pour l'architecture, de respecter les agents qui ont déjà leur propre réglage et de déclencher automatiquement le mode chef d'orchestre. Ces choix définissent ma façon de travailler. C'est là que je veux garder la main.
Outil 1 : le tableau de bord du projet
Ce premier mod existait déjà ; je l'ai fait redessiner. Son panneau reste ouvert à côté de la conversation. Il me permet de voir ce qui est fait, ce qui est en cours et ce qu'il reste à faire.
Il se remplit seul à partir de l'état du dépôt de code, notamment les fichiers modifiés et le travail non publié, du journal des modifications et des listes de tâches. L'IA y inscrit aussi ce qu'elle commence ou termine d'important.
Dans la nouvelle version, l'en-tête affiche le nom du projet, la branche de travail et trois compteurs. Les sections suivent l'ordre dont j'ai besoin au quotidien : en cours, à faire, fait.
Quand je reprends un projet après deux semaines, je retrouve ainsi où on en est sans relire toute la conversation. Même chose lorsque l'IA vient d'enchaîner une longue série d'actions. Je peux regarder le panneau et reprendre le fil ; ma mémoire personnelle apprécie le renfort.
Sous le capot. Le panneau croise quatre sources : l'état du dépôt (
git status --porcelain, commits non poussés), les titres du journal des modifications, le fichier de reprise du projet et la phase de travail déclarée par l'IA. Il se recalcule à la fin de chaque tour, en différé, pour ne jamais ralentir la conversation. L'IA dispose en plus d'un outil dédié pour y écrire ses propres listes ; elles sont rangées par projet, dans le stockage du mod, sans rien ajouter aux dépôts de code.
Outil 2 : faire dialoguer mes sessions
Je travaille rarement sur un seul projet à la fois. J'ai parfois cinq ou six sessions de Claude Code ouvertes en parallèle, chacune dans son projet. Jusqu'ici, elles s'ignoraient.
Avec le mod « Sessions Claude », la commande /sessions affiche les autres sessions ouvertes sur ma machine, leur état, libre ou occupée, et depuis quand elles tournent. Je choisis une session dans un panneau, puis ce que je veux lui transmettre.
Je peux lui déléguer une tâche : l'IA de ma session transmet la demande, attend le compte rendu et me le résume. Je peux aussi ouvrir un échange entre les deux IA, dont la mienne me fera la synthèse. Ou simplement envoyer un message direct, tel quel, sans suivi.
Claude a proposé un choix de conception auquel je tiens : pour une délégation, l'IA reste dans la boucle. Le panneau demande à celle de ma session de transmettre la tâche, de suivre la réponse et de me rendre compte. Sans ce suivi, un message part, puis on ne sait plus très bien si le travail a abouti. Ce serait dommage de fabriquer un outil pour mieux perdre le fil.
Sous le capot. La liste vient de l'outil interne qui recense les sessions locales (
ListAgents) ; le mod analyse sa sortie et la rafraîchit au plus une fois par minute, sans minuterie permanente. Une délégation n'est pas un envoi brut : le mod soumet une consigne à l'IA de ma session, qui envoie parSendMessage, attend la réponse et la résume. Les messages reçus sont observés sans être interceptés : le mod les note dans l'historique, puis les laisse passer intacts, pour ne jamais priver l'IA d'une réponse.
Outil 3 : le bon modèle pour chaque demande
C'est le plus ambitieux des quatre. Anthropic propose plusieurs modèles, du plus léger au plus puissant : Haiku, Sonnet, Opus, Fable. Chacun possède un niveau de réflexion réglable, appelé « effort ». Augmenter la puissance du modèle et l'effort donne une réponse plus soignée, mais demande davantage de temps et coûte plus cher.
Je faisais ces réglages à la main. D'après l'étude de mes sessions, je les ai changés 26 fois en deux mois. C'est fastidieux, et facile à oublier. On finit par laisser le modèle le plus cher s'occuper d'un simple « fais le commit ». Pas vraiment de quoi mobiliser toute la cavalerie.
Ce que mes sessions ont révélé
La première surprise concerne les réponses courtes. Un « ok, vas-y » ou « 1a, 2b » lance généralement le travail préparé au tour précédent : 12 actions en médiane. Si l'outil ne regardait que la longueur de ma réponse, il choisirait le modèle le plus léger au moment précis où le travail commence. Le mien conserve donc le réglage précédent.
Les demandes vraiment légères sont d'ailleurs rares : entre 10 et 27 % selon le type. Le modèle le plus léger sert surtout à évaluer les demandes ; il leur répond rarement lui-même.
Enfin, les types de demandes ont des besoins différents. Pour chercher un bug, il faut de la réflexion. Pour un commit, de la méthode. Pour une question, de la précision. Le tableau devait tenir compte de ces différences.
Un tableau pour les cas clairs, un avis pour les autres
Quand la demande est reconnaissable, le tableau décide immédiatement, sans appel à une IA :
| Type de demande | Nombre dans l'étude | Modèle · effort |
|---|---|---|
| Débogage, déploiement | 286 / 47 | Opus · élevé |
| Création d'une fonctionnalité | 193 | Opus · élevé |
| Rédaction | 96 | Opus · moyen |
| Modification | 118 | Sonnet · élevé |
| Git, lecture, question | 212 / 96 / 67 | Sonnet · moyen |
| Architecture | 198 | avis de Haiku, Fable possible |
| Réponse courte | même choix qu'avant |
Pour les demandes ambiguës, le mod interroge Haiku. En une seconde environ, pour un coût négligeable, il propose un modèle, un effort et quelques mots de justification. Si sa réponse est mal formée ou arrive trop tard, rien ne change.
Je vois le choix dans une bande au-dessus de la saisie, par exemple : « Routage auto : actif · Sonnet medium — git (table) · cache 99 % ». Un bouton permet de tout couper. Si je règle le modèle à la main, l'aiguillage se met automatiquement en pause. Je veux pouvoir reprendre la main sans que mon propre outil vienne me contredire.
Sous le capot. La décision est prise une seule fois par demande, au démarrage du tour (
turn.start) ; l'avis de Haiku, quand il en faut un, tourne pendant que le tour démarre. Elle est ensuite réappliquée à chaque requête envoyée au modèle (turn.step), car une modification ne vaut que pour une requête. L'avis de Haiku dispose de 5 secondes et doit respecter un format JSON strict, avec une liste blanche de modèles et d'efforts : au moindre écart, repli sûr, rien ne change. Les tours lancés sans demande tapée (une notification d'agent, par exemple) reprennent le dernier choix, pour ne pas repartir sur le modèle par défaut.
on('turn.step', async function* ($, e, next) {
const choix = await decisionDuTour(e.turnId) // table ou avis de Haiku
if (!choix) return yield* next(e) // rien à changer
return yield* next({ ...e, model: choix.modele, effort: choix.effort })
})
Le cache, ou ce que le prix du modèle ne dit pas
Pendant les tests, il a fallu regarder le cache. Pour ne pas relire toute la conversation à chaque échange, le service conserve côté serveur ce qu'il a déjà lu. C'est ce qui rend les longues sessions rapides et économiques. Seulement, ce cache est propre à chaque modèle.
Il fonctionne par préfixe : tant que le début de la conversation est identique et que le modèle ne change pas, cette partie est relue depuis le cache au lieu d'être retraitée. Changer l'effort ne touche pas à ce préfixe. Changer de modèle, si : on repart d'un cache vide pour le nouveau modèle.
Claude en a mesuré l'effet dans les journaux de mes sessions :
| Situation | Part du contexte relue depuis le cache |
|---|---|
| Changement d'effort seul, même modèle (conversation de 245 000 tokens) | 99 % |
| Passage d'Opus à Fable | 0 % sur la première requête (90 000 tokens relus d'un coup) |
| Passage d'Opus à Sonnet | 46 % sur la première requête, puis 99 % |
Changer l'effort ne coûte rien ; changer de modèle coûte une relecture complète. Dans une longue conversation, passer à un modèle moins cher peut donc revenir plus cher que de rester sur le même. Le tarif du modèle ne raconte pas toute l'histoire.
J'ai retenu cette règle : au-delà de 60 000 tokens de contexte, l'outil ne descend plus de modèle et ne règle plus que l'effort. La taille du contexte n'est pas estimée : elle est lue dans les compteurs d'usage renvoyés par l'API à chaque requête. Le seuil de 60 000, lui, est un réglage de départ, pas une vérité : je l'ajusterai avec les mesures. C'est en discutant de cette limite qu'est venue l'idée du quatrième outil.
Outil 4 : le mode chef d'orchestre
Mon idée : si le cache « bloque » une session sur son modèle, elle peut devenir chef d'orchestre. Elle découpe le travail et le confie à des sous-agents. Chacun démarre avec un contexte neuf et un modèle adapté à sa tâche, pendant que le cache de la session principale reste intact.
Claude a confirmé la faisabilité et précisé les responsabilités : le découpage du travail restait mon rôle ; le réglage de chaque agent pouvait être automatisé par le mod. Il a ensuite construit l'ensemble.
Comment ça fonctionne
Dès que la conversation dépasse 60 000 tokens, le mod glisse une consigne à l'IA, une seule fois : déléguer les tâches autonomes à des agents avec des instructions complètes, au plus quatre en parallèle, et jamais deux sur les mêmes fichiers.
Le mod règle ensuite chaque agent avec le même tableau que pour mes demandes. Un inventaire de fichiers part sur Sonnet en effort moyen ; une recherche de bug, sur Opus en effort élevé. Certains agents ont déjà leur modèle attitré, comme mon « architecte », qui utilise le plus puissant. Ceux-là gardent leur réglage.
Je peux suivre le travail dans une seconde ligne de la bande : « Orchestrateur · contexte 245k · 2 agents en cours ». Le panneau « Flotte » détaille pour chaque agent le modèle, l'effort, la raison du choix, l'état, la durée et la production. Je peux donc voir qui travaille et avec quels moyens.
Sous le capot. La consigne de délégation n'est pas ajoutée au prompt système : elle accompagne la demande elle-même, en fin de conversation. Modifier le début de la conversation aurait invalidé tout le cache, celui-là même qu'on cherche à protéger. Le modèle et l'effort de chaque agent sont imposés à chaque requête qu'il envoie (
turn.step, repérée par l'identifiant de l'agent), pas seulement à son lancement : la vérification sur les journaux réels a montré que le moteur ne tenait pas compte du réglage passé au lancement. Les agents lancés par mes scripts d'automatisation, qui ont leurs propres règles, ne sont jamais touchés.
Le test en conditions réelles
Pour vérifier l'ensemble, j'ai lancé cinq agents en parallèle sur de vraies tâches : un inventaire de fichiers, un état du dépôt de code, une recherche de bug, une documentation à rédiger et un avis d'architecture. Claude a ensuite regardé dans les journaux de chaque agent quel modèle avait réellement répondu et avec quel effort.
Après mise au point, tous ont utilisé le réglage prévu par le tableau, et l'architecte a conservé le sien. L'agent chargé de chercher un bug en a même trouvé un vrai dans le mod lui-même. Il a été corrigé dans la foulée. Au moins, celui-là n'a pas eu à chercher loin.
J'avais aussi demandé à l'architecte s'il fallait fusionner les trois mods. Sa recommandation a été de les garder séparés, pour pouvoir couper l'aiguillage sans perdre le reste.
Il reste une mesure à avoir en tête : les consignes et les outils d'un agent représentent déjà environ 57 000 tokens à sa première requête. Il ne démarre donc pas à vide. C'est un arbitrage à faire à chaque fois : d'un côté ce coût d'entrée, payé au tarif du modèle de l'agent ; de l'autre, le travail qu'on évite d'ajouter à une conversation longue et coûteuse. Pour une petite action, la session principale reste plus efficace ; déléguer ne vaut le coup que si la tâche a une certaine taille.
Ce que ça change, pour moi et pour mes clients
Je n'ai plus à penser au niveau de réflexion à chaque demande. La puissance va aux bugs et aux décisions, la rapidité aux tâches mécaniques. Les sessions longues restent fluides parce que le travail lourd part chez les agents au lieu de s'accumuler dans la conversation.
Et je vois ce qui se passe : quel modèle travaille, sur quoi, depuis combien de temps. C'est appréciable quand plusieurs choses avancent en parallèle.
Pour les entreprises avec qui je travaille, l'effet est indirect, mais réel : davantage de temps pour la conception et les échanges, des coûts d'outillage maîtrisés et la garantie que les outils qui touchent à leurs projets ont été lus, testés et compris par celui qui s'en sert.
Et chez vous ?
Vous n'avez pas besoin d'écrire des mods pour regarder vos outils de cette façon. Avant d'en ajouter un, prenez le temps de voir comment vous utilisez ceux que vous avez déjà. Les mesures peuvent réserver quelques surprises, comme mes fameuses réponses courtes qui déclenchent le gros du travail.
Le « prêt à installer » mérite aussi qu'on s'y arrête : ce qui s'installe s'exécute avec vos droits, et chaque ajout a un coût, même quand il ne se voit pas. Quant aux décisions, gardez-les. L'IA peut proposer, construire et vérifier ; c'est à vous de choisir ce qui compte dans votre activité.
Si vous vous demandez comment l'IA pourrait s'intégrer dans votre propre activité, sans boîte noire ni gadget, parlons-en.
Clin d'œil : cet article a été préparé avec ces outils. L'IA a rassemblé les mesures dans mes notes et les journaux de session, puis rédigé un premier jet à partir de mes réponses à une série de questions de cadrage. Elle l'a déposé en brouillon sur ce site via son connecteur. Une seconde IA, Codex, a ensuite retravaillé le style pour le rendre plus naturel et dessiné l'image de couverture. Je l'ai relu et corrigé avant de le publier.


