Communitygithub.com

Lev-it/lev-skills

Développement piloté par les tests. À utiliser lorsque l'utilisateur souhaite construire des fonctionnalités ou corriger des bugs en commençant par les tests, mentionne « red-green-refactor » ou souhaite des tests d'intégration.

Qu'est-ce que lev-skills ?

Cette compétence incarne les principes du développement piloté par les tests (TDD) avec une emphase sur les tests orientés comportement. Elle guide l'utilisateur pour écrire des tests qui valident le comportement via des interfaces publiques, garantissant ainsi que les tests restent robustes face aux refactorisations internes. L'approche privilégie des « slices verticaux » plutôt qu'horizontaux : chaque cycle RED → GREEN produit une petite fonctionnalité testée de bout en bout, évitant de tester des structures imaginaires. Le flux de travail inclut une phase de planification avec validation utilisateur, un tir tracer bullet pour valider le chemin, une boucle incrémentale, et une étape de refactorisation une fois tous les tests au vert. Cette compétence est conçue pour des agents comme Claude Code, Cursor ou Codex, et s'appuie sur des fichiers annexes (tests.md, mocking.md, refactoring.md) pour des exemples concrets. Son utilité principale est d'éviter les tests fragiles et de produire du code qui répond précisément aux comportements attendus.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Lev-it/lev-skills/tree/HEAD/.claude/skills/tdd

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

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 type 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 finaliser 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 moquent des collaborateurs internes, testent des méthodes privées, ou vérifient via des moyens externes (comme interroger directement une base de données au lieu d'utiliser l'interface). Le signe d'alerte : votre test échoue lorsque vous refactorisez, mais 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 de moquage.

Anti-patron : Tranches horizontales

NE PAS écrire tous les tests d'abord, puis toute l'implémentation. C'est ce qu'on appelle des « tranches horizontales » — traiter ROUGE comme « écrire tous les tests » et VERT comme « écrire tout le code ».

Cela produit des tests de merde :

  • 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 visible par l'utilisateur
  • Les tests deviennent insensibles aux changements réels — ils passent quand le comportement casse, échouent quand le comportement est bon
  • 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. 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.

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

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

Flux de travail

1. Planification

En explorant la base de code, lisez CONTEXT.md (s'il existe) pour que les noms de tests 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 quels changements d'interface sont nécessaires
  • Confirmer avec l'utilisateur quels comportements tester (prioriser)
  • Identifier les opportunités de modules profonds (petite interface, implémentation profonde) — exécuter la compétence /codebase-design pour le vocabulaire et les vérifications de testabilité
  • 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 sont les comportements 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 passe

C'est votre balle traçante — elle 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 passer → passe

Règles :

  • Un test à la fois
  • Seulement assez de code pour passer le test actuel
  • N'anticipez pas les tests futurs
  • Gardez les tests concentrés sur le comportement observable

4. Refactorisation

Une fois tous les tests au vert, cherchez des candidats à la refactorisation :

  • Extraire la duplication
  • 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 c'est ROUGE. Atteignez d'abord le VERT.

Liste de vérification 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

Individual skills in this repo

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

Lev-it/lev-skills

Ask which skill or flow fits your situation. A router over the user-invoked skills in this repo.

Lev-it/lev-skills

Premium brand-kit image generation skill for creating high-end brand-guidelines boards, logo systems, identity decks, and visual-world presentations. Trained for minimalist, cinematic, editorial, dark-tech, luxury, cultural, security, gaming, developer-tool, and consumer-app brand systems. Optimized for intentional logo concepting, refined composition, sparse typography, strong symbolic meaning, premium mockups, art-directed imagery, and flexible grid layouts.

Lev-it/lev-skills

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

Lev-it/lev-skills

Ink terminal renderer for json-render that turns JSON specs into interactive terminal UIs. Use when working with @json-render/ink, building terminal UIs from JSON, creating terminal component catalogs, or rendering AI-generated specs in the terminal.

Lev-it/lev-skills

Interactive QA session where user reports bugs or issues conversationally, and the agent files GitHub issues. Explores the codebase in the background for context and domain language. Use when user wants to report bugs, do QA, file issues conversationally, or mentions "QA session".

Lev-it/lev-skills

Facilitate a structured sprint retrospective — what went well, what didn't, and prioritized action items with owners and deadlines. Use when running a retrospective, reflecting on a sprint, creating action items from team feedback, or learning how to run effective retros.

Lev-it/lev-skills

Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes — Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match what the originating issue/PRD asked for?). Runs both reviews in parallel sub-agents and reports them side by side. Use when the user wants to review a branch, a PR, work-in-progress changes, or asks to "review since X".

Lev-it/lev-skills

Teach the user a new skill or concept, within this workspace.

Lev-it/lev-skills

Turn the current conversation into a PRD and publish it to the project issue tracker — no interview, just synthesis of what you've already discussed.

Lev-it/lev-skills

Move issues through a state machine of triage roles — categorise, reproduce, grill if needed, and write agent-ready briefs.

Lev-it/lev-skills

Create product backlog items in Why-What-Acceptance format — independent, valuable, testable items with strategic context. Use when writing structured backlog items, breaking features into work items, or using the WWA format.

Skills associés