What this mini-build is

The last three lessons were reading. This one is writing. By the end of the next 24 minutes you'll have a PRD — an actual, reviewable, engineer-shippable document — for an AI feature, starting from a one-line Slack message.

Most PMs write their first AI PRD by taking their last SaaS PRD, pasting it into a new Notion page, and editing the noun from "search bar" to "AI assistant." That document gets politely killed in review. It has acceptance criteria but no eval. It has user stories but no refusal list. It has a Figma link but no prompt.

An AI PRD is not a classical PRD with a chatbot bolted on. It has seven sections, and four of them don't exist in classical PM work. Today we walk through each one, on-camera, for a real-feeling ask from BoraPay Nairobi.

Who this is for:
you've read Lessons 00–03. You know what a probabilistic feature is, you've seen the five-layer stack, and you've mapped what LLMs can and can't do. Now you have to put it in a document that a skeptical engineer, a worried legal counsel, and a date-driven VP can all read in the same afternoon.

The seven sections of an AI PRD

Here's the skeleton. Memorise it. Every AI feature you ever write up for the rest of your career will sit in some version of these seven buckets.

🎯
1. Problem & goal
What user pain, what business outcome, what the success number is.
👥
2. Users & use cases
Who asks, how often, in what state of mind. Three top use cases, not twenty.
🧭
3. Scope & non-goals
What the feature does — and loudly, what it refuses to do in v1.
📝
4. Prompts & behaviour
The system prompt sketch, tone, format, refusal rules. AI-only section.
🗂️
5. Data & retrieval
What the model is allowed to see. Sources, freshness, PII, indexing plan.
🚦
6. Evals & launch gate
Golden set, rubric, pass-rate bar. The number that decides ship or not.
🛡️
7. Risks & fallbacks
When the model is wrong, slow, or down — what the product does.
Why seven: four of these (prompts, data, evals, risks/fallbacks) don't exist in a classical PRD. Cut any of them and you'll re-discover why — usually at 2am two weeks after launch.

Classical PRD vs AI PRD — section by section

If you've written a feature spec for a payments app, a catalogue, or a dashboard, you already have muscle memory for most of these. Here's the translation. Same column on the left, what flips on the right.

Section Classical PRD AI PRD
1. Problem & goal User pain + business KPI (conversion, NPS) User pain + business KPI + trust metric (e.g. thumbs-up rate)
2. Users & use cases Personas + top flows Personas + top intents the model must handle (and what it must punt on)
3. Scope Features in / out Intents in / out + topics the model will refuse
4. Behaviour spec State diagrams, acceptance criteria System prompt sketch: role · tone · format · refusal rules · examples
5. Data API contracts, DB schema Document sources, index freshness, PII boundaries, session memory policy
6. Quality bar Unit + E2E tests, bug SLA Golden set, rubric, eval pass rate, refusal rate, launch gate number
7. Risks Outage / performance Hallucination · prompt injection · bad tone · cost spike · model upgrade — each with a fallback
8. Ownership Eng owns quality, PM owns scope PM owns prompt, rubric, gate. Eng owns plumbing. Both sign the eval.
The rule of thumb:
any section that reads the same in classical and AI is probably under-specified for the AI version. If your "risks" section says "latency" and stops there, you haven't finished the PRD.

Scenario — Kwame at BoraPay Nairobi

📱
Real-world scenario
One-line ask from the CEO: "customers should be able to ask why they were charged"

Kwame is a PM on BoraPay Nairobi's in-app support team. Monday standup, 9:02am. Slack from the COO: "Customers should be able to ask why they were charged — let's do this with AI. Ship before the BoraGroup board review. You have 10 weeks." No other context. No Figma. No data sample. Just that.

Kwame has shipped SaaS features before. He's never shipped an AI one. He opens a blank Notion page and types "PRD — Charge Explanations." He stares at the cursor. Then he remembers the seven sections. The rest of this lesson is Kwame's afternoon.

Before he writes anything, he asks four questions

