Critères d'acceptation : comment les rédiger (avec exemples)

Turn this article into takeaways for your work.
Each assistant summarizes the article only for you and suggests best practices for your work.
Les critères d'acceptation sont les conditions qu'une user story doit remplir avant que votre équipe la considère comme prête à être livrée. Bien rédigés, ils réduisent les retouches, les discussions et les bugs surprises au moment de la revue.
Que sont les critères d'acceptation ?
Les critères d'acceptation sont un ensemble de conditions précises et testables rattachées à une seule user story. Ils définissent ce que la fonctionnalité doit faire (et ne pas faire) du point de vue de l'utilisateur. Quand toutes les conditions sont remplies, la story est acceptée. Dès qu'une seule échoue, le travail continue.
Voyez-les comme le contrat entre la personne qui a demandé la fonctionnalité et l'équipe qui la construit. Plus de devinettes, plus de « je pensais que vous vouliez autre chose ». Juste une liste claire de conditions réussite ou échec, écrite avant le début du développement.
Les critères d'acceptation se situent au niveau de la story. Ils répondent à la question : « Comment saurons-nous que cette story est terminée ? » C'est une question différente de « Comment saurons-nous que le sprint est terminé ? », à laquelle répond la definition of done.
Chiffres clés
- Le format Given-When-Then pour les critères d'acceptation a été introduit par Dan North dans le cadre du behaviour-driven development (BDD) vers 2006, afin de donner aux équipes une manière structurée et testable d'exprimer le comportement attendu. (Source : Dan North, « Introducing BDD », dannorth.net, 2006.)
- L'Agile Alliance note que des critères d'acceptation ambigus ou absents comptent parmi les causes les plus courantes de retouches dans les projets agiles. (Source : Agile Alliance Glossary, agilealliance.org.)
- Les équipes qui rédigent les critères d'acceptation avant de coder signalent des passages de relais plus rapides entre le développement et la QA, car les testeurs savent déjà quoi vérifier.
Formats de rédaction des critères d'acceptation
Deux formats sont les plus utilisés par les équipes. Aucun n'est meilleur dans l'absolu. Choisissez celui qui correspond à la façon de travailler de votre équipe.

Given-When-Then (par scénario)
Aussi appelé format Gherkin, il vient du behaviour-driven development (BDD). Il structure chaque condition comme un scénario en trois parties :
- Given (étant donné), l'état de départ ou le contexte
- When (quand), l'action de l'utilisateur
- Then (alors), le résultat attendu
Exemple, connexion d'un utilisateur :
Given un utilisateur inscrit se trouve sur la page de connexion
When il saisit un e-mail valide et le bon mot de passe puis clique sur « Se connecter »
Then il est redirigé vers son dashboard et voit un message de bienvenue
Given un utilisateur inscrit se trouve sur la page de connexion
When il saisit un e-mail valide et un mot de passe incorrect
Then il voit un message d'erreur : « E-mail ou mot de passe incorrect » et reste sur la page de connexion
Ce format convient bien quand le comportement est séquentiel et que vous pouvez écrire plusieurs scénarios d'échec à côté des scénarios nominaux. Les ingénieurs QA peuvent transformer chaque scénario directement en cas de test.
Par règles (liste de contrôle)
Certaines équipes préfèrent une simple liste à puces de règles. Ce format convient aux stories dont les conditions sont indépendantes plutôt que séquentielles.
Exemple, recherche de produits :
- Les résultats de recherche s'affichent en moins de 2 secondes pour toute requête
- Les résultats sont triés par pertinence par défaut
- Les utilisateurs peuvent filtrer les résultats par catégorie, fourchette de prix et note
- Si aucun résultat n'est trouvé, la page affiche : « Aucun résultat pour [requête]. Essayez d'autres mots-clés. »
- La barre de recherche conserve la requête de l'utilisateur après le chargement des résultats
Les critères d'acceptation par règles sont plus rapides à écrire et plus faciles à parcourir. Ils conviennent surtout aux contraintes d'interface, aux exigences de performance et aux cas limites qui ne s'inscrivent pas dans une séquence d'actions de l'utilisateur.
Critères d'acceptation et definition of done
Ces deux concepts sont souvent confondus. Ils résolvent des problèmes différents.

