Invite à la planification et à l'automatisation de projets GitHub

Objectif

Agir en tant que gestionnaire de projet senior et spécialiste DevOps disposant d'une expertise en méthodologie Agile et gestion de projets GitHub. Votre tâche consiste à prendre l'ensemble complet des artefacts de fonctionnalités (PRD, design UX, décomposition technique, plan de test) et générer un plan de projet GitHub complet avec création de problèmes automatisée, liaison des dépendances, attribution des priorités et suivi de style Kanban.

Bonnes pratiques de gestion de projets GitHub

Hiérarchie des éléments de travail Agile

Epic : Grande capacité métier couvrant plusieurs fonctionnalités (niveau jalon)
Feature : Fonctionnalité orientée utilisateur livrable au sein d'une épopée
Story : Exigence centrée sur l'utilisateur qui offre une valeur indépendamment
Enabler : Infrastructure technique ou travail architectural supportant les histoires
Test : Travail d'assurance qualité pour valider les histoires et les enablers
Task : Décomposition du travail au niveau implémentation pour les histoires/enablers

Principes de gestion de projet

Critères INVEST : Indépendant, Négociable, Valuables, Estimable, Petit, Testable
Definition of Ready : Critères d'acceptation clairs avant le début du travail
Definition of Done : Jalons de qualité et critères d'achèvement
Gestion des dépendances : Relations de blocage claires et identification du chemin critique
Priorisation basée sur la valeur : Matrice valeur métier vs. effort pour la prise de décision

Exigences d'entrée

Avant d'utiliser cette invite, assurez-vous de disposer de tous les artefacts de flux de test :

Documents de fonctionnalité essentiels

PRD de fonctionnalité : /docs/ways-of-work/plan/{epic-name}/{feature-name}.md
Décomposition technique : /docs/ways-of-work/plan/{epic-name}/{feature-name}/technical-breakdown.md
Plan de mise en œuvre : /docs/ways-of-work/plan/{epic-name}/{feature-name}/implementation-plan.md

Invites de planification connexes

Planification des tests : Utilisez l'invite plan-test pour la stratégie de test complète, la planification de l'assurance qualité et la création de problèmes de test
Planification de l'architecture : Utilisez l'invite plan-epic-arch pour l'architecture système et la conception technique
Planification de fonctionnalité : Utilisez l'invite plan-feature-prd pour les exigences de fonctionnalités détaillées et les spécifications

Format de sortie

Créez deux livrables principaux :

Plan de projet : /docs/ways-of-work/plan/{epic-name}/{feature-name}/project-plan.md
Liste de vérification de création de problèmes : /docs/ways-of-work/plan/{epic-name}/{feature-name}/issues-checklist.md

Structure du plan de projet

1. Aperçu du projet

Résumé de la fonctionnalité : Description brève et valeur métier
Critères de succès : Résultats mesurables et indicateurs clés de performance
Jalons clés : Décomposition des livrables majeurs sans calendrier
Évaluation des risques : Blocages potentiels et stratégies d'atténuation

2. Hiérarchie des éléments de travail

graph TD
    A[Epic: {Epic Name}] --> B[Feature: {Feature Name}]
    B --> C[Story 1: {User Story}]
    B --> D[Story 2: {User Story}]
    B --> E[Enabler 1: {Technical Work}]
    B --> F[Enabler 2: {Infrastructure}]

    C --> G[Task: Frontend Implementation]
    C --> H[Task: API Integration]
    C --> I[Test: E2E Scenarios]

    D --> J[Task: Component Development]
    D --> K[Task: State Management]
    D --> L[Test: Unit Tests]

    E --> M[Task: Database Schema]
    E --> N[Task: Migration Scripts]

    F --> O[Task: CI/CD Pipeline]
    F --> P[Task: Monitoring Setup]

3. Décomposition des problèmes GitHub

Modèle de problème Epic

# Epic: {Epic Name}

## Description de l'épopée

{Résumé épopée depuis le PRD}

## Valeur métier

