Article summary
- Give It Every Piece of Context
- Agree on the Work Before Writing Stories
- Epics First, Then Stories Anyone Can Read
- Review Every Story Before It Lands
- Build the Foundation While Design Catches Up
- Plan Sharp Up Close, Rough Further Out
- When the Concept Is Still Forming
- What Makes a Concept Ready for the Agent
Every product team has the same gap. On one side is a concept: a product brief, a roadmap item, a feature someone sketched in a meeting. On the other is a backlog a developer can pick up and build. Closing that gap is usually slow, manual work. In digital health, it also has to be careful work: a vague story can turn into a bug in software a clinician uses with a patient, and the plan has to make sense to clinical and compliance stakeholders who don’t read code.
You could hand a coding agent a product brief, ask for stories, and get some back. Out of the box, though, it tends to write the whole backlog in one pass, guess at file paths that look right, fill descriptions with code details, and invent specifics for screens nobody has designed yet.
So I built an AI skill (a reusable set of instructions that a coding agent like Claude Code follows) that turns that one-shot request into a process. The agent works in phases and waits for my corrections after each one, checks every claim against the actual code, keeps descriptions readable for people who don’t code, and marks work that depends on unfinished designs as a placeholder instead of guessing. The rest of this post walks through how it works. I’ve used the skill on three projects, and on one of them (an app clinicians use with a patient to calibrate a prosthetic arm) it planned six weeks of work.
Give It Every Piece of Context
The agent starts by asking for everything that has been written about the concept. At a consultancy like mine, that’s the output of the sales process: the proposal that says what we agreed to build, the timeline, and any estimates. On a product team, it’s whatever your product manager has produced: the brief or requirements, what stakeholders have signed off on, the target timeline, and a wishlist of things that would be nice to have. It also asks where the designs live, whether that’s a folder of images or a Figma file it can read directly.
If there’s existing code, I point the agent at it too. That tells it what’s already built and where new work fits easily. It also shows where we’d have to rework large parts of the app, which makes a story much heavier than it looks on paper. Knowing that up front keeps the estimates honest, because the agent plans each story against the code it actually has to fit into.
Agree on the Work Before Writing Stories
The first thing the agent produces is a short summary in chat of how it understands the work. It separates what’s committed from what’s on the wishlist, names the big chunks of work it sees, and flags gaps like items where the best-case and likely estimates are far apart (a sign nobody really knows how big they are yet) or tasks nobody clearly owns. It also lists the assumptions it’s making so I can correct them before they get baked into thirty stories.
This step is cheap, and it catches the most expensive mistakes. If the agent thinks a feature is in scope when it’s really a wishlist item, I’d rather find out from one paragraph than from a fully written epic. The skill won’t move on until I accept that summary, and it doesn’t write anything to a file in this phase.
Epics First, Then Stories Anyone Can Read
Once the summary is right, the agent proposes an outline: epics, each with one-line stubs for its stories. The goal is clear chunks of work that can go on a timeline and get an estimate, so the epics don’t map one-to-one to the brief. A big priority might split into two epics, and two similar ones might merge into one. There’s a lot of judgment in that step, and I stay in the loop for it. I’ll tell it to merge two stories, split one into a separate story for each repository it touches, or drop an epic that’s already being handled elsewhere, and it reprints the whole outline after every correction so I can see where things stand.
Then the agent and I go epic by epic and story by story. Each story has the same sections:
- Description: a plain-language overview of what someone will be able to do that they can’t today, and why it’s worth doing.
- Acceptance criteria: observable behavior a reviewer can check without reading the diff.
- Technical details: the specific files, types, tests, and gotchas the developer needs.
- Not in scope: what this story deliberately leaves out, with a pointer to the story that covers it.
- Related stories: what this one depends on, blocks, or runs alongside.
Without a clear rule, the agent fills the description with file paths, function names, and framework details that a product manager, clinical advisor, or other non-technical stakeholder doesn’t want to wade through. So the skill tells it to write the description for someone who will never open the code: what changes for the people using the product, and why it matters. Every file path, type name, and framework detail goes in the technical details below it. The result is close to a spec that non-developers can still read.
Review Every Story Before It Lands
Coding agents will confidently describe code they haven’t read. In a backlog that’s worse than useless, because a developer will trust a story that says “the calibration screen already handles this” and build on top of it. So the skill has a standing rule: read the code before you write about it. Before a story makes any claim about how the app works today, the agent reads the relevant files or runs the tests to confirm it.
Each story is drafted in chat first, and nothing gets written to a file until I approve it. Corrections happen on the cheap chat draft, not on a committed document. Every few stories, or whenever stories get renumbered or the plan pivots, the agent suggests a coherence review to make sure the stories still fit together and the cross-references still point at the right places. Stories also carry an escalation rule: if the developer working on a story turns up a real bug, they should document it and raise it for triage instead of changing a failing test to match broken behavior. When you’re working on software that changes the settings on a patient’s prosthesis, that rule isn’t optional.
I often refine the stories on my own, but this also works well as a group exercise with a product manager and designer around one monitor, so everyone agrees on what each story means. Either way, approved stories land in a markdown file per epic, and the agent pushes them into the team’s issue tracker (I’ve done this with both Jira and Azure DevOps) so the board and the local files stay in sync.
Build the Foundation While Design Catches Up
The agent orders the work so anything that doesn’t need design comes first. On the prosthetic app, our designer spent the first weeks redesigning the screens. Meanwhile, I upgraded the app to a current version of Expo, repaired a test suite that had drifted out of date, turned on strict type checking, cleared every compiler and linter error, and set up CI with a coverage gate. None of that depended on what the screens would look like. By the time the designs were ready, the systems underneath could support them, and layering on the new interface was easy.
In a medical device app, the tests show what the app actually does, and together with strict types and CI, they catch a change that breaks something before it ships. You want that safety net in place before anyone touches the screens a clinician uses with a patient.
Plan Sharp Up Close, Rough Further Out
The first two weeks get planned story by story, in full detail. The next two are planned more loosely. After that, stories get progressively foggier. Where a story depends on a design that doesn’t exist yet, the agent writes a placeholder with the intent, the expected scope, and its dependencies. A placeholder like that is more useful than a missing story and more honest than a confident one built on guesses. When the real design lands, I feed it in and the placeholder becomes a full story.
The backlog is never finished. As code changes, designs come in, and priorities shift, I point the agent back at the backlog to update the stories so they match reality. I use a companion skill for that. Its job is to revise stories in place while holding the numbering, structure, and cross-references steady, so the tracker doesn’t turn into a pile of orphaned tickets every time the plan moves.
That upkeep is usually a big part of a delivery lead’s or product manager’s job. On the first of those three projects, our delivery lead spent a lot of time early on shaping the timeline with me. Once the backlog was well defined and the agent was keeping it current, she could step back and the team kept moving. On the prosthetic app, we didn’t have a delivery lead at all. It was just me and our designer, and the backlog held up.
When the Concept Is Still Forming
The skill works best when the concept is well defined. The prosthetic app had a clear goal: make the research app easier to use and better looking, keep its current features, and add a few updates. It didn’t need to be a commercial digital health product hooked up to a server that manages every device. That gave the agent solid ground to plan on.
Not every concept is that well defined. On the most recent of those three projects, a tool for biomedical researchers, the client came in with five large priorities for a three-week engagement with a designer and two developers. They ranged from scaling the frontend to handle an order of magnitude more data to a new saving and sharing system that showed the full history of every change. Without a clear vision for the digital health product, they wanted all five at once, with no order for which to tackle first. I ran the same process, and it produced far more work than three weeks could hold.
I also leaned on my usual habit of laying a foundation first. We spent the first week setting up CI on GitHub, fixing lint errors, updating vulnerable dependencies, and starting on the client’s end-to-end testing priority, writing tests for code we were rebuilding at the same time. The tests kept changing under us, and we had little to show at the end of that week. The other four priorities got crammed into the last two. That taught me the skill can’t make up for unclear priorities, and my foundation-first habit can work against me when the concept is still forming. A few things help.
Push for fewer priorities.
Before the agent breaks anything into stories, ask your product manager to pick the one or two goals that matter most right now. The agent will happily plan all five, and that plan will be wrong.
Ship visible work sooner.
Foundation work pays off, but stakeholders exploring new directions need to see progress early. Ask your product manager which part of the concept is defined enough to build now, put something stakeholders can click on in the first week, and keep the foundation work to what that first feature needs. If nothing is defined yet, spend the first days only on foundation work that doesn’t depend on any decision, like dependency updates and tests around code you’re sure will stay.
Keep a decision-maker close.
When priorities are moving, someone needs to refine them with stakeholders and agree on a timeline. The agent can keep the backlog current, but it can’t make those calls. On that project, our designer stepped up to do it.
What Makes a Concept Ready for the Agent
If you’re planning a digital health product with AI, you’ll get a better backlog when you start with clear priorities for the first two weeks, access to the existing code, and someone who can make decisions as the plan changes.
The agent does the tedious part: reading every document, checking the code, and keeping dozens of stories consistent with each other. You still make the judgment calls about what’s in scope, how the work splits up, and what matters most this week. The plain-language descriptions pay off in a regulated product, too. Clinical, compliance, and business stakeholders can see what’s planned and why without reading code.
I’ve shared both skills, the one that builds the backlog and the companion that keeps it current, so you can try this on your own product. Give the agent everything you have, stay in the loop at every phase, and keep pointing it back at the backlog as the work changes.