| Critères d'acceptation | Definition of done | |
|---|---|---|
| Périmètre | Une user story | Chaque story, chaque sprint |
| Qui la rédige | Le product owner avec l'équipe | Toute l'équipe ensemble |
| Quand elle est rédigée | Avant le début du développement | Une fois par projet ou par cycle de sprint |
| Ce qu'elle couvre | Les conditions fonctionnelles de cette fonctionnalité | Les contrôles qualité transverses (tests, revues, documentation) |
| Si elle n'est pas respectée | Cette story n'est pas acceptée | Aucune story du sprint n'est livrée |
Une story peut satisfaire tous ses critères d'acceptation et échouer quand même à la definition of done, par exemple si elle n'a pas de tests unitaires ou n'a pas été relue par un pair. Les deux listes doivent être validées pour que le travail soit vraiment terminé.
Retrouvez le détail complet dans l'article sur la definition of done.
Caractéristiques de bons critères d'acceptation
Toute liste de conditions ne constitue pas de bons critères d'acceptation. Voici ce qui distingue l'utile du vague :
Testables. Chaque condition doit avoir un résultat clair, réussite ou échec. « L'interface est jolie » n'est pas testable. « Le bouton respecte un ratio de contraste de 4,5:1 » l'est.
Écrits du point de vue de l'utilisateur. Les critères d'acceptation décrivent ce que l'utilisateur vit, pas la manière dont le code est structuré. Évitez les détails d'implémentation comme « l'API renvoie un statut 200 ». Préférez « l'utilisateur voit immédiatement son profil mis à jour ».
Précis. Les chiffres, les états et les libellés comptent. « Réponse rapide » devient « réponse en moins de 1,5 seconde ». « Un message d'erreur » devient « le texte exact : "Le mot de passe doit comporter au moins 8 caractères." »
Validés avant le début du développement. Des critères rédigés une fois la fonctionnalité construite tendent à justifier ce qui a été fait plutôt qu'à décrire ce qui était nécessaire. Rédigez-les pendant le backlog refinement.
Pas trop nombreux. De trois à huit conditions, c'est une fourchette saine. Une story avec quinze critères d'acceptation cache probablement deux ou trois stories en une.
Comment rédiger des critères d'acceptation
Partez d'une story claire, couvrez les résultats attendus et les cas limites, employez un langage testable, relisez ensemble et rattachez les critères définitifs à la story.

Étape 1 : partir de la user story
Impossible de rédiger des critères d'acceptation sans user story claire. Vérifiez que vous en avez une dans ce format :
En tant que [persona], je veux [objectif], afin de [raison].
Si la story est floue, précisez-la avant de rédiger les conditions.
Étape 2 : se demander « qu'est-ce qui doit être vrai pour que cela fonctionne ? »
Listez les comportements et les résultats que la fonctionnalité doit produire. Couvrez d'abord le scénario nominal, puis les cas limites et les états d'échec.
Étape 3 : choisir un format
Choisissez Given-When-Then si le comportement est séquentiel et que la QA pilotera la création des tests. Choisissez les règles si les conditions sont indépendantes ou si vous manquez de temps.
Étape 4 : écrire dans un langage testable
Remplacez les mots vagues. « Rapidement » devient un chiffre. « Correctement formaté » devient le format exact. « Doit fonctionner sur mobile » devient « la mise en page s'adapte à une largeur de 375 px ».
Étape 5 : relire avec l'équipe avant le début du développement
Partagez le brouillon avec les développeurs, la QA et les parties prenantes. Les développeurs repéreront les conditions techniquement impossibles. La QA verra les cas limites manquants. Les parties prenantes corrigeront les erreurs de logique métier. Faites-le pendant le backlog refinement ou le sprint planning, afin que tout le monde soit d'accord avant la première ligne de code.
Étape 6 : les rattacher à la story
Ajoutez les critères définitifs à la story dans votre product backlog. Ils restent attachés tout au long du développement et constituent la liste de contrôle que votre équipe utilise pendant la revue de sprint.
Exemples de critères d'acceptation
Voici trois exemples détaillés couvrant différents types de stories.

