CommunityRédaction et éditiongithub.com

K3639284/skills

Créez des compétences d'agent IA modulaires et composables pour des tâches d'ingénierie de production.

Qu'est-ce que skills ?

Cette compétence, appelée « QA Session », permet de mener une session de questions-réponses interactive avec un utilisateur. L'utilisateur décrit les problèmes qu'il rencontre, vous les clarifiez, explorez la base de code pour obtenir du contexte, puis créez des issues GitHub durables, centrées sur l'utilisateur et utilisant le langage du domaine du projet. Elle est utile car elle structure le signalement de bugs de manière professionnelle, évite les détails d'implémentation éphémères et produit des issues exploitables par d'autres développeurs ou agents. La compétence fonctionne sur n'importe quel projet GitHub et s'appuie sur l'outil en ligne de commande `gh` pour créer les issues. Le processus comprend cinq étapes : écouter et clarifier légèrement, explorer la base de code en arrière-plan avec un sous-agent, évaluer si l'issue est unique ou doit être décomposée, créer les issues GitHub avec des modèles spécifiques sans chemins de fichiers ni numéros de ligne, et continuer la session jusqu'à ce que l'utilisateur soit satisfait.

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

Installed? Explore more Rédaction et édition skills: steipete/notion, langchain-ai/langchain, bytedance/podcast-generation · 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

Session de Questions-Réponses (QA)

Menez une session de questions-réponses interactive. L'utilisateur décrit les problèmes qu'il rencontre. Vous clarifiez, explorez la base de code pour obtenir du contexte, et créez des issues GitHub durables, centrées sur l'utilisateur et utilisant le langage du domaine du projet.

Pour chaque issue soulevée par l'utilisateur

1. Écouter et clarifier légèrement

Laissez l'utilisateur décrire le problème avec ses propres mots. Posez au maximum 2 à 3 courtes questions de clarification centrées sur :

  • Ce qu'il attendait par rapport à ce qui s'est réellement passé
  • Les étapes pour reproduire (si ce n'est pas évident)
  • Si le problème est constant ou intermittent

N'essayez pas de tout interviewer. Si la description est suffisamment claire pour créer une issue, passez à la suite.

2. Explorer la base de code en arrière-plan

Pendant que vous parlez à l'utilisateur, lancez un Agent (subagent_type=Explore) en arrière-plan pour comprendre la zone concernée. Le but n'est PAS de trouver une solution — c'est de :

  • Apprendre le langage du domaine utilisé dans cette zone (vérifiez le fichier UBIQUITOUS_LANGUAGE.md)
  • Comprendre ce que la fonctionnalité est censée faire
  • Identifier la frontière du comportement utilisateur

Ce contexte vous aide à rédiger une meilleure issue — mais l'issue elle-même ne doit PAS référencer des fichiers, des numéros de ligne ou des détails d'implémentation internes.

3. Évaluer la portée : issue unique ou décomposition ?

Avant de créer, décidez s'il s'agit d'une issue unique ou si elle doit être décomposée en plusieurs issues.

Décomposez quand :

  • Le correctif couvre plusieurs zones indépendantes (par exemple « la validation du formulaire est erronée ET le message de succès manque ET la redirection est cassée »)
  • Il existe des préoccupations clairement séparables que différentes personnes pourraient traiter en parallèle
  • L'utilisateur décrit quelque chose qui présente plusieurs modes de défaillance ou symptômes distincts

Gardez comme une seule issue quand :

  • Il s'agit d'un seul comportement erroné à un seul endroit
  • Les symptômes sont tous causés par le même comportement racine

4. Créer la ou les issues GitHub

Créez les issues avec gh issue create. Ne demandez PAS à l'utilisateur de relire d'abord — créez et partagez les URL.

Les issues doivent être durables — elles doivent avoir un sens même après des refontes majeures. Rédigez du point de vue de l'utilisateur.

Pour une issue unique

Utilisez ce modèle :

## Ce qui s'est passé

[Décrivez le comportement réel que l'utilisateur a rencontré, en langage simple]

## Ce que j'attendais

[Décrivez le comportement attendu]

## Étapes pour reproduire

1. [Étapes concrètes et numérotées qu'un développeur peut suivre]
2. [Utilisez les termes du domaine de la base de code, pas les noms de modules internes]
3. [Incluez les entrées, indicateurs ou configurations pertinents]

## Contexte supplémentaire

[Toutes les observations supplémentaires de l'utilisateur ou de l'exploration de la base de code qui aident à cadrer l'issue — par exemple « cela ne se produit qu'avec la couche Docker, pas avec la couche système de fichiers » — utilisez le langage du domaine mais ne citez pas de fichiers]

Pour une décomposition (plusieurs issues)

Créez les issues dans un ordre de dépendance (les bloqueurs d'abord) afin de pouvoir référencer de vrais numéros d'issue.

Utilisez ce modèle pour chaque sous-issue :

## Issue parente

#<numéro-de-l-issue-parente> (si vous avez créé une issue de suivi) ou « Signalé lors d'une session QA »

## Ce qui ne va pas

[Décrivez ce problème de comportement spécifique — juste cette partie, pas tout le rapport]

## Ce que j'attendais

[Comportement attendu pour cette partie spécifique]

## Étapes pour reproduire

1. [Étapes spécifiques à CETTE issue]

## Bloqué par

- #<numéro-d-issue> (si cette issue ne peut pas être corrigée tant qu'une autre n'est pas résolue)

Ou « Aucun — peut commencer immédiatement » s'il n'y a pas de bloqueur.

## Contexte supplémentaire

[Toutes les observations supplémentaires pertinentes pour cette partie]

Lors de la création d'une décomposition :

  • Préférez plusieurs issues fines à quelques issues épaisses — chacune doit pouvoir être corrigée et vérifiée indépendamment
  • Indiquez honnêtement les relations de blocage — si l'issue B ne peut vraiment pas être testée tant que l'issue A n'est pas corrigée, dites-le. Si elles sont indépendantes, marquez les deux comme « Aucun — peut commencer immédiatement »
  • Créez les issues dans l'ordre des dépendances afin de pouvoir référencer de vrais numéros d'issue dans « Bloqué par »
  • Maximisez le parallélisme — l'objectif est que plusieurs personnes (ou agents) puissent prendre différentes issues simultanément

Règles pour tous les corps d'issue

  • Pas de chemins de fichiers ni de numéros de ligne — ceux-ci deviennent obsolètes
  • Utilisez le langage du domaine du projet (vérifiez le fichier UBIQUITOUS_LANGUAGE.md s'il existe)
  • Décrivez les comportements, pas le code — « le service de synchronisation échoue à appliquer le correctif » pas « applyPatch() lève une exception à la ligne 42 »
  • Les étapes de reproduction sont obligatoires — si vous ne pouvez pas les déterminer, demandez à l'utilisateur
  • Soyez concis — un développeur doit pouvoir lire l'issue en 30 secondes

Après avoir créé, affichez toutes les URL des issues (avec un résumé des relations de blocage) et demandez : « Prochaine issue, ou avons-nous terminé ? »

5. Continuer la session

Continuez jusqu'à ce que l'utilisateur dise qu'il a terminé. Chaque issue est indépendante — ne les regroupez pas.

Skills associés