Communitygithub.com

Générateur de tâches exploitables

Génère un fichier tasks.md exploitable, organisé par dépendances, pour la fonctionnalité, à partir des artefacts de conception disponibles.

Qu'est-ce que Générateur de tâches exploitables ?

Cette compétence (skill) génère un fichier `tasks.md` structuré et actionnable pour une fonctionnalité spécifique, en s'appuyant sur les documents de conception existants (plan.md, spec.md, data-model.md, contracts/, etc.) dans un répertoire de fonctionnalité (`FEATURE_DIR`). Elle est typiquement utilisée par des agents comme Claude Code, Cursor ou Codex dans le cadre d'un workflow de développement piloté par la spécification (Specify). L'agent orchestre la génération de tâches en plusieurs phases : configuration, fondations, implémentation par user story (par ordre de priorité P1, P2, P3...), et enfin polissage. Chaque tâche suit un format strict de checklist Markdown avec ID, labels et chemins de fichiers, ce qui la rend immédiatement exécutable par un LLM sans contexte supplémentaire. La compétence inclut également la gestion des hooks d'extension (avant et après génération) définis dans `.specify/extensions.yml`, permettant d'exécuter des scripts personnalisés (optionnels ou obligatoires) et de les intégrer au flux de travail. Elle valide enfin l'exhaustivité des tâches et produit un rapport de complétion avec le nombre total de tâches, la répartition par user story et le scope MVP suggéré.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/tangjuyo/reels-blocker/tree/HEAD/.claude/skills/speckit-tasks

Demander à votre IA préférée

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

Documentation

Entrée utilisateur

$ARGUMENTS

Vous DEVEZ prendre en compte l'entrée utilisateur avant de continuer (si elle n'est pas vide).

Vérifications pré-exécution

