Inspiration
Teams write decisions and requirements in Confluence and then build in Jira. Those two records drift apart without anyone noticing. A ticket asks for five payment retries when the team capped retries at three. Nobody is careless: the person writing the ticket simply was not in the room, or the decision sits three links away.
The cost appears late, in review, in testing or after release, when the work is already done. Decision tools help a team make the decision. I wanted something that makes sure the work keeps it.
Trust was the second motivation. An AI that says "this looks wrong" is easy to ignore. So every finding had to bring its evidence: what the ticket says, what the team decided, how the two are connected, and why they disagree.
What it does
Precedent checks a Jira work item against the Confluence decisions and specifications that govern it.
On any work item, a panel shows a status on its collapsed header. Open it and Precedent returns one of three results: Conflict, Aligned, or No verdict when nothing clearly applies. It is not tuned to find problems.
Every finding shows four things:
- Sources: links to the page and the work item.
- Connection: the path between them, for example
CHK-4 → in epic CHK-2 → links to Checkout platform decisions. - Reasoning: quotes from both sides and a short explanation, labelled as a model judgement.
- Action: add a cited comment or link the governing page.
Code checks the quotes. Both quotes must appear in their sources, ignoring case and spacing, or the finding is thrown away. This proves the text exists. It does not prove the verdict is right, which is why verdicts are labelled as judgements.
Writes need a confirmed preview. In the panel, Precedent previews the exact text and warns who will be able to read it, and writes only after that same user confirms. In Rovo, confirmation also relies on Rovo's own review card and on the agent following its instructions.
Sprint triage checks up to 30 open work items, conflicts first, each beside the decision it contradicts.
The Precedent Rovo agent checks one item or a whole project, using reusable actions and a skill.
MCP tools let external coding agents check a ticket before building it. They can read and draft. The action that applies a change is not exposed over MCP.
A demo scenario loads labelled sample data in about a minute, and a built in evaluation lets administrators rerun the test set.
How I built it
Precedent is a Forge app on the Node 22 runtime with a UI Kit front end.
| Forge module | Use |
|---|---|
jira:issueContext |
Panel on each work item, with a dynamic status on the collapsed header |
jira:projectPage |
Sprint triage, setup, demo loader, evaluation |
rovo:agent, action, rovo:skill |
The agent, its reusable actions and the "check before you build" skill |
rovo:mcp |
The same actions exposed as MCP tools, except the write action |
llm |
Forge LLMs with Claude family models, so model calls stay on Atlassian's platform |
| Forge KVS | Cache, budgets, confirmation tokens and audit, all with expiry |
The pipeline has five stages:
- Retrieve the governing pages through remote links, description mentions, the parent epic, project spaces and search. Comments are excluded, so a commenter cannot pull a restricted page into a check.
- Extract commitments deterministically from Confluence's document format: native decision items, requirement headings and normative sentences.
- Rank them lexically and keep the top 12.
- Check them with a forced tool call. Source text is wrapped as untrusted data.
- Verify in code: quotes must match, undecided items cannot be a conflict, only decisions can be reopened, and "aligned" needs high confidence.
Every read and write runs as the signed in user. Confirmation tokens are bound to the user, expire in 10 minutes and can be used once under an atomic lock. Each site and each user has a daily AI budget. Over budget, the app still shows the governing sources, marked "not checked".
I built this solo with Claude Code as an AI pair programmer. The 48 evaluation pairs were written by a separate AI agent that was instructed not to read the prompt or code.
Challenges
- Time limits. Forge limits UI functions to 25 seconds, and my first evaluation run died on that limit. Sprint triage and the evaluation now run in short, resumable slices as the user.
- Rovo action identity. The handler lookup I first used returned nothing for Rovo actions. The fix was reading
context.principal.accountId, and giving each action its own function. - Remote links that vanish. Jira hid links created with the Confluence application type. Plain web links with a stable
globalIdwork and are idempotent. - Duplicate comments. Two separate previews could post the same comment. Each finding now has its own marker, checked before posting.
- MCP refusing after install. The endpoint said the app could not expose its tools. The cause was a separate Tools toggle on the Confluence installation, as well as the Jira one. The install steps now say so.
- A write path for agents. I removed the confirm action from MCP after a security review, because an external agent should not be able to approve its own change.
Accomplishments
- One engine across four surfaces: issue panel, sprint triage, Rovo agent and MCP.
- The deployed checker found all 22 conflicts in each of four evaluation runs, two of them on the shipped prompt, with no false alarms, on 48 labelled pairs. This is a small test set, and every miss is published.
- All 9 demo stories received the verdict their scenario expects, through the real retrieval pipeline. I wrote those labels myself.
- Installed from the share link on a second site with its own demo data and confirmed working there, using the same account.
- No external network destinations, so the app stays on Atlassian's infrastructure.
What I learned
- Verifying quotes in code is cheap and removes a whole class of failure, but it proves less than it seems to. The honest label matters as much as the check.
- "Conflict" and "reopens" are not a stable boundary, even for a strong model. Treating them as one signal to the user was the better product decision.
- A "no verdict" result is a feature to design for, because a tool that always finds something cannot be believed when it does.
- On Forge, permissions and identity shape the design from the first day.
What's next
- Test with real teams on messy, long pages, and measure whether conflicts are caught earlier. No real team has used Precedent yet.
- A larger evaluation set reviewed by people.
- Check a work item automatically when it is created or changes.
- Teamwork Graph as a further retrieval route, once it is generally available.
Built With
- atlassian-forge
- confluence
- forge-llms
- forge-storage
- forge-ui-kit
- jira
- mcp
- node.js
- react
- rovo
- typescript
- vitest