PRD to User Stories: AI-DLC Inception with Quick Desktop
A custom PRD skill in Quick Desktop turns one sentence into personas, scope, and metrics. Inception Stories reads that PRD to generate traceable user stories
From Idea to PRD to Execution-Ready Stories
Every product idea starts out deceptively simple. “Build a personal task manager with recurring tasks and daily focus mode.” That sounds clear enough, until you try to turn it into a real PRD (Product Requirements Document).
Who exactly is this for? What problem are we solving first? What is in scope? What is explicitly out of scope? How will we know if the feature worked?
This is the messy middle between a promising idea and a team-ready product plan.
In previous post (From Vague Idea to Testable User Stories in Minutes: AI-DLC Inception in Amazon Quick Desktop ), I showed how AI-DLC Inception in Amazon Quick Desktop can turn a vague feature idea into structured, testable user stories and development units. In this post, I’m adding the upstream step: a PRD skill.
Now the flow becomes: One sentence → PRD → User Stories → Units.
One conversation. Three approval gates. A fully traceable path from intent to execution.
To make that flow work, the tool needs to do more than generate text. It needs to understand context, work with files, and preserve decisions across the lifecycle.
Why Amazon Quick Desktop
Quick Desktop is where PMs already work: on their laptop, across their tools, in the middle of their day. Here is how its capabilities map to the PRD workflow:
Connect to your existing tools. The feature idea didn't come from nowhere. It came from a Slack thread where a user complained about forgetting recurring tasks, an email from your manager about focus time, a spreadsheet of competitor features. Quick connects to Slack, Outlook, Gmail, Salesforce, and local files. When the PRD skill asks you to confirm personas or scope, you can point it at the source material and it pulls the context in.
Remember your projects and people. Run the PRD skill today, come back next week to run Stories. Quick remembers the project, the decisions you made, the stakeholders you mentioned. No re-explaining context between sessions.
Work with any file on your machine. The PRD skill reads existing docs you point it at (competitor analyses, prior PRDs, design briefs) and writes its output directly to your filesystem. You choose where the folder lives.
Produce real deliverables, not chat responses. The output is
prd.md, user_stories.md, units_plan.md on disk. Version-controllable. Reviewable in PRs. Ready to hand to engineering.Custom skills turn any workflow into a command. The PRD skill is a SKILL.md file with structured instructions and 4 tool bindings (Folder Create, File Write, File Edit, File Read). You trigger it by saying "create a prd for [feature]." Building your own skill for sprint planning, stakeholder updates, or competitive analysis follows the same pattern.
Amazon Quick Desktop is available for macOS and Windows.
What We’re Building in Part 2
In Part 2, I added a PRD skill that sits upstream of Inception Stories. It takes a single sentence of intent and turns it into a stakeholder-facing Product Requirements Document with personas, scope boundaries, and success metrics.
Inception Stories then reads that PRD and uses it as generation context, so the user stories are no longer created from a vague idea alone. They are grounded in the product intent, audience, constraints, and measurable outcomes captured in the PRD.
The result is a complete pipeline:
1
2
3
4
5
6
7
"Build a personal task manager with recurring tasks and daily focus mode"
↓
[] → prd.md
↓
[] → user_stories.md
↓
[] → units/Each skill runs independently. Each produces a file. Each approval gate is human-controlled. The composition happens through the file system.
This is important because it keeps the workflow modular. You can run the PRD skill when you need product alignment, run Stories when you are ready for requirements, and run Units when engineering needs parallelizable work. Each step creates a durable artifact that the next step can trust.
How the PRD feeds Inception
When the PRD skill completes, it hands off the
prd_path to Inception Stories. Stories reads the file and extracts three things: personas, scope, and success metrics. Here is what flows through on the task manager use case:PRD defines a persona:
Busy Professional — Juggles 20+ tasks across work and personal life. Forgets recurring tasks. Overwhelmed by long lists with no clear priority for today.
Stories uses it to determine which stories to write, with a role-based actor:
US-1.1: As a user, I can mark a task as recurring with a custom frequency so that it automatically reappears on my list without manual re-entry.
PRD sets a success metric:
Daily planning time: User can identify their top 3 focus tasks for the day in < 30 seconds.
Stories turns it into non-functional acceptance criteria:
Focus mode view loads within 1 second. Task list renders up to 200 tasks without scroll lag. Recurring task generation completes before the user opens the app each morning.
PRD draws a scope boundary:
Out of scope: Team collaboration, shared task lists, calendar sync.
Stories respects it:
No stories generated for multi-user features, sharing, or calendar integration.
Personas inform which stories get written. Metrics become acceptance criteria. Out-of-scope items constrain what stories are not generated.
Skills in action
Let’s see the skills in action.
aidlc-inception-prd skill loading, confirming project name/folder, and asking where to save the output (kickoff step).
PRD plan presented with step-by-step checklist and [Needs Confirmation] gates for personas & scope, awaiting user input before execution.
User answers the open questions ("all general personas, web for now"), plan updated, approval gate shown to execute the PRD.
PRD plan approved, now executing - writing the full prd.md and marking all plan steps complete.
Completed PRD shown with summary (personas, scope, metrics), approval gate to hand off to the next phase (user stories).
PRD approved,
aidlc-inception-stories skill loads, reads prd.md for context, and begins writing the stories plan.
Stories plan presented (7 epics derived from PRD scope), with the plan document open in session tab, awaiting approval to generate user_stories.md.
In short: it's the full PRD → Stories handoff flow - the PRD skill plans, asks, executes, then the stories skill picks up where the PRD left off.
The output folder
1
2
3
4
5
6
7
8
9
10
aidlc_task_manager_20260601/inception/
prd_plan.md
prd.md
stories_plan.md
user_stories.md
units_plan.md
units/
unit_1_task_crud.md
unit_2_recurring.md
unit_3_focus_mode.mdOne folder. Fully version-controllable. Every artifact traces back to the original intent.
Why composition, not a single skill
- PRD runs standalone. Not every project needs stories yet. Sometimes you need alignment first.
- Stories runs standalone.
prd_pathis an optional parameter. Without it, Stories works exactly as before. - The file is the interface. Skills compose through the file system. No coupling, no orchestration layer, no dependencies between skill definitions.
Why This Matters
PRDs often fail for the same reason user stories fail: they leave too much room for interpretation. A persona is mentioned once but never reflected in the stories. A success metric is written in the PRD but never becomes an acceptance criterion. An out-of-scope item is agreed verbally but quietly sneaks back into the backlog.
This workflow closes those gaps. The PRD becomes the source of truth, and the downstream artifacts stay traceable to it.
Design principles
- AI proposes, human approves. Three gates: PRD approval, stories approval, units approval.
- Structured output. Every file follows a defined format. Stories are consistent. Criteria are testable. Units have clear boundaries.
- Composable. Each skill is independent. Add more upstream or downstream without changing existing skills.
- Tool-agnostic downstream. Feed the output into Kiro, Cursor, Claude Code, a human team, or any AI coding agent.
Conclusion
The pipeline from intent to execution-ready artifacts is now complete: One sentence → PRD → User Stories → Units. The PRD captures the product intent. The Stories translate that intent into testable requirements. The Units organize those requirements into parallelizable work.
Each step produces a real file. Each file becomes input to the next skill. Each approval gate keeps the human in control. That is the core idea behind AI-DLC Inception: not AI replacing product thinking, but AI making product thinking more structured, repeatable, and traceable.
Part 1 showed how to move from vague ideas to user stories and units. Part 2 adds the product alignment layer before that work begins. The result is a cleaner path from idea to execution, one that PMs, engineers, human teams, and AI agents can all work from.
This is Part 2 of the AI-DLC series. Part 1 covers the Inception Stories and Units skills.
The PRD, Stories, and Units skills are available as custom skills in Amazon Quick Desktop .
#AI-DLC #ProductManagement #HumanInTheLoop #RequirementsEngineering #KiroEnjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article