Craft
From PRD to Tickets: Breaking a Spec Into Issues
Tickets should link to requirements, not restate them. How to break a PRD into issues and user stories without creating a second source of truth that drifts.
The usual way a PRD becomes tickets is by copying. Whoever does the breakdown pastes a requirement into each issue, perhaps rewrites it as a user story, and adds the acceptance criteria underneath. It feels thorough. It also creates a second copy of every requirement, in the place where engineers actually work.
The first amendment breaks it. The spec gets updated; the tickets do not. Now there are two versions of the requirement, and the one people build from is the one closer to the work.
The rule that prevents this comes from where a PRD should live: one canonical location, linked from everywhere else. In a tracker, that means tickets link to requirements; they do not restate them. The rest of this post is how to make that practical, because a ticket that says only "see PRD" is not much better than a copy.
What a ticket should carry
A ticket is not a smaller spec. It is a unit of work with a pointer to the spec. Five things belong in it:
The job, as a verb phrase. "Let an admin schedule a weekly export", not "Export scheduling". Someone scanning the board should know what the work is.
A link to the requirement, at section level. Not to the top of the document. A link to the exact section is what makes the ticket useful in five seconds and keeps it correct when the spec moves.
The slice boundary. What this ticket covers and, as importantly, what it does not, with the tickets that cover the rest. This is the ticket's own decision, so it belongs in the ticket.
Done when. The acceptance criteria it must pass, cited by ID rather than pasted. "R3.1 to R3.4 pass as written in the spec."
Engineering notes. Implementation detail, design doc references, known traps. This is engineering's content, and the ticket is its natural home.
An illustration:
EXP-14 · Let an admin create and edit a weekly export schedule
Spec: Scheduled exports, §3 (R3.1 to R3.4), linked to the section
Covers: creating, editing and pausing a schedule
Not this: delivery email (EXP-15), link expiry (EXP-16)
Done when: R3.1 to R3.4 pass as written in the spec
Eng notes: reuse the existing job queue; design doc §2
Nothing in that ticket goes stale when the spec changes the schedule options, because none of the options are written in it.
Give requirements stable IDs
Linking at section level needs something to link to. The cheapest version is an ID per requirement, R3.1, R3.2 and so on, written in the spec and never renumbered. If a requirement is removed, its ID is retired, not reused.
IDs make three things possible. A ticket can cite exactly what it implements. A test case can cite exactly what it checks. An amendment can list exactly which tickets it affects. Without them every reference is a paraphrase, and paraphrase drifts.
Breaking the spec down
Walk the requirements in order and give each one a home. Three rules make the breakdown hold.
Every requirement has at least one ticket, and every ticket cites a requirement. Or it is labelled as engineering work with no product requirement behind it. With IDs, that is a coverage check you can run by eye.
States get explicit homes. The breakdown is where edge cases and error states disappear. The ticket says "build the export button"; the empty state, the failure behaviour and the permission rule are in the spec and in nobody's ticket. Either they get tickets of their own, or they are named in the "done when" of the ticket that owns them.
Slice by behaviour, not by document section. One section can produce three tickets, and one ticket can span two sections. What matters is that each ticket is something a reviewer can check against the spec on its own, using criteria that are testable as written.
Where user stories fit
If your tracker runs on user stories, the rule still works. The story line, who wants what and why, makes a good ticket title. But a story was always meant as a placeholder for a conversation, and the decisions from that conversation are what the PRD holds.
What goes wrong is writing the PRD as a list of stories and letting the acceptance criteria live in the tickets. The criteria end up scattered across twenty issues, nobody can read the whole set at once, and the spec turns into a table of contents for work items. Keep the criteria in the spec, where they can be reviewed together, and let each story cite the ones it satisfies.
When the spec changes
This is where linking pays for itself. An amendment goes into the spec with a change block that lists the tickets it affects. Each affected ticket gets a one-line comment linking to that entry. The ticket text itself changes only if its own slice boundary moved.
Compare the copying version. Someone has to find every ticket that restated the old requirement, rewrite each one, and hope they found them all. They will not have found them all.
The exception: a copy that re-syncs
The rule above is about copies nobody maintains, which is nearly all of them. Maintaining one by hand means remembering, in the middle of an amendment, every ticket that restated the thing you just changed.
Automation changes that, under one condition: the tool has to know which ticket came from which story or requirement, and sending again has to update those tickets rather than open a second set. Then the requirement text in the ticket is not a snapshot, it is a cache, and the amendment arrives the same day you write it.
What does not change is the direction of authority. The spec is still where a requirement is decided and reviewed, and the ticket holds a rendering of it. If someone edits the requirement text in the tracker and that edit survives the next send, you are back to two sources of truth with extra steps.
So the practical rule has two halves. Without that kind of tooling, link and never restate. With it, restate freely, and never hand-edit the restatement.
Jira, Linear, whatever you use
The mechanics are the same in any tracker, because they need nothing more than a link in a field or the first line of a description. A few habits help regardless of tool:
Put the spec link first. Above the engineering notes, where it is the first thing someone opening the ticket sees.
Link the spec to its tickets too. A short list under each section, or a link to a filtered board view, so that someone reading the spec can see what is built, in progress, or not started.
Move documents, not fragments. If a tool moves the spec into your tracker's document space, that copy can become the canonical one, provided the old one is marked as moved. What to avoid is requirement text duplicated into individual tickets and then left alone, whether a person or a tool put it there.
Ticket status is not spec status. A closed ticket says the work is done. Whether the spec is still current is a separate question, answered on the spec's first line.
The test
Pick a ticket at random from the current sprint. Change, in the spec, one requirement it implements. Then ask: does the ticket now say anything false?
If not, the ticket links. If it does, the ticket restates, and every restated ticket in the sprint is a place where the next amendment will quietly fail to arrive.
FAQ
How do you turn a PRD into Jira or Linear issues? One ticket per slice, each linking to its requirements by section and ID instead of restating them.
Should user stories replace the PRD? No. Use the story as the title and keep the criteria in the spec.
Why not copy the requirement into the ticket? A copy nobody maintains goes stale at the first amendment, and it is the copy people build from. A copy that a tool re-syncs on every send is fine.
How do you make sure no requirement is missed in the breakdown? Stable IDs, a coverage check in both directions, and explicit homes for states.