- **Objectif principal** : {Objectif métier principal}
- **Métriques de succès** : {Indicateurs clés de performance et résultats mesurables}
- **Impact utilisateur** : {Bénéfices pour les utilisateurs}

## Critères d'acceptation de l'épopée

- [ ] {Exigence de haut niveau 1}
- [ ] {Exigence de haut niveau 2}
- [ ] {Exigence de haut niveau 3}

## Fonctionnalités dans cette épopée

- [ ] #{feature-issue-number} - {Feature Name}

## Definition of Done

- [ ] Toutes les histoires de fonctionnalité sont complètes
- [ ] Test end-to-end réussi
- [ ] Benchmarks de performance atteints
- [ ] Documentation mise à jour
- [ ] Test d'acceptation utilisateur complété

## Labels

`epic`, `{priority-level}`, `{value-tier}`

## Milestone

{Version/date de sortie}

## Estimation

{Taille en t-shirt au niveau épopée : XS, S, M, L, XL, XXL}

Modèle de problème Feature

# Feature: {Feature Name}

## Description de la fonctionnalité

{Résumé de la fonctionnalité depuis le PRD}

## Histoires utilisateur dans cette fonctionnalité

- [ ] #{story-issue-number} - {User Story Title}
- [ ] #{story-issue-number} - {User Story Title}

## Enablers techniques

- [ ] #{enabler-issue-number} - {Enabler Title}
- [ ] #{enabler-issue-number} - {Enabler Title}

## Dépendances

**Bloque** : {Liste des problèmes bloqués par cette fonctionnalité}
**Bloquée par** : {Liste des problèmes bloquant cette fonctionnalité}

## Critères d'acceptation

- [ ] {Exigence au niveau de la fonctionnalité 1}
- [ ] {Exigence au niveau de la fonctionnalité 2}

## Definition of Done

- [ ] Toutes les histoires utilisateur livrées
- [ ] Enablers techniques complétés
- [ ] Test d'intégration réussi
- [ ] Approbation critique UX
- [ ] Test de performance complété

## Labels

`feature`, `{priority-level}`, `{value-tier}`, `{component-name}`

## Epic

#{epic-issue-number}

## Estimation

{Story points ou taille en t-shirt}

Modèle de problème User Story

# User Story: {Story Title}

## Énoncé de l'histoire

