Half Your PRs Link to Nothing. Your Roadmap Is a Vibe.

TL;DR: The work lives in git. The plan lives in Jira or Linear. In most orgs, nothing joins them, and "half" is a hypothesis your own repo will happily test: pull your merged PRs from the last quarter and count how many carry a ticket key. Every question that depends on that join - what did we ship for the initiative? how much of our capacity went to new product vs keeping the lights on? - is currently answered by a person doing archaeology, or by a vibe. The fix is one measured number (your linkage rate) and one cheap convention (the key in the branch name); the investment split falls out as a fact.

The question arrives in the QBR, and it isn't even a hard one: "What did we actually ship for the payments initiative last quarter?"

Watch what happens next. Someone opens the tracker: a third of the epic's tickets say Done, a third say In Progress since forever, and everyone in the room privately knows the board and reality parted ways months ago. Someone else opens GitHub: four hundred merged PRs last quarter, titled things like fix the thing properly this time. Both windows are true. Neither answers the question, because the answer lives in the join, and the join doesn't exist. So a TPM spends three days after the meeting reconstructing it by hand, interviewing engineers about what refactor-v2-final was for, and the deck ships a week late with numbers nobody would defend under oath.

That's the quiet tax of unlinked work. Not drama - archaeology, every quarter, forever.

The work is in git. The story is in the tracker. Nothing joins them.

This isn't a your-org problem; it's the industry default. Rath et al. studied six open-source projects and found that on average only 60% of commits were linked to specific issues: four in ten changes with no thread back to any stated intent.

And the damage isn't limited to the unlinked share, because the linked subset isn't a fair sample. Bird et al. showed that which bug fixes get linked is systematically biased, so any analysis built only on linked work quietly inherits that bias. Translation for your org: the half of the work you can trace is not a miniature of the whole, and every report built on it is skewed in ways nobody in the room can see.

Here's what that costs, concretely:

• Roadmap reporting becomes a person. Somewhere in your org, initiative reporting has a human in the loop whose actual job is joining two databases with their memory. They're expensive, slow, and wrong in untrackable ways. And when the CEO asks what's landing this quarter, their reconstruction is the load-bearing artifact.
• The investment question gets a vibe. "How much of engineering went to new product versus keeping the lights on?" is a question your board is entitled to ask and your biggest line item should be able to answer. Without linkage, the answer is whatever the loudest team lead remembers feeling. With linkage, it's arithmetic, and the KTLO-vs-new balance becomes something you can manage instead of debate. A feature factory hides beautifully in an org that can't compute this split.
• The capitalization audit trail doesn't exist. If finance capitalizes development work, the auditor's first question is which work was which, and under both US GAAP and IFRS that requires records rather than recollections. Guidance like ASU 2025-06 modernizes what qualifies; it does nothing for an org that can't say which PRs served which workstream. The CapEx-vs-OpEx conversation is only as good as the join underneath it.
• Every delivery metric gets weaker. Cycle time, throughput, the whole delivery scoreboard: all of it gains meaning when work connects to intent. The SPACE framework's core warning is that single, context-free measures mislead; unlinked work is the extreme case, activity with the context amputated.

Notice what this is not: it's not an engineer-discipline problem. Nobody omits a ticket key out of malice. The link simply costs three seconds of remembering at the exact moment someone's head is full of the actual work, and nothing in the toolchain catches the miss. It's a missing default in the system, chronically misread as a people problem.

The free cure: one number, one convention

1. Compute your linkage rate today. Merged PRs, last 90 days. Count how many carry a ticket key: a KEY-123 pattern in the branch name or PR title is the join your tooling can actually make. Divide. That's your number; the title's "half" is a hypothesis for your data to confirm, beat, or embarrass. All three outcomes are useful, and the number is computable in an afternoon with your git host's API.
2. Read the unlinked remainder before judging it. Sort the unlinked PRs by size. Some are legitimately un-ticketed trivia. Some are entire features that lived only in a Slack thread. The mix tells you whether you have a hygiene gap or a shadow roadmap, and those have different fixes.

Make linking cheap: link PRs to Jira tickets automatically

3. Put the key where the tooling reads it. The convention that works is structural, not motivational: create branches from the ticket (Jira and Linear both generate branch names carrying the key), so linkage happens before anyone has to remember anything. Back it with a PR-template line and a soft CI check that comments - never blocks - when no key is found.
4. Refuse the hard gate. A required-ticket policy without cheap tooling produces junk tickets, misc dumping grounds, and a linkage rate that's high and meaningless. The honest number should rise because linking got easier.
5. Then cash the cheque: read your investment split. Once most merged work joins to a ticket, "what did we ship for the initiative" becomes a query, and the strategic split (new product vs improvements vs keeping the lights on vs unplanned firefighting) becomes a fact with receipts. That's the artifact that upgrades your executive reporting from narrative to evidence.

How you'd actually see this in Busfactor

The afternoon of counting is exactly the ritual that happens once and dies. Busfactor computes the linkage rate continuously: linked merged PRs over merged PRs across a rolling window, matching the ticket key in the branch name first, then the PR title, including keys that changed when an issue moved between teams. That last part is precisely the detail a hand-rolled script misses. When the signal can't support the number, it says unobservable, never a fake zero: no tracker connected means no rate.

Traceability is also a governance control with receipts: the exact PRs that merged without a linked ticket, listed and linkable, so the conversation starts from evidence instead of a percentage in the air. The door comes attached - adopt a branch naming rule that carries the key.

Downstream is where it pays. The investment allocation view classifies every merged PR by a disclosed precedence: the linked ticket's type first, then conventional-commit title prefixes, then narrow, named heuristics. Whatever can't be classified is shown honestly as unclassified, never guessed. The split rolls up into New, Improvements, KTLO, and Unplanned, each judged against a healthy range; it slices by org, team, and person; hours become money through your cost model in your currency; and the finance export carries provenance (run id, ruleset version, content hash), so the CapEx package is audit-grade rather than take-my-word-for-it. One ticket's whole journey - board, code, review, deploy - is drawn as a single swimlane when you need the receipt for one specific "what happened here."

The honest limits: the linkage engine reads branch names and titles, so a PR genuinely tied to planned work that never carried the key counts as unlinked. The metric measures traceability, and your first weeks of data will partly reflect naming habits rather than planning discipline. It also can't tell you whether the linked ticket was worth doing; linkage makes the "what did we ship" question answerable, and leaves "should we have" where it belongs: with you.

The door

Run the count this week: 90 days of merged PRs, one regex, one division. The number will tell you something true about every roadmap report you've shipped this year. Then make linking structural instead of virtuous, and watch the QBR question turn from a three-day archaeology dig into a link someone pastes in ten seconds. If you'd rather the join maintain itself (rate watched, breaches receipted, the investment split standing ready for the board deck), get your org's free read: one connection, and the archaeology retires.