Communitygithub.com

madnpc/skills

Compétences d'agent pour « Le dernier NPC n'est pas normal » · Compétences de workflow réutilisables.

Qu'est-ce que skills ?

Ce dépôt propose un ensemble de compétences (skills) pour agents IA, dans le cadre du projet « Le dernier NPC n'est pas normal ». Il contient une compétence complète de développement piloté par les tests (TDD) qui définit une approche disciplinée pour écrire des tests d'intégration centrés sur le comportement visible plutôt que sur les détails d'implémentation. La compétence insiste sur une approche par tranches verticales (tracer bullets) où chaque test est immédiatement suivi de l'implémentation minimale nécessaire, évitant l'anti-pattern des tranches horizontales. Elle intègre des listes de contrôle pour chaque cycle de test, des phases de planification et de refactorisation, et s'applique à tout agent capable d'interagir avec du code source, comme Claude Code, Cursor ou Codex. L'objectif est de produire des tests robustes aux refactorisations, lisibles comme des spécifications, et de minimiser les tests fragiles couplés à l'implémentation interne.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add madnpc/skills

Demander à votre IA préférée

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

Documentation

Développement Piloté par les Tests

Langue de sortie

Par défaut, communique avec l'utilisateur en français et rédige les stratégies de test, les descriptions de test et les résumés d'implémentation en français. Si l'utilisateur précise explicitement une autre langue ou si la documentation existante suit une autre convention, cette convention est respectée ; le code, les commandes, les noms de produits et les citations qui doivent rester dans leur langue originale ne sont pas traduits de force.

Philosophie

Principe fondamental : Les tests doivent vérifier le comportement via les interfaces publiques, pas les détails d'implémentation. Le code peut changer entièrement ; les tests ne devraient pas.

Les bons tests sont de style intégration : ils exercent des chemins de code réels à travers les API publiques. Ils décrivent ce que le système fait, pas comment il le fait. Un bon test se lit comme une spécification – « l'utilisateur peut valider sa commande avec un panier valide » vous indique exactement quelle capacité existe. Ces tests survivent aux refactorisations car ils ne se soucient pas de la structure interne.

Les mauvais tests sont couplés à l'implémentation. Ils simulent des collaborateurs internes, testent des méthodes privées, ou vérifient par des moyens externes (comme interroger une base de données directement au lieu d'utiliser l'interface). Le signe d'alerte : votre test échoue lorsque vous refactorisez, alors que le comportement n'a pas changé. Si vous renommez une fonction interne et que les tests échouent, ces tests testaient l'implémentation, pas le comportement.

Voir tests.md pour des exemples et mocking.md pour les directives sur la simulation (mocking).

Anti-Pattern : Tranches horizontales

N'écrivez PAS tous les tests d'abord, puis toute l'implémentation. C'est ce qu'on appelle une « tranche horizontale » – traiter ROUGE comme « écrire tous les tests » et VERT comme « écrire tout le code. »

Cela produit des tests médiocres :

  • Les tests écrits en masse testent un comportement imaginé, pas un comportement réel
  • Vous finissez par tester la forme des choses (structures de données, signatures de fonctions) plutôt que le comportement orienté utilisateur
  • Les tests deviennent insensibles aux changements réels – ils passent quand le comportement échoue, échouent quand le comportement est correct
  • Vous dépassez vos phares, vous engageant dans une structure de test avant de comprendre l'implémentation

Approche correcte : Tranches verticales via des balles traçantes (tracer bullets). Un test → une implémentation → répéter. Chaque test répond à ce que vous avez appris du cycle précédent. Parce que vous venez d'écrire le code, vous savez exactement quel comportement compte et comment le vérifier.

FAUX (horizontal) :
  ROUGE : test1, test2, test3, test4, test5
  VERT  : impl1, impl2, impl3, impl4, impl5

JUSTE (vertical) :
  ROUGE→VERT : test1→impl1
  ROUGE→VERT : test2→impl2
  ROUGE→VERT : test3→impl3
  ...

Workflow

1. Planification

Lors de l'exploration de la base de code, lisez CONTEXT.md (s'il existe) afin que les noms de test et le vocabulaire de l'interface correspondent au langage du domaine du projet, et respectez les ADR dans la zone que vous touchez.

Avant d'écrire du code :

  • Confirmer avec l'utilisateur les modifications d'interface nécessaires
  • Confirmer avec l'utilisateur les comportements à tester (prioriser)
  • Identifier les opportunités pour des modules profonds en utilisant les principes de conception de base de code lorsque les limites d'interface sont floues. N'invoquez pas une autre compétence automatiquement sauf demande explicite de l'utilisateur.
  • Lister les comportements à tester (pas les étapes d'implémentation)
  • Obtenir l'approbation de l'utilisateur sur le plan

Demandez : « À quoi devrait ressembler l'interface publique ? Quels comportements sont les plus importants à tester ? »

Vous ne pouvez pas tout tester. Confirmez avec l'utilisateur exactement quels comportements comptent le plus. Concentrez l'effort de test sur les chemins critiques et la logique complexe, pas sur tous les cas limites possibles.

2. Balle traçante

Écrivez UN test qui confirme UNE chose sur le système :

ROUGE : Écrire le test pour le premier comportement → le test échoue
VERT   : Écrire le code minimal pour passer → le test réussit

C'est votre balle traçante – prouve que le chemin fonctionne de bout en bout.

3. Boucle incrémentale

Pour chaque comportement restant :

ROUGE : Écrire le test suivant → échoue
VERT   : Code minimal pour réussir → réussit

Règles :

  • Un test à la fois
  • Uniquement assez de code pour passer le test actuel
  • Ne pas anticiper les tests futurs
  • Garder les tests concentrés sur le comportement observable

4. Refactorisation

Une fois tous les tests réussis, recherchez candidats à la refactorisation :

  • Extraire les duplications
  • Approfondir les modules (déplacer la complexité derrière des interfaces simples)
  • Appliquer les principes SOLID là où c'est naturel
  • Considérer ce que le nouveau code révèle sur le code existant
  • Exécuter les tests après chaque étape de refactorisation

Ne refactorisez jamais quand vous êtes en ROUGE. Passez d'abord en VERT.

Liste de contrôle par cycle

[ ] Le test décrit le comportement, pas l'implémentation
[ ] Le test utilise uniquement l'interface publique
[ ] Le test survivrait à une refactorisation interne
[ ] Le code est minimal pour ce test
[ ] Aucune fonctionnalité spéculative ajoutée

Skills associés