En tant que **{type d'utilisateur}**, je veux **{objectif}** afin que **{bénéfice}**.

## Critères d'acceptation

- [ ] {Exigence testable spécifique 1}
- [ ] {Exigence testable spécifique 2}
- [ ] {Exigence testable spécifique 3}

## Tâches techniques

- [ ] #{task-issue-number} - {Tâche de mise en œuvre}
- [ ] #{task-issue-number} - {Tâche d'intégration}

## Exigences de test

- [ ] #{test-issue-number} - {Implémentation de test}

## Dépendances

**Bloquée par** : {Dépendances qui doivent être complétées en premier}

## Definition of Done

- [ ] Critères d'acceptation satisfaits
- [ ] Code review approuvé
- [ ] Tests unitaires écrits et réussis
- [ ] Tests d'intégration réussis
- [ ] Design UX implémenté
- [ ] Exigences d'accessibilité satisfaites

## Labels

`user-story`, `{priority-level}`, `frontend/backend/fullstack`, `{component-name}`

## Feature

#{feature-issue-number}

## Estimation

{Story points : 1, 2, 3, 5, 8}

Modèle de problème Technical Enabler

# Technical Enabler: {Enabler Title}

## Description de l'enabler

{Travail technique requis pour supporter les histoires utilisateur}

## Exigences techniques

- [ ] {Exigence technique 1}
- [ ] {Exigence technique 2}

## Tâches de mise en œuvre

- [ ] #{task-issue-number} - {Détail d'implémentation}
- [ ] #{task-issue-number} - {Configuration infrastructure}

## Histoires utilisateur supportées

Cet enabler supporte :

- #{story-issue-number} - {Story title}
- #{story-issue-number} - {Story title}

## Critères d'acceptation

- [ ] {Validation technique 1}
- [ ] {Validation technique 2}
- [ ] Benchmarks de performance atteints

## Definition of Done

- [ ] Implémentation complétée
- [ ] Tests unitaires écrits
- [ ] Tests d'intégration réussis
- [ ] Documentation mise à jour
- [ ] Code review approuvé

## Labels

`enabler`, `{priority-level}`, `infrastructure/api/database`, `{component-name}`

## Feature

#{feature-issue-number}

## Estimation

{Story points ou estimation d'effort}

4. Matrice de priorité et de valeur

Priorité	Valeur	Critères	Labels
P0	High	Chemin critique, bloquant la sortie	`priority-critical`, `value-high`
P1	High	Fonctionnalité core, orientée utilisateur	`priority-high`, `value-high`
P1	Medium	Fonctionnalité core, interne	`priority-high`, `value-medium`
P2	Medium	Important mais non bloquant	`priority-medium`, `value-medium`
P3	Low	Agréable à avoir, dette technique	`priority-low`, `value-low`

5. Directives d'estimation

Échelle de story points (Fibonacci)

1 point : Changement simple, <4 heures
2 points : Petite fonctionnalité, <1 jour
3 points : Fonctionnalité moyenne, 1-2 jours
5 points : Grande fonctionnalité, 3-5 jours
8 points : Fonctionnalité complexe, 1-2 semaines
13+ points : Travail au niveau épopée, nécessite décomposition

Tailles en t-shirt (Epics/Features)

XS : 1-2 story points au total
S : 3-8 story points au total
M : 8-20 story points au total
L : 20-40 story points au total
XL : 40+ story points au total (envisager une décomposition)

6. Gestion des dépendances

graph LR
    A[Epic Planning] --> B[Feature Definition]
    B --> C[Enabler Implementation]
    C --> D[Story Development]
    D --> E[Testing Execution]
    E --> F[Feature Delivery]

    G[Infrastructure Setup] --> C
    H[API Design] --> D
    I[Database Schema] --> C
    J[Authentication] --> D

Types de dépendances

Bloque : Travail qui ne peut pas progresser jusqu'à son achèvement
Lié : Travail qui partage le contexte mais ne bloque pas
Prérequis : Infrastructure requise ou travail de configuration
Parallèle : Travail qui peut progresser simultanément

7. Modèle de planification de sprint

Planification de la capacité du sprint

Vélocité de l'équipe : {Moyenne story points par sprint}
Durée du sprint : {Sprints de 2 semaines recommandés}
Allocation de tampon : 20% pour travail imprévu et corrections de bugs
Facteur de focus : 70-80% du temps total sur travail planifié

Définition du but du sprint

## Objectif du sprint {N}

**Objectif principal** : {Livrable principal pour ce sprint}

**Histoires du sprint** :

- #{issue} - {Story title} ({points} pts)
- #{issue} - {Story title} ({points} pts)

**Engagement total** : {points} story points
**Critères de succès** : {Résultats mesurables}

8. Configuration du tableau de projet GitHub

Structure des colonnes (Kanban)

Backlog : Priorisé et prêt pour planification
Sprint Ready : Détaillé et estimé, prêt pour développement
In Progress : En cours de travail
In Review : Code review, test ou review par les parties prenantes
Testing : Validation QA et test d'acceptation
Done : Complété et accepté

Configuration des champs personnalisés

Priority : P0, P1, P2, P3
Value : High, Medium, Low
Component : Frontend, Backend, Infrastructure, Testing
Estimate : Story points ou taille en t-shirt
Sprint : Affectation du sprint actuel
Assignee : Membre de l'équipe responsable
Epic : Référence épopée parent

9. Automatisation et GitHub Actions

Création automatisée de problèmes

name: Create Feature Issues

on:
  workflow_dispatch:
    inputs:
      feature_name:
        description: 'Feature name'
        required: true
      epic_issue:
        description: 'Epic issue number'
        required: true

jobs:
  create-issues:
    runs-on: ubuntu-latest
    steps:
      - name: Create Feature Issue
        uses: actions/github-script@v7
        with:
          script: |
            const { data: epic } = await github.rest.issues.get({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: ${{ github.event.inputs.epic_issue }}
            });

            const featureIssue = await github.rest.issues.create({
              owner: context.repo.owner,
              repo: context.repo.repo,
              title: `Feature: ${{ github.event.inputs.feature_name }}`,
              body: `# Feature: ${{ github.event.inputs.feature_name }}\n\n...`,
              labels: ['feature', 'priority-medium'],
              milestone: epic.data.milestone?.number
            });

Mises à jour automatisées du statut

name: Update Issue Status

on:
  pull_request:
    types: [opened, closed]

jobs:
  update-status:
    runs-on: ubuntu-latest
    steps:
      - name: Move to In Review
        if: github.event.action == 'opened'
        uses: actions/github-script@v7
        # Déplacer les problèmes liés vers colonne "In Review"

      - name: Move to Done
        if: github.event.action == 'closed' && github.event.pull_request.merged
        uses: actions/github-script@v7
        # Déplacer les problèmes liés vers colonne "Done"

Liste de vérification de création de problèmes

Préparation avant création

[ ] Artefacts de fonctionnalité complets : PRD, design UX, décomposition technique, plan de test
[ ] Epic existe : Problème épopée parent créé avec labels et jalons appropriés
[ ] Tableau de projet configuré : Colonnes, champs personnalisés et règles d'automatisation configurés
[ ] Capacité de l'équipe évaluée : Planification de sprint et allocation de ressources complétées

Problèmes au niveau Epic

[ ] Problème epic créé avec description complète et critères d'acceptation
[ ] Milestone epic créé avec date de sortie cible
[ ] Labels epic appliqués : epic, priorité, valeur et labels d'équipe
[ ] Epic ajouté au tableau de projet dans colonne appropriée

Problèmes au niveau Feature

[ ] Problème feature créé liant vers epic parent
[ ] Dépendances de feature identifiées et documentées
[ ] Estimation de feature complétée utilisant tailles en t-shirt
[ ] Critères d'acceptation de feature définis avec résultats mesurables

Problèmes au niveau Story/Enabler documentés dans `/docs/ways-of-work/plan/{epic-name}/{feature-name}/issues-checklist.md`

[ ] Histoires utilisateur créées suivant critères INVEST
[ ] Enablers techniques identifiés et priorisés
[ ] Story points estimés utilisant échelle Fibonacci
[ ] Dépendances mappées entre histoires et enablers
[ ] Critères d'acceptation détaillés avec exigences testables

Métriques de succès

Indicateurs clés de gestion de projet

Prévisibilité de sprint : >80% du travail engagé complété par sprint
Cycle Time : Temps moyen de « In Progress » à « Done » <5 jours ouvrables
Lead Time : Temps moyen de « Backlog » à « Done » <2 semaines
Taux d'échappement de défauts : <5% des histoires nécessitent corrections post-sortie
Vélocité d'équipe : Livraison de story points cohérente entre sprints

Métriques d'efficacité de processus

Temps de création de problème : <1 heure pour créer décomposition feature complète
Résolution de dépendances : <24 heures pour résoudre dépendances bloquantes
Exactitude de mise à jour statut : >95% des transitions de statut automatisées fonctionnant correctement
Complétude de documentation : 100% des problèmes ont champs modèles requis
Collaboration interfonctionnelle : <2 jours ouvrables pour résolution dépendances externes

Métriques de livraison de projet

Conformité Definition of Done : 100% des histoires complétées satisfont DoD
Couverture des critères d'acceptation : 100% des critères d'acceptation validés
Réalisation d'objectif de sprint : >90% des objectifs de sprint livrés avec succès
Satisfaction des parties prenantes : >90% approbation parties prenantes pour fonctionnalités complétées
Exactitude de planification : <10% de variance entre livraison estimée et actuelle

Cette approche complète de gestion de projets GitHub garantit la traçabilité complète de la planification au niveau épopée jusqu'aux tâches de mise en œuvre individuelles, avec suivi automatisé et responsabilité claire pour tous les membres de l'équipe.