"Wasn't this fixed?"
Picture this. The ticket moved to Done on Friday. The pull request was merged, CI was green, everyone moved on.
On Monday the checkout total was wrong.
The test that should have caught it was still there. It just didn't check anything anymore. In the last commit, labelled "fix flaky test", one line had changed:
- expect(total(cart)).toBe(90);
+ expect(total(cart)).toBeDefined();
The old line checked that the total is exactly 90. The new one only checks that there is some total. 0 passes. 900 passes. So CI went green, and Jira said Done.
Nobody lied. A developer in a hurry, or an AI agent told to "make the tests pass", took the shortest road to green. CI can't tell the difference. Green is green.
Proof of Done for Jira can. Before a work item moves to Done, it reads the pull requests behind it and asks the one question CI never asks: do the tests still prove what they proved before? If not, Done is blocked, and Jira shows the exact test that changed, the line, and why it matters.
It works where your team works:
- Jira: blocks Done, shows the evidence, and turns a block into a fix task in one click.
- GitHub and Bitbucket: reads pull requests from both. On Bitbucket, the same check also runs on the pull request itself, before anyone merges.
- Rovo: ask the Proof of Done agent in Rovo chat, "@Proof of Done Is DEMO-2 really done?", and it answers with the file, the line and what to fix.
- AI agents (MCP): any external agent can ask the same question through MCP and get the evidence back.
66 of 66 test shortcuts caught · 0 of 47 honest changes flagged · 0 of 100 real merged pull requests blocked.
Green CI is a result. Trustworthy tests are the evidence.
Demo video
Use it on your own project
- Install on Jira: installation link. Nothing to download.
- Jira settings → Apps → Proof of Done settings. In Repositories add one line per Jira project:
KEY=owner/repofor GitHub, orKEY=bitbucket:workspace/repofor Bitbucket Cloud. KEY is the letters before the number in a work item, like SHOP in SHOP-12. For a private repository, add a read-only token on the same page. - Turn it on for a project, pick your project and press Apply. It shows which transitions into Done get the check before anything changes.
- Put the work item key in the pull request title or branch name, for example
SHOP-12: fix checkout total. Work with no code (a design, a meeting) gets the labelno-codeand goes to Done without a pull request.
Or try the demo first (5 minutes)
- Install on Jira with the installation link above.
- Create a company-managed project with the key DEMO and four work items, DEMO-1 to DEMO-4. Nothing to connect: a project with the key DEMO reads the public demo repository https://github.com/WST2002/proof-of-done-demo.
- Jira settings → Apps → Proof of Done settings → Turn it on for a project → DEMO → Apply.
- Open DEMO-3 and press Create a task to fix this: a sub-task appears with the evidence. Then open the project's Proof of Done dashboard tab.
- Move each work item to Done. DEMO-1 goes through and gets an audit receipt. DEMO-2 is blocked (weakened assertion), DEMO-3 is blocked (skipped test), DEMO-4 is blocked, and its panel's Show test timeline marks the green-after-weakening commit. All four pull requests are merged with green CI. Once a work item's Proof of Done panel has checked it, Done disappears from its transition menu until the problem is fixed, and the panel says why.
Optional extras
- Bitbucket merge check (optional): install the Bitbucket app, turn on custom merge checks in Workspace settings → Custom merge checks, then Repository settings → Custom merge checks → Add → Proof of Done. On a Free workspace Bitbucket shows it as a warning; on Premium it can block the merge.
- Rovo (optional, on a site with Rovo, for example a Forge demo site from
forge site provision): press Ask Rovo, type@Proof, pick Proof of Done, and ask "Is DEMO-2 really done?". Step-by-step guide with a screenshot: https://github.com/WST2002/proof-of-done-jira#in-rovo-chat - MCP (optional): a site admin enables the tools under Atlassian Administration → your site → Connected apps → Proof of Done for Jira → Tools → Enable tools. Or run
npm run mcp-check -- DEMO-4from the repo. Then from any MCP client, for example Claude Code:claude mcp add --transport http proof-of-done https://mcp.atlassian.com/forge/487a9b05-d2bc-4e8f-98ce-2c533e95676f, sign in, and ask "Is DEMO-4 really done?"
What it does
- Blocks Done until every pull request that mentions the work item key is merged, its CI ran and passed, code changes come with test changes, and no test was weakened, skipped or deleted to get green.
- Shows the evidence, not just a red light: the pull request, the file, the line, the assertion before and after, and one sentence on why it is suspicious. Example:
expect(total(cart)).toBe(90)becameexpect(total(cart)).toBeDefined(): "The old line checked one exact value. The new one passes for almost any value, so a wrong result would still go green." - Test timeline: every commit of the pull request with its CI result. It marks the green-after-weakening commit: the exact commit where CI turned green right after the tests were changed to pass.
- Hides Done in the transition menu while the last check failed, so people see why before they try.
- Audit receipt: when a work item does reach Done, it gets a comment with the pull requests, the commit it was checked at, the CI runs and the rules version. An auditor can open it months later and see exactly what was checked.
- AI agent signal: when a pull request's commits credit an AI agent (a co-author trailer or a bot author), it gets a badge and must add at least one new exact assertion.
- Bitbucket too: Jira projects can point at GitHub or Bitbucket Cloud repos, and a second app, Proof of Done for Bitbucket, runs the same tampering rules as a merge check before the pull request is merged.
- Guided setup: on the settings page, pick a project, preview which transitions into Done get the check, press Apply. Nothing changes before Apply.
- MCP tools for AI agents:
check-done,get-test-evidenceandget-test-timeline, so an agent can ask "is POD-32 really done, and if not, why?" - Create a task to fix this: a block becomes the next piece of work. One click creates a sub-task (or a linked Task) with the file, the line, the test before and after, and the pull request link written in, created as the person who pressed it. The same blocked state never makes a duplicate.
- Project dashboard for team leads: a Proof of Done tab in every project shows how many work items are ready, blocked now, caught with tests changed to pass, or let through by an override, the latest catches, and tables with the reason for each block and each override (who, why, when). It searches as the viewer, so Jira's permissions apply. The settings page shows the same counts per project.
- Recorded override: when a block is wrong, a project admin overrides it with a reason. The reason and their name stay on the work item, and a new commit voids the override.
- No-code work (design, research, a meeting) gets the label
no-codeand skips the check. Admins can rename the label.
How accurate is it?
- Benchmark of 113 small diffs, including two held-out sets of 20 written after the rules: catches 66 of 66 shortcuts, with 0 false alarms on 47 honest changes (renaming a test, making an assertion stronger, moving tests to a new file, a timeout doubled for a slow runner, two checks merged into one).
npm run benchmarkprints precision and recall. - All 100 merged pull requests of three of my real repositories: 0 blocked.
- It blocked my own work too: POD-37 (pull request #31 changed code without a test) is still blocked on my board. I left it that way.
- The benchmark lives in the repo, so anyone can rerun it with
npm test.
Bonus: Best app with Atlassian MCP
- The MCP server (
rovo:mcp, endpointhttps://mcp.atlassian.com/forge/487a9b05-d2bc-4e8f-98ce-2c533e95676f) exposes three read-only tools:check-done(is this work item really done, and what is missing),get-test-evidence(every change that makes the tests prove less, with file, line, before and after) andget-test-timeline(each commit, its CI result, and the commit where CI turned green after the tests were changed). - Tested with a real external client: OAuth 2.1 with PKCE, all three tools called on live work items; an unknown key gets a plain "not found". Each answer uses the signed-in person's Jira permissions. Shown in the demo video at 2:54.
- Open-source skill file:
skills/proof-of-done-mcp/SKILL.mdtells an agent when to call each tool and how to answer: verdict first, evidence quoted, never "done" unlesscheck-donesays so. - The same tools power the Rovo agent inside Jira, tested on a Forge demo site with Rovo (five questions, five correct answers); shown in the demo video at 3:19.
Inspiration
I maintain an open-source Claude Code plugin called proof-of-done. It stops an AI agent from saying "done" before the tests really ran and passed. While building it I kept seeing one trick over and over: CI goes green because a test was skipped, deleted, or an exact assertion was swapped for a weaker one. In review each of these looks like a one-line tidy-up, so nobody stops it.
Jira has the same gap. A work item goes to Done because someone dragged the card. Merge checks and "CI must pass" rules exist, but none of them ask whether the tests still prove what they proved yesterday. So I took the rules from my plugin and put them where a team decides what done means: the Done transition, and the merge button.
Imagine a team of 50 shipping with AI agents. A checkout ticket goes to Done on Friday: pull request merged, CI green. On Monday the totals are wrong in production. The test that would have caught it was changed from toBe(90) to toBeDefined() in the last commit, labelled "fix flaky test". Nobody lied and nobody looked. That is the moment Proof of Done is built for.
How I built it
- Forge modules:
jira:workflowValidator,jira:workflowCondition, a trigger on issue updates for the receipt,jira:issuePanelandjira:issueContextin UI Kit,jira:projectPage(the dashboard, with a UI Kit chart and tables),jira:adminPage, arovo:agentand arovo:mcpserver that share three actions, andbitbucket:mergeCheckin the Bitbucket app. Settings, tokens (encrypted) and admin overrides live in Forge app storage, so a work item's properties cannot fake an override. - The check reads the linked pull requests from the GitHub or Bitbucket API: merge state, CI results, the diff and the commits. A pull request is linked when its title or branch name contains the key.
- The tampering rules cover Jest, node:assert, pytest, unittest, JUnit and Go: skips and focus, deleted tests, weakened assertions, always-true assertions, suppression comments, lowered coverage thresholds, test timeouts doubled or more, and added retries. One rule file is shared by both apps.
- 103 tests, many against real GitHub pull requests rather than mocks, plus a benchmark. CI runs both on every pull request.
- The project's own work was tracked in a Jira project on my site, and the app checked its own pull requests.
Challenges I ran into
- A wrong block costs more trust than a miss. So every rule is checked against honest changes that look almost the same: the word "eslint-disable" inside a test name, an
assert.oknext to an unrelated removed assertion, a runtime skip with a reason liket.skip("no clipboard tool on this machine"). Each is a benchmark case that must pass. - Receipts on every workflow: the receipt comes from an issue-updated trigger that reacts only to a move into a Done status, so it needs no post function in the workflow.
- GitHub search ignores branch names, so pull requests are matched by title through search and by branch name through the recent pull request list.
- Rate limits: GitHub allows 60 anonymous requests an hour per IP and Forge IPs are shared. The app makes fewer calls, explains the limit in plain words, and falls back to anonymous reads if a saved token expires.
Accomplishments that I'm proud of
- Every scenario tested live on a real Jira site with a 14-step regression: no pull request, code without tests, weakened assertion, deleted test, hidden lint error, key only in the branch, similar keys (POD-1 vs POD-10), an honest pull request that goes through, and no-code work.
- The timeline demo: in DEMO-4, commit de16349 fails CI, commit a03b524 loosens
assert.equaltoassert.ok, CI passes, and Jira points at that exact commit.
What I learned
"Is this really done" is easy to get wrong in both directions. A check that blocks honest work gets switched off in a week, so most of the effort went into the honest side of the benchmark.
What's next
- GitLab.
- Per-project rules (for example docs-only work items without a pull request).
- More test frameworks in the rules (RSpec, PHPUnit).