---
id: req.acceptance-criteria
title: Acceptance criteria
kind: practice
domain: requirements
description: Write acceptance criteria as observable pass-or-fail checks tied to requirement ids, agree them before work starts, and record who accepted the result with what evidence.
version: 1.0.0
status: approved
authority: recommended
applies_to: [core]
sources:
  - title: IREB CPRE Glossary — "Acceptance criteria", "Acceptance test"
    url: https://cpre.ireb.org/en/downloads-and-resources/glossary
    license: LicenseRef-All-Rights-Reserved
    accessed: 2026-11-20
  - title: Dan North, "Introducing BDD"
    url: https://dannorth.net/blog/introducing-bdd/
    license: LicenseRef-All-Rights-Reserved
    accessed: 2026-11-20
  - title: Martin Fowler, "Given When Then"
    url: https://martinfowler.com/bliki/GivenWhenThen.html
    license: LicenseRef-All-Rights-Reserved
    accessed: 2026-11-20
  - title: GOV.UK Service Manual — Writing user stories
    url: https://www.gov.uk/service-manual/agile-delivery/writing-user-stories
    license: OGL-UK-3.0
    accessed: 2026-11-20
  - title: Atlassian, "What is acceptance criteria?"
    url: https://www.atlassian.com/work-management/project-management/acceptance-criteria
    license: LicenseRef-All-Rights-Reserved
    accessed: 2026-11-20
standards: [ISO/IEC/IEEE 29148:2018]
requires: [req.requirements-specification]
related: [req.scope-and-mvp, req.product-vision, mgmt.project-foundation, quality.quality-release]
last_reviewed: 2026-11-22
review_every: 12
---

## Summary

Acceptance criteria are the conditions a piece of work must meet for the person who asked for it to accept it.
Each one is a check with a clear pass or fail, written in terms of what a user or the system does, and tied to
the requirement it proves. They are agreed before the work starts, so that "done" is not argued afterwards,
and they are checked by someone other than the person who built the work.

## Rules

- **R1.** Every requirement, and every issue or story that delivers one, MUST have at least one acceptance
  criterion before work on it starts.
- **R2.** An acceptance criterion MUST be a statement that someone other than its author can answer with pass
  or fail without asking the author what was meant.
- **R3.** An acceptance criterion MUST describe observable behaviour or a result (what a user or another system
  sees or can do), not how the work is implemented.
- **R4.** Each criterion MUST carry its own stable id (for example `AC-4`) and the id of each requirement it
  proves. Ids MUST NOT be renumbered or reused.
- **R5.** A criterion for a quality requirement MUST state the measured value, the condition and the method
  of measurement.
- **R6.** For a requirement that handles input, permissions or failure, the criteria MUST include at least
  one case where the system refuses, rejects or fails safely, in addition to the normal case.
- **R7.** Criteria MUST NOT be weakened or removed to make a failing result pass. A change to a criterion MUST
  be approved in the same way as a change to the requirement it proves.
- **R8.** Acceptance MUST be decided by the person who owns the product or by the customer, as named in the
  requirements specification. The author of the work MUST NOT accept it.
- **R9.** A criterion that is checked by hand MUST be written as steps with the expected result, and its
  result MUST be recorded with evidence (a log, a link, a screenshot) and the date.
- **R10.** Acceptance MUST be recorded: each criterion with its result, the evidence, the date and who
  accepted. A release or a delivered work item MUST NOT be reported as accepted without this record.
- **R11.** A criterion SHOULD be automated as a test where the cost is reasonable, and the test SHOULD cite the
  criterion id. A project SHOULD use one format for criteria, either scenarios (Given, When, Then) or a
  checklist ("it is done when …").

## Guidance

- **Two common formats.** A scenario format reads: *Given* the starting situation, *When* an action or event
  occurs, *Then* the observable result. It comes from behaviour-driven development, where Dan North described
  a story's behaviour as its acceptance criteria written as scenarios; Fowler summarises the style and its
  link to specification by example. The rule format is a plain checklist; the GOV.UK Service Manual suggests
  "it's done when …" lines for each story. Use scenarios where inputs and outcomes vary, a checklist where
  the work is a set of facts to confirm.
