22 février 2026Mis à jour le Fathy Shalaby13 min de lecture
Comment découper un PRD en user stories et tickets Jira
Une méthode pas à pas pour transformer un PRD en epics, user stories et tickets Jira sans perdre le pourquoi, avec un exemple concret et les apports de l’IA dans la création de tickets.
Pour découper un PRD en user stories, cartographiez le parcours utilisateur que décrit le PRD, transformez chaque étape en une story fine et de bout en bout, puis scindez tout ce qui dépasse quelques jours de travail à l’aide de schémas comme SPIDR. Donnez à chaque story des critères d’acceptation testables, vérifiez-la avec INVEST, puis envoyez-la dans Jira avec un lien vers le PRD pour que le raisonnement accompagne le ticket.
L’essentiel
Les projets échouent sur les exigences : l’étude Pulse of the Profession 2014 du PMI a constaté que 47 % des projets non réussis avaient manqué leurs objectifs à cause d’une gestion inexacte des exigences (PMI, 2014).
Les bonnes stories respectent INVEST : Independent, Negotiable, Valuable, Estimable, Small et Testable (Bill Wake, 2003).
Dimensionnez les stories pour que 6 à 10 tiennent dans un sprint (Humanizing Work).
Cinq techniques permettent de scinder presque toute story trop grosse : Spikes, Paths, Interfaces, Data et Rules (Mountain Goat Software).
Rédigez les critères d’acceptation en Given/When/Then, deux à quatre par story, pour que « terminé » soit testable.
Quelle est la différence entre un PRD, un epic, une user story et une tâche ?
Un PRD décrit le problème et le résultat attendu ; les epics, stories et tâches décrivent le travail. Bien distinguer les niveaux représente la moitié du travail quand vous découpez un PRD en user stories.
Niveau
Ce qu’il contient
Horizon typique
Responsable
PRD
Problème, utilisateurs, objectifs, non-objectifs, indicateurs de succès
Une tranche de valeur utilisateur, de bout en bout
Tient dans un sprint
Le PM rédige, l’équipe affine
Tâche
Travail technique qui soutient les stories (migration, analytics, tests)
De quelques heures à quelques jours
Ingénieur
Ces horizons suivent les recommandations d’Atlassian, qui décrit les stories comme tenant dans un sprint, les epics comme un travail que l’on peut terminer en un mois ou un trimestre, et les initiatives comme s’étendant de plusieurs trimestres à un an (Atlassian). Mike Cohn définit simplement un epic comme « a large story », c’est-à-dire une grosse story que l’on scinde à l’approche du développement (Mountain Goat Software).
Si votre PRD est encore en cours de rédaction, terminez-le d’abord ; le guide pour rédiger un PRD explique ce qu’il lui faut avant que les stories aient un sens.
Comment découper un PRD en user stories ?
Suivez ces huit étapes. Le PM peut faire seul le premier jet ; l’affinage avec l’équipe demande une session de plus.
Fixer les limites. Surlignez les objectifs du PRD et ses non-objectifs. Chaque story doit se rattacher à un objectif ; tout ce qui se rattache à un non-objectif est écarté maintenant, pas lors de la revue de sprint.
Cartographier le parcours utilisateur. Alignez les étapes qu’un utilisateur franchit, de gauche à droite, dans l’ordre où elles se produisent. Le user story mapping de Jeff Patton, décrit pour la première fois dans un article de 2005, organise les stories le long de ce parcours pour repérer les trous et planifier les releases (Jeff Patton).
Rédiger un epic par capacité majeure. Règle empirique utile : un à trois epics par PRD de fonctionnalité. Plus de quatre signalent généralement que le PRD couvre plusieurs paris et doit être scindé.
Écrire des stories fines et de bout en bout pour chaque étape. Utilisez le gabarit connu : en tant que [type d’utilisateur], je veux [faire quelque chose], afin de [bénéfice]. Chaque story doit traverser toutes les couches (UI, API, données) pour livrer quelque chose qu’un utilisateur peut essayer.
Scinder tout ce qui est trop gros. La recommandation initiale de Bill Wake plafonnait les stories à quelques semaines-personnes, et beaucoup d’équipes visent quelques jours-personnes. Si l’équipe ne peut pas estimer une story, ou si elle occuperait l’essentiel d’un sprint, scindez-la (voir la section suivante).
Rédiger les critères d’acceptation. Deux à quatre énoncés Given/When/Then par story, tirés des exigences du PRD. N’inventez pas d’exigences voisines pour remplir la place.
Ajouter des tâches pour le travail transverse. Événements analytics, migrations de données, feature flags et mise en place des tests relèvent de tâches liées aux stories qu’elles soutiennent.
Vérifier avec INVEST, estimer et séquencer. Poussez ensuite vers Jira ou Linear, avec un lien vers le PRD dans chaque epic.
Comment scinder une user story trop grosse ?
Choisissez le découpage qui livre la valeur utilisateur le plus tôt et qui met en évidence les parties à faible valeur que vous pouvez abandonner. La technique SPIDR de Mike Cohn propose cinq options, chacune avec un exemple tiré de son propre article :
Technique
Comment elle scinde
Exemple
Spikes
Mener d’abord une recherche limitée dans le temps, puis scinder avec ce que l’on a appris
Tester des outils commerciaux de sous-titrage avant de décider de construire ou d’acheter
Paths
Une story par chemin que l’utilisateur peut emprunter pour accomplir la tâche
« Partager par lien » comme une story, « partager sur un réseau social » comme une autre
Interfaces
D’abord une interface simple, des versions plus riches ensuite
Partager un simple lien avant un sélecteur de partage avec logos
Data
Prendre d’abord en charge un sous-ensemble plus simple de données
Accepter un seul format vidéo au départ ; supposer un seul manager par employé
Rules
Assouplir temporairement une règle dont la story aura finalement besoin
Livrer les commentaires avant le filtrage des contenus offensants
Le guide de Richard Lawrence et Peter Green ajoute neuf schémas, dont les étapes de workflow, les opérations (créer, lire, modifier, supprimer), les variantes de règles métier et « reporter la performance ». Deux de leurs critères pour choisir entre plusieurs découpages méritent d’être adoptés :
Privilégiez le découpage qui révèle un travail à faible valeur. Une façon de scinder montre souvent qu’une partie de la story peut être abandonnée purement et simplement.
Privilégiez des stories de taille égale. Leur exemple : scinder une story de 8 points en quatre stories de 2 points plutôt qu’en une de 5 et une de 3, car des morceaux égaux laissent plus de liberté au product owner pour les réordonner.
Évitez de scinder par couche technique (« construire l’API », « construire l’UI »). Ces morceaux ne livrent rien qu’un utilisateur puisse tester seul, ce qui enfreint le V de INVEST.
Comment rédiger les critères d’acceptation d’une user story ?
Rédigez-les comme des résultats observables, au format Given/When/Then issu de Gherkin. Given décrit le contexte de départ, When décrit un événement ou une action, et Then décrit le résultat attendu (Cucumber). Cohn décrit les critères d’acceptation comme les détails qui indiquent à l’équipe si une story est terminée, la « confirmation » du modèle carte, conversation et confirmation de Ron Jeffries.
Un bon jeu de critères pour une story :
Story : En tant qu’analyste, je veux enregistrer mes filtres actuels sous un nom,
afin de relancer le rapport de lundi prochain en un clic.
AC1 Given J’ai appliqué au moins un filtre
When Je choisis « Enregistrer le filtre » et saisis un nom
Then L’ensemble de filtres apparaît dans ma liste de filtres enregistrés
AC2 Given J’ai un filtre enregistré
When J’ouvre le rapport et je le sélectionne
Then Le rapport affiche les mêmes résultats qu’au moment de l’enregistrement
AC3 Given Je saisis un nom qui existe déjà
When J’enregistre
Then On me demande de renommer ou d’écraser
Trois règles gardent les critères utiles. Chacun doit pouvoir être testé par quelqu’un qui ne l’a pas écrit. Chacun doit décrire un comportement, pas une implémentation. Et il devrait rarement y en avoir plus de quatre : une story à huit critères, ce sont généralement deux stories. La checklist de recette du PM explique comment vérifier le travail terminé par rapport à eux.
Exemple concret : un PRD découpé en stories (illustratif)
Imaginons une équipe de six personnes avec un PRD pour des filtres de rapport enregistrés dans un produit d’analytics B2B. Les clients reconstruisent les mêmes filtres chaque lundi. Objectif : réduire le temps de production du rapport hebdomadaire. Non-objectif : l’envoi programmé des rapports par e-mail.
#
Type
Ticket
Découpage utilisé
Points
E1
Epic
Enregistrer et réutiliser des filtres
S1
Story
En tant qu’analyste, je veux enregistrer mes filtres actuels sous un nom, afin de les réutiliser la semaine prochaine
3
S2
Story
En tant qu’analyste, je veux appliquer un filtre enregistré depuis une liste, afin que le rapport se charge en une étape
Étape de workflow
2
S3
Story
En tant qu’analyste, je veux renommer ou supprimer un filtre enregistré, afin que ma liste reste ordonnée
Opérations
2
S4
Story
Les filtres enregistrés ne prennent en charge que la date et la région ; les champs personnalisés viendront plus tard
Data
3
E2
Epic
Partager des filtres avec l’équipe
S5
Story
En tant que team lead, je veux partager un filtre enregistré par lien, afin que mon équipe exécute le même rapport
Paths
3
S6
Story
Les filtres partagés sont en lecture seule ; les droits de modification viendront plus tard
Rules
5
T1
Tâche
Ajouter un événement analytics filter_saved pour mesurer l’adoption
1
T2
Tâche
Migration de base de données pour les filtres enregistrés
2
T3
Spike
Le moteur de requêtes peut-il mettre en cache les résultats filtrés ? Limité à une journée
Spike
–
Cela fait deux epics, six stories, deux tâches et un spike, soit 21 points au total. Avec 6 stories, on reste aussi dans la fourchette de 6 à 10 par sprint : une équipe dont la vélocité tourne autour de 20 points pourrait donc tout livrer en un sprint environ. L’envoi programmé par e-mail n’apparaît nulle part, puisque le PRD l’a exclu.
Comment transférer les stories d’un PRD dans Jira sans perdre le contexte ?
L’échec habituel ne vient pas du découpage, mais de ce qui se perd en route. Les ingénieurs voient un titre et trois puces, et la raison côté client reste dans le PRD que plus personne ne rouvre.
Liez chaque epic au PRD, et le PRD à l’epic en retour.
Mettez le « pourquoi » dans la description : une phrase sur le problème du client, idéalement avec la preuve (une citation, un nombre de tickets, un indicateur).
Copiez les critères d’acceptation dans le ticket, plutôt que « voir PRD ». Les critères placés dans un document lié ne sont pas testés.
Étiquetez par section du PRD pour pouvoir vérifier ensuite que chaque exigence a un ticket.
Modifiez d’abord le PRD quand le périmètre change, puis régénérez ou modifiez les tickets concernés. Si le PRD et Jira se contredisent, personne ne sait lequel dit vrai. Une spécification technique que les ingénieurs lisent vraiment suit la même règle pour les décisions de conception.
L’IA peut-elle découper un PRD en user stories ?
Oui. Quand vous découpez un PRD en user stories avec l’IA, elle gère bien la partie mécanique : proposer des epics, rédiger le texte des stories, suggérer des critères d’acceptation et des estimations en quelques secondes. Elle est plus faible sur ce qui demande du jugement : savoir quel non-objectif une partie prenante essaiera de réintroduire, quel découpage révèle un travail à faible valeur, et quelle estimation est largement optimiste pour votre base de code.
Traitez les tickets générés par l’IA comme un premier brouillon. Une courte checklist de relecture :
Chaque story se rattache-t-elle à un objectif du PRD, et aucune à un non-objectif ?
Chaque story est-elle une tranche verticale qu’un utilisateur pourrait essayer ?
Chaque story a-t-elle au moins un critère d’acceptation testable ?
L’IA a-t-elle ajouté du travail « connexe » que le PRD n’a jamais demandé ?
Un ingénieur de votre équipe validerait-il les estimations ?
Si les tickets sont destinés à un agent de code plutôt qu’à une personne, le niveau d’exigence monte, car les agents implémentent l’ambiguïté au pied de la lettre. Le modèle de PRD pour agents de code IA montre comment rendre les contraintes explicites.
Quelles sont les erreurs courantes dans le découpage d’un PRD ?
Le découpage horizontal. « Back-end des filtres enregistrés » et « front-end des filtres enregistrés » sont des tâches, pas des stories.
Les stories sans utilisateur. « Refactoriser le service de filtres » peut être nécessaire, mais c’est une tâche. Étiquetez-la honnêtement.
Les critères qui reprennent le titre. « L’utilisateur peut enregistrer un filtre » n’est pas un test. Dites ce que l’utilisateur voit.
Découper trop tôt. Si l’indicateur de succès ou le périmètre du PRD sont encore contestés, les tickets figent une supposition. Réglez d’abord le PRD ; un pre-mortem de lancement peut faire ressortir les hypothèses risquées.
Ne jamais boucler la boucle. Un ticket terminé indique que le code est livré, pas que le problème du client a disparu. Vérifiez l’indicateur de succès du PRD après la mise en production.
Cette méthode suppose une équipe qui travaille par sprints avec un backlog partagé. Les très petites équipes qui livrent en continu peuvent se passer d’estimations ; conservez malgré tout la vérification INVEST et les critères d’acceptation. Si vous cherchez à l’intégrer dans une semaine chargée, l’exemple d’emploi du temps hebdomadaire d’un PM place l’affinage du backlog le jeudi après-midi.
Où Specky s’intègre-t-il ?
Specky génère des tickets à partir d’un PRD approuvé ou d’une opportunité : epics, stories et tâches, chacun avec une description, deux à quatre critères d’acceptation testables, une priorité, une estimation en story points et des étiquettes liées à la section du PRD. Vous modifiez tout avant l’envoi. La livraison vers Jira, Linear, GitHub Issues, Trello ou Shortcut n’a lieu qu’une fois le PRD approuvé et chaque ticket doté d’au moins un critère d’acceptation ; chaque ticket reste lié à son PRD, et le lien Jira ou Linear est enregistré à côté. Comme le PRD se trouve dans le Product Graph avec ses preuves client, le « pourquoi » reste attaché. Essayez le générateur de PRD gratuit pour rédiger d’abord le PRD.
Foire aux questions
Combien de user stories un PRD doit-il comporter ?
Il n’y a pas de nombre fixe. En règle empirique, un PRD pour une seule fonctionnalité produit un à trois epics, chacun avec une poignée de stories. La taille compte plus que le nombre : Humanizing Work recommande des stories assez petites pour que 6 à 10 tiennent dans un sprint. Si un PRD produit plus de quatre epics, il regroupe probablement plusieurs paris et devrait être scindé en PRD distincts.
Quelle est la différence entre un epic et une user story ?
Un epic est un gros bloc de travail qui regroupe des stories liées sous un même objectif ; une user story est une petite tranche de valeur utilisateur qui tient dans un sprint. Atlassian décrit les epics comme prenant un mois ou un trimestre. Mike Cohn qualifie un epic de « a large story » que l’on scinde en stories plus petites à l’approche du développement.
Qui doit rédiger les user stories, le PM ou les ingénieurs ?
Le product manager rédige généralement les user stories à partir du PRD, puis l’équipe les affine ensemble. Le PM porte le « qui » et le « pourquoi » ; les ingénieurs affûtent le découpage, les estimations et les tâches techniques. Les stories écrites par le seul PM sont souvent mal découpées, et celles écrites par les seuls ingénieurs perdent souvent l’utilisateur de vue. Une session d’affinage commune règle les deux problèmes.
Qu’est-ce qui fait une bonne user story ?
Une bonne user story respecte INVEST, la checklist de Bill Wake de 2003 : Independent, Negotiable, Valuable, Estimable, Small et Testable. Concrètement, elle désigne un vrai utilisateur, livre quelque chose qu’il peut essayer seul, peut être estimée par l’équipe, tient en quelques jours de travail et possède des critères d’acceptation qu’une autre personne pourrait tester.
Quel niveau de détail pour les critères d’acceptation ?
Les critères d’acceptation doivent être assez détaillés pour que quelqu’un qui ne les a pas écrits puisse tester la story, et pas davantage. Deux à quatre énoncés Given/When/Then par story constituent une bonne fourchette. Décrivez un comportement observable plutôt qu’une implémentation. Si une story demande huit critères, scindez-la en deux stories plutôt que d’écrire une liste plus longue.
Peut-on convertir automatiquement un PRD en tickets Jira ?
Oui. Plusieurs outils, dont Specky, utilisent l’IA pour transformer un PRD en epics, stories et critères d’acceptation et les envoyer dans Jira. L’automatisation gère bien la rédaction, mais une personne doit tout de même contrôler le résultat : chaque story doit se rattacher à un objectif du PRD, rien ne doit provenir d’un non-objectif, et chaque ticket doit avoir des critères testables avant qu’un ingénieur ne s’en empare.
GDPR-aligned. EU workspace data is stored in Frankfurt, Germany. GDPR and EU data Built in Vienna, Austria. A product of influence solutions fm GmbH (FN 675374y). Imprint 14-day trial. Card required, and nothing is charged until day 14. 30-day refund after subscribing. See pricing