Question 1
How often does this actually happen?
He checks: support tickets tagged "unknown charge" — 18,000 last month. Biggest single category. Worth it.
Question 2
What answer does the user actually want?
He reads 30 tickets: most want one sentence — "That was your BoraGroup airtime top-up at 14:22, KES 50." Not a lecture.
Question 3
What data does the answer need?
He lists: transaction ID, amount, timestamp, merchant, transaction type code. All in one existing table.
Question 4
What must it never do?
He writes: never claim a charge is fraud, never promise a refund, never touch loan-related charges. Hand off to an agent.
Why this matters: the PRD Kwame is about to write is 80% decided by these four questions. If he skipped them and went straight to Notion, he'd produce a beautiful document about nothing.

How Kwame writes the PRD — five sub-steps

Here is the actual sequence. Five sub-steps, one afternoon, seven sections by Thursday.

One-line ask Slack, Monday 9am PM scoping tickets · 4 questions Draft PRD 7 sections, v0.1 Eval design golden set · gate Review eng · legal Ship w10 w0 w0–w1 w1 w2–w3 w3 w10
STEP 1Write the problem + goal in one paragraph

Kwame types the problem in user words, not PM words: "BoraPay users get charged and can't tell what the charge was for. 18k tickets/month start with 'why was I charged'. Call-centre cost is KES 220 per ticket. Users churn harder after a confused charge than after a failed one."

Then the goal, with a number: "Deflect 50% of 'unknown charge' tickets in Q3. Thumbs-up rate ≥ 70% on AI answers. No fraud false-positives." Three numbers — volume, quality, safety. He resists the urge to add a fourth.

STEP 2Pick three intents and refuse the rest

Kwame reads 100 real tickets and tallies the intents. Top three cover 82% of volume:

In scope (v1): (1) "explain this specific charge" (2) "what does this merchant code mean" (3) "why are charges appearing when I'm not spending" (usually auto-debits). Out of scope: refunds, fraud claims, loan charges, disputes. Each out-of-scope intent gets a hard-coded human handoff. This is the scope section and the first draft of his refusal rules.

STEP 3Sketch the prompt and data before the UI

Here Kwame flips the classical PM instinct. Instead of going to Figma, he opens a fresh section called Prompts & behaviour and writes a prose system prompt — role, tone, format, refusal. Then a Data & retrieval section listing the exact fields the model is allowed to see (txn id, amount, timestamp, merchant, type code) and the ones it isn't (KYC, linked loans, saved cards). This is the document artefact the engineer actually builds from. Figma comes Thursday.

STEP 4Design the eval before you know the answer

Kwame exports 100 real "unknown charge" tickets. For each he writes the ideal one-sentence answer a human would give. That's his golden set. The rubric is two axes — correctness (did we cite the right transaction?) and helpfulness (did the user understand?) — each graded 1–5. The launch gate is one line: "Ship when ≥ 80% of golden-set answers score ≥ 4 on both axes, with zero answers that misidentify a charge as fraud." Written on day two, frozen.

STEP 5List the risks with named fallbacks

For each bad thing that can happen, Kwame writes one line in the Risks & fallbacks section: model hallucinates wrong transaction → the answer is templated from retrieved data, so the model fills blanks, not facts. Prompt injection from merchant name → strip control chars on the way in. Model is down → show a templated "see full statement" fallback. Vendor silently upgrades the model → pinned version, weekly re-eval, 3-point regression budget. Every row has an owner.

What the "Prompts & behaviour" section looks like

This is the AI-only section that a classical PRD has no slot for. It is not the final production prompt — it's the PM's behavioural spec, written as a prompt sketch so engineering, legal and the eval lead can agree on tone and refusal rules before a line of code is written.

ROLE You are BoraPay's in-app charge-explainer. You do not handle disputes, loans, or fraud.

TONE Short. Neutral. Never apologise before the facts. Never accuse BoraGroup or a merchant of an error.

FORMAT One sentence, ≤ 25 words. Always include the amount, the time, and the merchant name exactly as stored. Offer one follow-up: "See full statement" or "Talk to an agent".