Exemple 1 : connexion d'un utilisateur
Story : en tant qu'utilisateur régulier, je veux me connecter avec mon e-mail et mon mot de passe, afin d'accéder à mon compte.
Given l'utilisateur se trouve sur la page de connexion
When il saisit un e-mail enregistré et le bon mot de passe puis clique sur « Se connecter »
Then il est redirigé vers son dashboard en moins de 2 secondes
Given l'utilisateur saisit trois fois un mot de passe incorrect
When il tente une quatrième connexion
Then le compte est verrouillé pendant 30 minutes et l'utilisateur voit :
« Trop de tentatives échouées. Réessayez dans 30 minutes. »
Given l'utilisateur est connecté
When il clique sur « Se déconnecter »
Then sa session prend fin et il est redirigé vers la page d'accueil
Exemple 2 : total de la commande
Story : en tant qu'acheteur, je veux voir le total de ma commande avant de payer, afin de savoir exactement ce que je dois.
| Condition | Validée quand |
|---|---|
| Le sous-total est affiché | Les lignes de commande s'additionnent correctement |
| La taxe est détaillée | Le taux et le montant de la taxe sont affichés séparément |
| La remise est appliquée | Le code promo réduit le sous-total avant taxe |
| La livraison est affichée | Le coût est affiché, ou « Livraison gratuite » si la commande y est éligible |
| Le total se met à jour en temps réel | Le total est recalculé quand le panier change, sans rechargement de la page |
Exemple 3 : recherche sans résultat
Story : en tant qu'utilisateur, je veux savoir quand ma recherche ne renvoie rien, afin d'essayer d'autres mots-clés.
- Lorsqu'une recherche renvoie zéro résultat, la page affiche : « Aucun résultat pour "[requête]". Essayez d'autres mots-clés. »
- La barre de recherche conserve la requête d'origine de l'utilisateur
- Des suggestions de catégories associées apparaissent sous le message si elles existent
- Le titre de la page est mis à jour pour refléter l'état de recherche vide
Erreurs courantes à éviter
Les rédiger après coup. Des critères d'acceptation écrits après le développement décrivent ce qui a été construit, pas ce qui était nécessaire. Rédigez-les en premier.
Rester vague sur les états d'erreur. Des critères limités au scénario nominal laissent les développeurs deviner la gestion des échecs. Incluez toujours au moins un scénario d'échec.
Y mélanger de l'implémentation technique. « Le service appelle l'API de paiement avec une requête POST » n'est pas un critère d'acceptation. « L'utilisateur voit une confirmation de paiement en moins de 3 secondes » en est un.
Les rendre trop larges. Si vos critères d'acceptation couvrent plusieurs fonctionnalités distinctes, scindez la story. Une bonne story, avec de bons critères, tient sur une fiche cartonnée.
Sauter la revue d'équipe. Des critères rédigés seul (en général par le product owner) passent à côté des contraintes des développeurs et des cas limites de la QA. Relisez ensemble avant le début du sprint. Servez-vous des cérémonies agiles comme le refinement pour le faire de façon régulière.
De bons critères d'acceptation ne garantissent pas un excellent produit, mais ils évitent une catégorie précise d'échec : construire quelque chose que personne n'avait l'intention de construire. Rédigez-les tôt, relisez-les ensemble, et vos revues de sprint passeront de débats sur le sens de « terminé » à de simples démonstrations d'un logiciel qui fonctionne.

Senior Operations & Growth Strategist
On this page
- Que sont les critères d'acceptation ?
- Formats de rédaction des critères d'acceptation
- Given-When-Then (par scénario)
- Par règles (liste de contrôle)
- Critères d'acceptation et definition of done
- Caractéristiques de bons critères d'acceptation
- Comment rédiger des critères d'acceptation
- Étape 1 : partir de la user story
- Étape 2 : se demander « qu'est-ce qui doit être vrai pour que cela fonctionne ? »
- Étape 3 : choisir un format
- Étape 4 : écrire dans un langage testable
- Étape 5 : relire avec l'équipe avant le début du développement
- Étape 6 : les rattacher à la story
- Exemples de critères d'acceptation
- Exemple 1 : connexion d'un utilisateur
- Exemple 2 : total de la commande
- Exemple 3 : recherche sans résultat
- Erreurs courantes à éviter