Back to Blog
TutorialsSpec-Driven Development

How to Write a PRD with AI: A Step-by-Step Workflow

Keeborg Team
Product team planning a product requirements document on a whiteboard

Vague prompts lead to endless iterations. If you've ever asked an AI coding agent to "build the dashboard" and watched it guess at half your requirements, the problem usually isn't the model — it's the brief. A product requirements document (PRD) is the brief, and writing one with AI turns a blank page into a structured spec in minutes.

This guide walks through what a PRD is, a step-by-step AI-assisted workflow, a reusable prompt template you can copy, and the mistakes that quietly waste your time.

What is a PRD, and what goes in it?

A PRD is the document that defines what you're building and why, before anyone writes code. It's not a design doc and it's not a backlog — it's the source of truth that engineering, design, and AI agents all read from.

A useful PRD covers the essentials and nothing more:

  • Problem and goal: the user problem you're solving and what success looks like.
  • Users and use cases: who this is for and the jobs they need done.
  • Scope: what's in, and just as importantly, what's out.
  • Requirements: functional behaviour, plus non-functional needs like performance and accessibility.
  • Acceptance criteria: how you'll know each requirement is met.
  • Open questions: the decisions you haven't made yet.

Why write a PRD with AI?

AI coding agents are powerful, but they need clear instructions. A PRD gives the agent the context it would otherwise invent: constraints, edge cases, and the definition of done. Feed it a tight PRD and you spend your time reviewing output instead of re-explaining intent.

Writing the PRD with AI helps in the other direction too. The model is good at turning a rough idea into structured sections, surfacing requirements you forgot, and drafting acceptance criteria you can refine — so you start from a complete first draft rather than a blank template.

How to write a PRD with AI: a step-by-step workflow

1. Start with the problem, not the feature

Open with one or two sentences describing the user problem and the outcome you want. Resist jumping to a solution. If the AI knows the problem, it can pressure-test whether your proposed feature actually solves it.

2. Give the AI your raw context

Paste everything you already have: notes, a Slack thread, a competitor screenshot description, the relevant part of your stack. Messy input is fine — the model's job is to organise it. The more concrete context you give, the fewer assumptions it has to make.

3. Ask for a structured first draft

Prompt the model to produce the PRD using the section list above. Ask it to mark anything it had to assume, so you can see exactly where it filled gaps. Treat this draft as a starting point, never the final word.

4. Interrogate the scope

Scope creep starts in the PRD. Ask the AI to list what's explicitly out of scope and to flag any requirement that looks like a separate project. Cutting scope here is far cheaper than cutting it after the agent has written the code.

5. Generate acceptance criteria

For each requirement, ask for testable acceptance criteria in plain language. These double as the checklist your AI coding agent works against and the basis for your tests, so spend a minute making them specific and measurable.

6. Review, tighten, and hand off

Read the whole thing as if you were the engineer. Delete filler, resolve the open questions you can, and leave the rest clearly marked. Then hand the PRD to your coding agent — or generate the supporting spec files directly from it.

A reusable PRD prompt template

Copy this prompt, fill in the brackets, and paste your raw context underneath:

You are helping me write a PRD. Here is the context: [paste notes]. Produce a PRD with these sections: Problem & Goal, Users & Use Cases, Scope (In / Out), Functional Requirements, Non-Functional Requirements, Acceptance Criteria, Open Questions. Keep it concise. Mark every assumption you make with [ASSUMPTION] so I can verify it. Flag any requirement that looks large enough to be its own project.

Run it, then iterate section by section rather than regenerating the whole document — you'll keep the parts that are already right.

Common mistakes to avoid

  • Writing the solution instead of the problem — the agent inherits your blind spots.
  • Skipping the "out of scope" section, which is where scope creep is cheapest to stop.
  • Accepting the AI's first draft without checking its assumptions — verify every [ASSUMPTION].
  • Vague acceptance criteria like "works well" that can't be tested or implemented.
  • Letting the PRD and your actual instruction files drift apart once code starts.

From PRD to spec-driven development

A PRD is the first artefact in a spec-driven workflow: you define the spec, then let the AI build against it. Once your PRD is solid, the next step is turning it into the technical specs your agent reads every session. Compare the AI PRD tools to see how different tools approach this, then move from document to working spec.

Keeborg does that last step for you. Paste your idea and it generates a complete PRD plus the supporting technical specifications — the fastest way to go from rough notes to a brief your AI agent can build from. Try the PRD generator.

FAQ

How long should a PRD be?

As short as it can be while still answering what, why, for whom, and how you'll know it's done. A focused two-page PRD beats a ten-page one that nobody reads. AI helps here by trimming filler if you ask it to.

Can AI write the whole PRD for me?

It can write a strong first draft, but you own the decisions. The model fills gaps with assumptions; your job is to verify them, cut scope, and resolve the open questions. Treat it as a fast drafting partner, not the decision-maker.

What's the difference between a PRD and a spec?

A PRD describes the product — the problem, users, and requirements. A technical spec describes the implementation. The PRD comes first; the spec is how you turn it into something an AI coding agent can build.

Spec-Driven Development

You know the theory.
Now install the system.

The Dev System is a complete spec-driven development methodology you install in 30 seconds. 10 skills, a 95/100 quality gate, a continuity protocol, and a security audit — personalised to your framework, deploy target, and preferences.

Install in 30 seconds One-time $49 — not a subscription Yours to keep and modify
See what's inside
New
your-dev-system/
CLAUDE.md              ← Your rules
skills/
  session-continuity/  ← Never lose context
  multi-agent-qa/      ← 95/100 quality gate
  security-audit/      ← Blocks bad deploys
  seo-aeo-pass/        ← Every public page
  research-and-plan/   ← Before any code
  nextjs-scaffold/     ← Your framework
  vercel-deploy/       ← Your deploy target
  resend-email/        ← Your email provider
  post-launch/         ← Monitoring + care
templates/
  project-CLAUDE.md    ← Per-project setup
  continuity/          ← decisions, changelog,
                          session-log
$49one-time
Personalised to your stack
Keeborg Team

The Keeborg team is building the AI Agent Development Kit - helping developers generate production-ready specifications for AI coding agents.

Ready to build your next project?

Generate 8 AI-agent-ready specification documents from a plain English description in under 90 seconds.

Get Started Free

Related Articles