REFUSAL If the user asks about a loan charge, a refund, a suspected fraud, or a dispute, respond exactly: "I can't help with that one — I'm connecting you to an agent now." Do not attempt to explain the charge.
Two things to notice: (1) the format rule "always include amount, time, merchant" is what turns the model from a generator into a filler — it can only combine retrieved facts, not invent them. (2) The refusal is a verbatim string, not guidance. Guidance is a hallucination magnet.

The AI connection

How real AI teams use this

In production AI teams at Anthropic, Stripe and SouthBank India, the PRD is not a one-time artifact — it's the input to a prompt repo, a golden-set repo and an eval dashboard. The "Prompts & behaviour" section becomes a versioned system prompt in git. The "Data & retrieval" section becomes a retrieval config. The "Evals & launch gate" section becomes the CI check that blocks deploys. PMs who write these sections tightly save weeks of re-negotiation. prd-as-spec prompt-repo golden-set launch-gate eval-ci

What Kwame's finished PRD looks like

Here's the at-a-glance version — the first page of the Notion doc. If all a reviewer sees is this table of contents, they should already know what Kwame is shipping and what he isn't.

Notion · BoraPay Nairobi · Support
PRD v0.9 — Charge Explanations (AI)

Owner: Kwame · Target ship: Week 10 · Launch gate: ≥ 80% golden-set pass, 0 fraud misclassifications

