mattpocock/ask-matt

Demandez quelle compétence ou quel flux correspond à votre situation. Un routeur pour les compétences de ce dépôt.

Qu'est-ce que ask-matt ?

Ask Matt est un routeur de compétences conçu pour aider les développeurs à choisir le bon flux de travail parmi un ensemble de compétences spécialisées. Il répond à la difficulté commune de se souvenir de l'outil approprié pour chaque situation de développement, en particulier lors de la navigation entre l'idéation, le prototypage, l'implémentation et la maintenance. La compétence est structurée autour d'un flux principal ("idée → livraison") avec des voies d'accès pour les bugs et les demandes, un vocabulaire fondamental pour la modélisation du domaine et la conception du code, et des compétences autonomes pour la recherche, le prototypage et l'apprentissage. Elle prend en charge la gestion du contexte entre les sessions via des mécanismes de handoff et de compactage, garantissant ainsi que les sessions longues restent dans la "zone intelligente" pour des performances optimales. Ask Matt fonctionne comme une couche de navigation qui oriente l'utilisateur vers les compétences spécialisées comme `/grill-with-docs`, `/tdd`, `/implement`, et `/code-review` en fonction de son entrée.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/mattpocock/skills/tree/main/skills/engineering/ask-matt

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

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

Documentation

Demandez à Matt

Vous ne vous souvenez pas de chaque compétence, alors demandez.

Un flux est un chemin à travers les compétences. La plupart des chemins suivent un flux principal, et deux voies d'accès le rejoignent. Tout le reste est autonome, ou une couche de vocabulaire qui s'exécute en dessous.

Le flux principal : idée → livraison

Le chemin que la plupart des travaux empruntent. Vous avez une idée et vous voulez la construire.

  1. /grill-with-docs — affinez l'idée par entretien. Commencez ici quand vous avez une base de code : elle est avec état, conservant ce qu'elle apprend dans CONTEXT.md et les ADR. (Pas de base de code ? Utilisez /grill-me — voir Autonome. Les deux exécutent la même primitive /grilling ; grill-with-docs est celle qui laisse une trace écrite.)

  2. Embranchement — pouvez-vous régler chaque question par la conversation ? Si une question nécessite une réponse exécutable (état, logique métier, une UI que vous devez voir), faites un détour par un prototype, ponté par /handoff dans les deux sens (voir Sessions croisées) :

    • /handoff sortir, puis ouvrez une nouvelle session sur ce fichier,
    • /prototype pour répondre à la question avec du code jetable,
    • /handoff revenir avec ce que vous avez appris, et référencez-le depuis le fil de discussion de l'idée originale.
  3. Embranchement — s'agit-il d'une construction multi-sessions ?

    • Oui → /to-prd (transformez le fil de discussion en PRD) → /to-issues (divisez la PRD en issues pouvant être prises indépendamment). Comme les issues sont indépendantes, effacez le contexte entre chacune d'elles : démarrez une session fraîche par issue et lancez /implement en lui passant la PRD et l'issue unique à traiter.
    • Non → /implement ici même, dans la même fenêtre de contexte.

    Dans les deux cas, /implement construit chaque issue en pilotant /tdd en interne — une tranche rouge-vert à la fois — puis se termine en exécutant /code-review, une revue à deux axes (Normes + Spécifications) du diff, avant de commiter. Utilisez /tdd seul quand vous voulez juste construire un comportement concret en test-first sans spécification complète, et /code-review seul quand vous voulez passer en revue une branche ou une PR par rapport à un point de référence.

Hygiène du contexte

Gardez les étapes 1 à 3 dans une même fenêtre de contexte ininterrompue — ne compactez pas et n'effacez pas avant /to-issues — pour que le grilling, la PRD, et les issues soient tous bâtis sur la même réflexion. Chaque /implement démarre ensuite frais, en travaillant à partir de l'issue.

La limite est la zone intelligente : la fenêtre (~120k tokens sur les modèles de pointe) dans laquelle le modèle raisonne encore nettement. Si une session s'en approche avant /to-issues, ne poussez pas sur un modèle dégradé — faites /handoff et continuez dans un nouveau fil.

Voies d'accès

Une situation de départ qui génère du travail, puis rejoint le flux principal.

  • Les bugs et demandes s'accumulent → /triage. Il déplace les issues à travers les rôles de triage et produit des issues prêtes pour l'agent, que /implement reprendra plus tard.

    Le triage est uniquement pour les issues que vous n'avez pas créées — rapports de bugs, demandes de fonctionnalités entrantes, tout ce qui arrive brut. Les issues que /to-issues a produites sont déjà prêtes pour l'agent, donc ne les triez pas.

  • Quelque chose est cassé → /diagnosing-bugs. Pour les cas difficiles : le bug qui résiste à un premier coup d'œil, l'instabilité intermittente, la régression qui s'est glissée entre deux états connus comme bons. Il refuse de théoriser avant d'avoir une boucle de rétroaction serrée — une commande qui est déjà rouge sur ce bug — puis corrige avec un test de régression. Son débriefing passe à /improve-codebase-architecture quand la vraie découverte est qu'il n'y a pas de bon point de coupure pour verrouiller le bug.

Santé de la base de code

Pas du travail sur les fonctionnalités — de l'entretien.

  • /improve-codebase-architecture — exécutez dès que vous avez un moment libre pour garder la base de code propice au travail des agents. Il fait remonter des opportunités d'approfondissement ; en choisir une génère une idée que vous pouvez emmener dans le flux principal à /grill-with-docs. C'est l'étude qui trouve les candidats ; /codebase-design (ci-dessous) est l'établi sur lequel vous concevez celui que vous avez choisi.