- **Criterion, definition of done, test.** An acceptance criterion belongs to one requirement or story. The
  *definition of done* is the team-wide quality bar that every item passes (reviewed, tested, documented); see
  `templates/definition-of-done.md`. A *test* is the automated check of a criterion or of the bar. A story is
  finished when its criteria are met and the definition of done is met.
- **Examples beat adjectives.** "The error message is clear" fails R2. "A wrong password shows 'Wrong email or
  password' and does not say which of the two was wrong" passes.
- **Boundaries.** For every number, ask "and at exactly the limit? one past it? empty? twice?" Add the cases
  that matter (R6).
- **Keep few and sharp.** A story that needs more than a handful of criteria is usually two stories. Split it.
- **Writing them in time.** Write the criteria with the owner when the requirement is written or when the item
  is made ready, not after the code exists. The Hub's definition of ready asks for criteria that can be
  checked by a test or a demonstration (`templates/definition-of-ready.md`).
- **Working with agents.** Give an agent the criteria with their ids and ask it to show, for each, the test or
  the evidence. An agent reports; the owner or customer accepts (R8).
- **When not to apply.** Typo fixes and internal refactorings with no change in behaviour need no new criteria;
  the existing ones must still pass.

## Explanation

The IREB glossary defines acceptance criteria as the criteria a work product must satisfy to be accepted by
its stakeholders and, in agile development, the criteria a backlog item must satisfy. An acceptance test is a
test that assesses whether a system satisfies its requirements and is typically used by customers to decide
whether to accept it. That makes criteria the contract between the requirement and the proof: the requirement
says what is wanted, the criterion says how everyone will know it was delivered.

Writing criteria first changes the conversation. Vague agreement ("sounds good") becomes a question about a
concrete case, while a change is still cheap. It also separates two roles that otherwise blur: the builder
shows evidence, and the person who owns the outcome decides (R8). Atlassian describes the same benefits:
shared understanding, less rework, and a clear point at which work is complete.

## Examples

Good — scenarios tied to ids, one failure case:

```markdown
- AC-7 (FR-9) Given a registered user, when they sign in with the right email and password, then they see
  their dashboard.
- AC-8 (FR-9) Given a registered user, when they sign in with a wrong password five times in ten minutes,
  then the sixth attempt is refused for 15 minutes and the page says when they can try again.
- AC-9 (NFR-3) The sign-in page responds in under 800 ms at the 95th percentile with 50 concurrent users,
  measured by the load test `signin.k6` on staging.
```

Bad — not checkable, no id, describes the build:

```markdown
- Sign-in works well and feels secure.
- Uses bcrypt.
```

## Sources

- [IREB CPRE Glossary](https://cpre.ireb.org/en/downloads-and-resources/glossary) — © IREB, all rights reserved; the definitions of acceptance criteria and acceptance test are paraphrased. Accessed 2026-11-20.
- [Dan North, "Introducing BDD"](https://dannorth.net/blog/introducing-bdd/) — all rights reserved; the scenario form (Given, When, Then) and the idea that a story's behaviour is its acceptance criteria, summarised. Accessed 2026-11-20.
- [Martin Fowler, "Given When Then"](https://martinfowler.com/bliki/GivenWhenThen.html) — all rights reserved; the style and its origin, summarised. Accessed 2026-11-20.
- [GOV.UK Service Manual, "Writing user stories"](https://www.gov.uk/service-manual/agile-delivery/writing-user-stories) — Open Government Licence v3.0; acceptance criteria as an "it's done when" checklist. Accessed 2026-11-20.
- [Atlassian, "What is acceptance criteria?"](https://www.atlassian.com/work-management/project-management/acceptance-criteria) — all rights reserved; purpose and benefits, summarised. Accessed 2026-11-20.
- ISO/IEC/IEEE 29148:2018, *Systems and software engineering — Life cycle processes — Requirements engineering* — referenced by name only.