Vérifiez la présence de hooks d'extension (avant la génération des tâches) :

  • Vérifiez si le fichier .specify/extensions.yml existe à la racine du projet.
  • S'il existe, lisez-le et cherchez les entrées sous la clé hooks.before_tasks
  • Si le YAML ne peut pas être parsé ou est invalide, ne passez pas en silence : dites à l'utilisateur que .specify/extensions.yml n'a pas pu être lu (incluez l'erreur de parser) et qu'aucun hook n'a été vérifié, y compris les hooks obligatoires (optional: false) qui y sont enregistrés, puis continuez normalement
  • Filtrez les hooks où enabled est explicitement false. Traitez les hooks sans champ enabled comme activés par défaut.
  • Pour chaque hook restant, n'essayez pas d'interpréter ou d'évaluer les expressions de condition du hook :
    • Si le hook n'a pas de champ condition, ou s'il est nul/vide, traitez le hook comme exécutable
    • Si le hook définit une condition non vide, ignorez le hook et laissez l'évaluation de la condition à l'implémentation de HookExecutor
  • Lors de la construction des invocations de commande à partir des noms de commande du hook, remplacez les points (.) par des traits d'union (-). Par exemple, speckit.git.commit → /speckit-git-commit.
  • Pour chaque hook exécutable, produisez la sortie suivante en fonction de son indicateur optional :
    • Hook optionnel (optional: true) :
      ## Hooks d'extension
      
      **Pré-hook optionnel** : {extension}
      Commande : `/{command}`
      Description : {description}
      
      Invite : {prompt}
      Pour exécuter : `/{command}`
      
    • Hook obligatoire (optional: false) :
      ## Hooks d'extension
      
      **Pré-hook automatique** : {extension}
      Exécution : `/{command}`
      EXECUTE_COMMAND : {command}
      
      Attendez le résultat de la commande du hook avant de passer au Plan.
      
      Après avoir émis le bloc ci-dessus, vous DEVEZ réellement invoquer le hook et attendre qu'il se termine avant de continuer. Exécutez-le de la même manière que vous exécuteriez la commande vous-même dans cet agent/session (l'invocation peut différer du littéral {command} montré ci-dessus, par exemple un agent en mode compétences l'exécute comme /skill:speckit-... ou $speckit-...). Émettre le bloc seul n'exécute pas le hook.
  • Si aucun hook n'est enregistré ou si .specify/extensions.yml n'existe pas, passez en silence

Plan

  1. Configuration : Exécutez .specify/scripts/bash/setup-tasks.sh --json depuis la racine du dépôt et analysez FEATURE_DIR, TASKS_TEMPLATE_CONTENT, TASKS_TEMPLATE et AVAILABLE_DOCS. FEATURE_DIR et TASKS_TEMPLATE doivent être des chemins absolus lorsqu'ils sont fournis. AVAILABLE_DOCS est une liste de noms de documents/chemins relatifs disponibles sous FEATURE_DIR (par exemple research.md ou contracts/). Pour les guillemets simples dans les arguments comme "Je suis Groot", utilisez la syntaxe d'échappement : par exemple 'Je''' suis Groot' (ou des guillemets doubles si possible : "Je suis Groot").

  2. Charger les documents de conception : Lisez depuis FEATURE_DIR :

    • Obligatoire : plan.md (pile technologique, bibliothèques, structure), spec.md (user stories avec priorités)
    • Optionnel : data-model.md (entités), contracts/ (contrats d'interface), research.md (décisions), quickstart.md (scénarios de test)
    • SI EXISTE : Chargez .specify/memory/constitution.md pour les principes du projet et les contraintes de gouvernance
    • Remarque : Tous les projets n'ont pas tous les documents. Générez les tâches en fonction de ce qui est disponible.
  3. Exécuter le flux de travail de génération de tâches :

    • Chargez plan.md et extrayez la pile technologique, les bibliothèques, la structure du projet
    • Chargez spec.md et extrayez les user stories avec leurs priorités (P1, P2, P3, etc.)
    • Si data-model.md existe : Extrayez les entités et mappez-les aux user stories
    • Si contracts/ existe : Mappez les contrats d'interface aux user stories
    • Si research.md existe : Extrayez les décisions pour les tâches de configuration
    • Générez les tâches organisées par user story (voir Règles de génération de tâches ci-dessous)
    • Générez un graphe de dépendances montrant l'ordre d'achèvement des user stories
    • Créez des exemples d'exécution parallèle par user story
    • Validez l'exhaustivité des tâches (chaque user story a toutes les tâches nécessaires, testable indépendamment)
  4. Générer tasks.md : Utilisez TASKS_TEMPLATE_CONTENT (de la sortie JSON ci-dessus) comme structure. Pour la compatibilité avec les anciens scripts de configuration qui omettent TASKS_TEMPLATE_CONTENT, lisez TASKS_TEMPLATE à la place. Remplissez avec :

    • Le nom correct de la fonctionnalité depuis plan.md
    • Phase 1 : Tâches de configuration (initialisation du projet)
    • Phase 2 : Tâches fondamentales (prérequis bloquants pour toutes les user stories)
    • Phase 3+ : Une phase par user story (dans l'ordre de priorité de spec.md)
    • Chaque phase comprend : objectif de la story, critères de test indépendants, tests (si demandés), tâches d'implémentation
    • Phase finale : Polissage et préoccupations transversales
    • Toutes les tâches doivent suivre le format strict de checklist (voir Règles de génération de tâches ci-dessous)
    • Chemins de fichiers clairs pour chaque tâche
    • Section des dépendances montrant l'ordre d'achèvement des stories
    • Exemples d'exécution parallèle par story
    • Section de stratégie d'implémentation (MVP d'abord, livraison incrémentale)

Hooks obligatoires post-exécution

Vous DEVEZ terminer cette section avant de signaler la complétion à l'utilisateur.

Vérifiez si .specify/extensions.yml existe à la racine du projet.

  • S'il n'existe pas, ou si aucun hook n'est enregistré sous la clé hooks.after_tasks, passez au Rapport de complétion.
  • S'il existe, lisez-le et cherchez les entrées sous la clé hooks.after_tasks.
  • Si le YAML ne peut pas être parsé ou est invalide, ne passez pas en silence : dites à l'utilisateur que .specify/extensions.yml n'a pas pu être lu (incluez l'erreur de parser) et qu'aucun hook n'a été vérifié, y compris les hooks obligatoires (optional: false) qui y sont enregistrés, puis continuez vers le Rapport de complétion.
  • Filtrez les hooks où enabled est explicitement false. Traitez les hooks sans champ enabled comme activés par défaut.
  • Pour chaque hook restant, n'essayez pas d'interpréter ou d'évaluer les expressions de condition du hook :
    • Si le hook n'a pas de champ condition, ou s'il est nul/vide, traitez le hook comme exécutable
    • Si le hook définit une condition non vide, ignorez le hook et laissez l'évaluation de la condition à l'implémentation de HookExecutor
  • Lors de la construction des invocations de commande à partir des noms de commande du hook, remplacez les points (.) par des traits d'union (-). Par exemple, speckit.git.commit → /speckit-git-commit.
  • Pour chaque hook exécutable, produisez la sortie suivante en fonction de son indicateur optional :
    • Hook obligatoire (optional: false) — Vous DEVEZ émettre EXECUTE_COMMAND: pour chaque hook obligatoire :
      ## Hooks d'extension
      
      **Hook automatique** : {extension}
      Exécution : `/{command}`
      EXECUTE_COMMAND : {command}
      
      Après avoir émis le bloc ci-dessus, vous DEVEZ réellement invoquer le hook et attendre qu'il se termine avant de continuer. Exécutez-le de la même manière que vous exécuteriez la commande vous-même dans cet agent/session (l'invocation peut différer du littéral {command} montré ci-dessus, par exemple un agent en mode compétences l'exécute comme /skill:speckit-... ou $speckit-...). Émettre le bloc seul n'exécute pas le hook.
    • Hook optionnel (optional: true) :
      ## Hooks d'extension
      
      **Hook optionnel** : {extension}
      Commande : `/{command}`
      Description : {description}
      
      Invite : {prompt}
      Pour exécuter : `/{command}`
      

Rapport de complétion

Affichez le chemin vers tasks.md généré et un résumé :

  • Nombre total de tâches
  • Nombre de tâches par user story
  • Opportunités de parallélisation identifiées
  • Critères de test indépendants pour chaque story
  • Portée MVP suggérée (généralement juste la User Story 1)
  • Validation du format : Confirmez que TOUTES les tâches suivent le format de checklist (case à cocher, ID, labels, chemins de fichiers)

Contexte pour la génération de tâches : $ARGUMENTS

Le tasks.md doit être immédiatement exécutable - chaque tâche doit être suffisamment spécifique pour qu'un LLM puisse la réaliser sans contexte supplémentaire.

Règles de génération de tâches

CRITIQUE : Les tâches DOIVENT être organisées par user story pour permettre une implémentation et un test indépendants.

Les tests sont OPTIONNELS : Ne générez des tâches de test que si cela est explicitement demandé dans la spécification de la fonctionnalité ou si l'utilisateur demande une approche TDD.

Format de checklist (OBLIGATOIRE)

Chaque tâche DOIT strictement suivre ce format :

- [ ] [TaskID] [P?] [Story?] Description avec chemin de fichier

Composants du format :

  1. Case à cocher : Commencez TOUJOURS par - [ ] (case à cocher Markdown)
  2. ID de tâche : Numéro séquentiel (T001, T002, T003...) dans l'ordre d'exécution
  3. Marqueur [P] : Incluez UNIQUEMENT si la tâche est parallélisable (fichiers différents, aucune dépendance sur des tâches incomplètes)
  4. Étiquette [Story] : OBLIGATOIRE pour les tâches de phase user story uniquement
    • Format : [US1], [US2], [US3], etc. (correspond aux user stories de spec.md)
    • Phase de configuration : PAS d'étiquette de story
    • Phase fondamentale : PAS d'étiquette de story
    • Phases User Story : DOIVENT avoir une étiquette de story
    • Phase de polissage : PAS d'étiquette de story
  5. Description : Action claire avec le chemin de fichier exact

Exemples :

  • ✅ CORRECT : - [ ] T001 Créer la structure du projet selon le plan d'implémentation
  • ✅ CORRECT : - [ ] T005 [P] Implémenter le middleware d'authentification dans src/middleware/auth.py
  • ✅ CORRECT : - [ ] T012 [P] [US1] Créer le modèle User dans src/models/user.py
  • ✅ CORRECT : - [ ] T014 [US1] Implémenter UserService dans src/services/user_service.py
  • ❌ ERRONÉ : - [ ] Créer le modèle User (ID et étiquette de story manquants)
  • ❌ ERRONÉ : T001 [US1] Créer le modèle (case à cocher manquante)
  • ❌ ERRONÉ : - [ ] [US1] Créer le modèle User (ID de tâche manquant)
  • ❌ ERRONÉ : - [ ] T001 [US1] Créer le modèle (chemin de fichier manquant)

Organisation des tâches

  1. À partir des User Stories (spec.md) - ORGANISATION PRINCIPALE :

    • Chaque user story (P1, P2, P3...) obtient sa propre phase
    • Mappez tous les composants associés à leur story :
      • Modèles nécessaires pour cette story
      • Services nécessaires pour cette story
      • Interfaces/UI nécessaires pour cette story
      • Si des tests sont demandés : Tests spécifiques à cette story
    • Marquez les dépendances des stories (la plupart des stories doivent être indépendantes)
  2. À partir des Contrats :

    • Mappez chaque contrat d'interface → à la user story qu'il sert
    • Si des tests sont demandés : Chaque contrat d'interface → tâche de test de contrat [P] avant l'implémentation dans la phase de cette story
  3. À partir du Modèle de Données :

    • Mappez chaque entité à la (aux) user story(s) qui en a besoin
    • Si l'entité sert plusieurs stories : Mettez-la dans la story la plus ancienne ou dans la phase de configuration
    • Relations → tâches de la couche service dans la phase de story appropriée
    • Pour chaque champ avec des contraintes dans data-model.md (longueur max, nullable/obligatoire, valeurs enum, règles de validation), citez la contrainte textuellement dans la description de la tâche afin qu'elle ne soit pas laissée à la discrétion du moment de l'implémentation
  4. À partir de la Configuration/Infrastructure :

    • Infrastructure partagée → Phase de configuration (Phase 1)
    • Tâches fondamentales/bloquantes → Phase fondamentale (Phase 2)
    • Configuration spécifique à une story → dans la phase de cette story

Structure des phases

  • Phase 1 : Configuration (initialisation du projet)
  • Phase 2 : Fondamentale (prérequis bloquants - DOIT être terminée avant les user stories)
  • Phase 3+ : User Stories dans l'ordre de priorité (P1, P2, P3...)
    • Au sein de chaque story : Tests (si demandés) → Modèles → Services → Points d'accès → Intégration
    • Chaque phase doit être un incrément complet et testable indépendamment
  • Phase finale : Polissage et préoccupations transversales

Terminé quand

  • tasks.md généré avec toutes les phases, les IDs de tâches et les chemins de fichiers
  • Les hooks d'extension ont été exécutés ou ignorés conformément aux règles des Hooks obligatoires post-exécution ci-dessus
  • La complétion a été signalée à l'utilisateur avec le nombre de tâches, la répartition par story et le scope MVP

Individual skills in this repo

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

Skills associés