1
Problem & goal
Deflect 50% of 18k/month unknown-charge tickets · trust ≥ 70%
2
Users & use cases
3 intents cover 82% of volume · mobile-app only · English + Swahili
3
Scope & non-goals
In: explain charge · merchant code · auto-debit. Out: refund · fraud · loan · dispute
4
Prompts & behaviour
Role, tone, format, refusal string — sketch in git as prompts/charge_explainer_v0.txt
5
Data & retrieval
5 allowed fields from txn_ledger · 48h freshness · no KYC, no loans
6
Evals & launch gate
100-ticket golden set · correctness + helpfulness rubric · gate = 80% + 0 fraud errors
7
Risks & fallbacks
5 risks with named fallbacks: templated answer · handoff · pinned model version · cost cap · audit log
The test:
if you deleted sections 4, 5, 6 or 7 from this PRD, what would break first? (Answer: 6. Without the gate, the feature ships on vibes — and if it ships wrong, there's no agreed line for when to roll back.)

Mini challenge — write the first page for your own feature

Pick an AI feature at work (or a competitor's) and draft sections 1–3 in 20 minutes

1. Write the problem & goal as one paragraph + three numbers

One paragraph of user pain in user words. Then exactly three numbers: a volume number, a quality number, a safety number. If you can't name all three, the ask isn't scoped yet — push back before you write anything else.

2. List three intents in scope, three out of scope

Read 20 real user messages (tickets, reviews, support chats). Tally intents. Pick the three that cover most volume. Then pick three common intents you will refuse in v1 — and write the verbatim refusal string for each.

3. Write the launch gate in one sentence

Finish this sentence: "We ship when ≥ __% of a __-item golden set scores ≥ 4 on the rubric, and zero answers __." That one sentence protects you from every "can we just ship" meeting for the next ten weeks.

Interview questions

Easy What's the biggest difference between a classical PRD and an AI PRD?
+
Four extra sections: prompts & behaviour, data & retrieval, evals & launch gate, risks & fallbacks. A classical PRD describes deterministic behaviour and leaves quality to QA. An AI PRD describes a distribution of behaviours, names the prompt and data the model sees, defines a numeric launch gate over a golden set, and lists fallbacks for when the model is wrong. Same first three sections (problem, users, scope), very different last four.
Easy Why write the scope section as "intents in / intents out" rather than "features in / out"?
+
Because the model will be asked everything, not just what you built for. If you write scope as features, users will still type loan questions into a charge-explainer. Listing intents out of scope gives you a concrete refusal list the prompt can enforce and the eval can measure. It turns scope into a runtime contract, not just a planning document.
Medium When do you write the eval section — before or after the prompt?
+
Before. The rubric defines what "good" means. If you write the prompt first, you'll unconsciously optimise the rubric to match what the prompt already does — and the gate stops protecting you. The order is: problem & goal → scope & intents → golden set + rubric → launch gate → then prompt sketch. Engineers build to the gate; the prompt is just the current best attempt at clearing it.
Medium Your PRD says "no fraud false positives." How do you actually enforce that in the eval?
+
Two layers. First, the golden set includes a fraud-bait subset — tickets where the user says "I didn't authorise this." The ideal answer for these is the verbatim handoff refusal, not an explanation. Second, the launch gate has two thresholds, not one: a pass-rate threshold on the full golden set (e.g. ≥ 80%) and a zero-tolerance threshold on the fraud-bait subset (any answer that tries to explain counts as a failure, even if the explanation is correct). The gate blocks deploy if either fails. You're turning a risk into a measurable subset.
Hard Your stakeholder insists on a date commitment before the eval exists. How do you negotiate?
+
You don't refuse to give a date — that ends the conversation. You re-shape it into two commitments. Commitment one: a scope date — "by end of week 2, the golden set, rubric and launch gate will be frozen and reviewed with you." That's the date your stakeholder actually needs: the moment the feature becomes predictable. Commitment two: a ship date range — "between week 8 and week 11, conditional on the eval clearing the gate we're about to freeze." You write both into the PRD next to their section numbers. If the stakeholder pushes for a single hard date anyway, name the cost: shipping on date X means either lowering the gate below 80%, narrowing scope to one intent, or accepting post-launch fixes as the quality strategy. Force them to pick one explicitly, in writing, in the PRD's "Risks & fallbacks" section. Most will back off; the ones who don't have at least taken ownership of the trade-off. The PRD is the negotiation surface — use it.

Test your knowledge

Question 1 of 5
Which four sections of an AI PRD don't exist in a classical PRD?
Question 2 of 5
Kwame's one-line ask was "customers should be able to ask why they were charged." Before writing the PRD, what should he do first?
Question 3 of 5
Why write the eval section before the prompt section?
Question 4 of 5
The PRD says "no fraud false positives." What's the strongest way to enforce that?
Question 5 of 5
A stakeholder demands a hard ship date before the eval is built. What's the best PM move?
0
/5
Your first AI PRD will hold up in review.

Common mistakes writing a first AI PRD

PRD as wishlist
Twenty intents, five personas, "v1 covers everything." A real PRD is ruthless — three intents in, a dozen refused, one launch gate. If the doc can be summed up in a single paragraph, it's scoped.
No launch gate number
"We'll ship when quality is good" isn't a gate. A gate is "≥ 80% pass rate on a 100-item golden set, 0 fraud errors." Without the number, every exec meeting becomes a negotiation about whether to ship.
Data section as afterthought
"The model uses our data." Which fields? Which freshness? What PII? Written vaguely, this is where your legal review dies. Write it as a field-by-field allow-list next to the prompt.
No fallback when the model is wrong
Every risk needs a named fallback — templated reply, hard handoff, pinned model version. "We'll handle edge cases in v2" is how you discover those edge cases in a Twitter screenshot instead.

Key takeaways

  • Every AI PRD has the same seven sections: problem · users · scope · prompts · data · evals/gate · risks/fallbacks. Four of them don't exist in classical PM work.
  • A one-line ask isn't a spec. Before you open Notion, read 20–100 real user messages and tally intents, volume, data needed and refusals.
  • Write the eval section before the prompt. Rubric first, prompt second, or the gate silently adjusts to whatever the prompt happens to do.
  • Scope is a runtime contract, not a planning artefact. Intents out of scope become refusal strings in the prompt and gated subsets in the eval.
  • Every risk needs a named fallback with an owner: templated answer, handoff, pinned model, cost cap, audit log. A risk without a fallback is a future incident.
  • The PRD is the negotiation surface. If a stakeholder pushes a hard date, trade into a scope-freeze date and a conditional ship range — in writing, in the PRD.
Africa & India's Best AI Academy
🤖 AI-first 🎓 Placement Assistance

You've written your first AI PRD.
Now learn to write the prompts inside it.

Join the Best AI Program: The AI-Era Agentic Engineer — 5 months, fully online, with placement assistance. Week 1 is free.

Explore The AI-Era Agentic Engineer →