Vocabulaire sous-jacent

Deux références invoquées par le modèle qui s'exécutent en dessous des autres compétences — chacune est la source unique de vérité pour son vocabulaire. Utilisez-les directement quand ce sont les mots, pas le processus, qui posent problème ; ou laissez les compétences ci-dessus les invoquer.

  • /domain-modeling — affinez le langage domaine du projet : défiez un terme flou, résolvez un mot surchargé ("compte" faisant trois jobs), enregistrez une décision difficile à revenir en arrière comme un ADR. C'est la discipline active que /grill-with-docs pilote pour maintenir CONTEXT.md comme un glossaire propre.
  • /codebase-design — le vocabulaire des modules profonds (module, interface, profondeur, point de coupure, adaptateur, levier, localité) pour concevoir la forme d'un module : beaucoup de comportement derrière une petite interface à un point de coupure propre. /tdd et /improve-codebase-architecture parlent tous deux ce langage.

Sessions croisées

  • /handoff — quand un fil de discussion est plein ou que vous devez bifurquer (par exemple dans une session /prototype), cela compacte la conversation en un fichier Markdown. Vous ne continuez pas sur place — vous ouvrez une nouvelle session et référencez ce fichier pour transporter le contexte. C'est le pont entre les fenêtres de contexte, dans les deux sens. Utilisez-le quand vous voulez une session fraîche mais que vous devez préserver la conversation actuelle.
  • /compact (intégré) — restez dans la même conversation, en laissant les tours précédents être résumés. Utilisez-le lors de pauses intentionnelles entre les phases, quand cela ne vous dérange pas de perdre l'historique textuel. Ne compactez pas en milieu de phase — l'agent pourrait perdre le fil. /handoff bifurque ; /compact continue.

Autonomes

Hors du flux principal.

  • /grill-me — le même entretien acharné que /grill-with-docs, mais pour quand vous n'avez pas de base de code. Sans état : il ne sauvegarde rien localement, ne construit pas de CONTEXT.md. Utilisez-le pour affiner tout plan ou conception qui ne vit pas dans un dépôt.
  • /prototype — un petit programme jetable qui répond à une question de conception : ce modèle d'état semble-t-il correct, ou à quoi devrait ressembler cette UI. Jetable dès le premier jour — gardez la réponse, supprimez le code. C'est le détour à l'étape 2 du flux principal, mais utilisez-le à tout moment quand une question de conception est difficile à trancher sur le papier.
  • /research — déléguez la lecture de fond à un agent d'arrière-plan : il étudie une question à partir de sources primaires, puis laisse un fichier Markdown cité dans le dépôt. Continuez à travailler pendant qu'il lit. Le fichier qu'il produit est quelque chose à emmener dans le flux principal à /grill-with-docs — la recherche alimente la réflexion, elle ne la remplace pas.
  • /teach — apprenez un concept sur plusieurs sessions, en utilisant le répertoire courant comme espace de travail avec état.
  • /writing-great-skills — référence pour écrire et éditer des compétences efficacement.

Précondition

/setup-matt-pocock-skills — exécutez avant votre premier flux d'ingénierie pour configurer le gestionnaire d'issues, les étiquettes de triage et la disposition des documents que les autres compétences supposent. Les gestionnaires d'issues personnalisés fonctionnent également.

Individual skills in this repo

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

mattpocock/caveman

Ultra-compressed communication mode. Cuts token usage ~75% by dropping filler, articles, and pleasantries while keeping full technical accuracy. Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens", "be brief", or invokes /caveman.

mattpocock/claude-handoff

Hand the current conversation off to a fresh background agent that picks up the work immediately.

mattpocock/codebase-design

Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.

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".

mattpocock/diagnose

Disciplined diagnosis loop for hard bugs and performance regressions. Reproduce → minimise → hypothesise → instrument → fix → regression-test. Use when user says "diagnose this" / "debug this", reports a bug, says something is broken/throwing/failing, or describes a performance regression.

mattpocock/diagnosing-bugs

Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.

mattpocock/domain-modeling

Build and sharpen a project's domain model. Use when the user wants to pin down domain terminology or a ubiquitous language, record an architectural decision, or when another skill needs to maintain the domain model.

mattpocock/edit-article

Edit and improve articles by restructuring sections, improving clarity, and tightening prose. Use when user wants to edit, revise, or improve an article draft.

mattpocock/git-guardrails-claude-code

Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute. Use when user wants to prevent destructive git operations, add git safety hooks, or block git push/reset in Claude Code.

mattpocock/grilling

Grill the user relentlessly about a plan or design. Use when the user wants to stress-test a plan before building, or uses any 'grill' trigger phrases.

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".

mattpocock/grill-with-docs

Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.

mattpocock/handoff

Compact the current conversation into a handoff document for another agent to pick up.

mattpocock/implement

Implement a piece of work based on a PRD or set of issues.

mattpocock/implement-spec

Implement a specification in code.

mattpocock/improve-codebase-architecture

Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.

mattpocock/loop-me

Grill me about specs for the workflows I want to build, within this workspace.

mattpocock/migrate-to-shoehorn

Migrate test files from `as` type assertions to @total-typescript/shoehorn. Use when user mentions shoehorn, wants to replace `as` in tests, or needs partial test data.

mattpocock/obsidian-vault

Search, create, and manage notes in the Obsidian vault with wikilinks and index notes. Use when user wants to find, create, or organize notes in Obsidian.

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.

Skills associés