A definition of done is a team's standing quality bar: the checklist every piece of work must meet before anyone calls it finished. It is different from acceptance criteria. Acceptance criteria describe what one story must do. The definition of done describes what every story must go through, whatever it does. As of November 2026, after more than 15 years in design, UX and development, I think confusing the two is the most common way "done" quietly shrinks to mean "merged." The Scrum Guide defines the definition of done and says nothing about acceptance criteria, which is part of why teams blur them. Below is a starter definition of done in three tiers (story, release, and agent-written code) and a side-by-side table against acceptance criteria.
What is a definition of done?
A definition of done is the shared checklist a piece of work must meet before a team calls it finished. It applies to every item the team ships, not to one story. It names the quality steps that are easy to skip under pressure: review, tests, documentation, deployment, and whoever has to see it before it counts.
The Scrum Guide gives it a formal role. In the 2020 edition, the definition of done describes the state the work must reach to meet the quality the product requires. Work that doesn't meet it can't be released, and can't even be shown at the Sprint Review.
That second rule is the one with teeth. It means "almost done" isn't a status. Work is done or it goes back on the board.
You don't need to run Scrum to use one. Any team that ships software has a bar, written or not. The only question is whether everyone agrees on where it sits.
What is the difference between the definition of done and acceptance criteria?
Acceptance criteria describe what one story must do, and they change with every story. The definition of done describes the quality bar every story must clear, and it stays the same across the backlog. Acceptance criteria answer whether you built the right thing. The definition of done answers whether you finished it properly.
I covered the story side in acceptance criteria, with examples that would survive a test. This is the other half of that pair.
| Definition of done | Acceptance criteria | |
|---|---|---|
| Applies to | Every item the team ships | One story |
| Changes | Rarely, on purpose, at a retrospective | With every story |
| Who writes it | The team, inside any organizational minimum | Whoever owns the story, with the team |
| Answers | Is it finished to our standard? | Does it do what was asked? |
| Typical lines | Code reviewed. Tests run in CI. Docs updated. Deployed to staging. | A 51 MB upload is rejected with a named message. Codes never stack. |
| When it fails | Work ships with no tests, no docs, no rollback plan | Work does the wrong thing, well |
| Where it lives | One shared page, the same for everyone | In the story itself |
The giveaway that a team has mixed them up is a story with "code is reviewed" or "tests pass" in its acceptance criteria. Those lines aren't wrong. They're in the wrong place. If every story needs them, they belong in the definition of done, written once.
The reverse mistake is rarer and worse. A definition of done that contains story-specific behavior stops being a standing bar. Nobody can recite it, so nobody checks it.
Why does done end up meaning merged?
Because merging is the last step a developer can see, and the definition of done usually lists steps that happen after it. When the list lives in a wiki nobody opens, the merge button becomes the de facto bar. Testing in a real environment, documentation, and release slide into a next sprint that rarely comes.
This is my read of the pattern, not a statistic. The merge is visible, satisfying, and shows up on a dashboard. Updating the help text does not.
There's a second force. Acceptance criteria are checked in review, because they sit right there in the story. The definition of done is checked from memory. Under deadline, memory loses.
The fix is boring. Put the definition of done where the merge happens: in the pull request template, in the board's last column, in the release checklist. A bar that has to be read at the moment of merging gets read.
What should a starter definition of done include?
Start with three tiers. A story tier for every piece of work, a release tier for anything that reaches users, and a third tier for code an AI agent wrote. Keep each tier short enough to read aloud in a standup. A definition of done nobody can recite is one nobody follows.
Treat this as a starter. Cut what doesn't fit your product and add what your last three incidents taught you. Copy it:
DEFINITION OF DONE (team: ________ last changed: ________)
Tier 1: Story (every item)
- [ ] Acceptance criteria met and checked by someone other than the author
- [ ] Code reviewed by at least one teammate
- [ ] Automated tests added or updated; all tests pass in CI
- [ ] No new warnings or lint errors
- [ ] User-facing text written, not placeholder
- [ ] Docs or help text updated, or "no doc change" stated in the PR
Tier 2: Release (anything that reaches users)
- [ ] Deployed to a staging environment and checked there
- [ ] Keyboard and screen-reader pass on changed screens
- [ ] Logging or monitoring in place for the new path
- [ ] Rollback plan written in one sentence
- [ ] Release note drafted in plain language
Tier 3: Agent-written code (in addition to Tiers 1 and 2)
- [ ] Diff touches only files the task named, or the extra files are explained
- [ ] At least one test was seen failing before the change made it pass
- [ ] A person on the team can explain every changed function without the agent
- [ ] No new dependency added without a human choosing it
- [ ] The prompt or task spec is linked from the PR
Two lines in that list do most of the work in my experience. "Checked by someone other than the author" catches the misread story. "Rollback plan written in one sentence" catches the release nobody thought through. If you keep only two lines, keep those.
How should a definition of done change for agent-written code?
Add checks for what agents get wrong that humans rarely do: changes outside the requested scope, tests written to pass rather than to fail, and plausible code nobody on the team understands. The bar itself stays the same. A person still has to be able to explain the change and own it after it ships.
I wrote about where the human work goes in agentic software engineering: toward specification and verification. The definition of done is the verification half, made routine.
The Tier 3 lines are my inference from that shift, not an industry standard. The one I'd defend hardest is "a test was seen failing first." A test that has never failed hasn't proven it can. An agent asked to make the tests pass will make the tests pass. That isn't the same as making the code correct.
The scope line matters for a quieter reason. An agent that tidies three nearby files while fixing one bug produces a diff that's harder to review. Hard-to-review diffs get approved anyway.
Who owns the definition of done, and when should it change?
The team that does the work owns it, inside whatever minimum the organization sets. Change it on purpose, at a retrospective, when the same kind of defect escapes twice. Never loosen it quietly mid-sprint to make a date. That is how a standing bar turns into a suggestion.
The Scrum Guide puts it this way, paraphrased: if the organization has a definition of done, every team follows it as a minimum. If it doesn't, the team writes its own. I like that split. The organization sets the floor and the team can raise it.
Put a date on the page. "Last changed" is the cheapest honesty check a team has. A definition of done that hasn't changed in two years either describes a perfect team or describes nobody.
And when the date says you're about to miss a deadline, cut scope, not the bar. Move a story out of the sprint. Don't move "tested" out of done.