AI PRD Generator
Turn a one-paragraph idea into a structured product requirements document — goals, users, requirements, metrics, risks. Built by Tekk.
Free · No signup for your first 2 PRDs · Markdown output, copy anywhere
See an example PRD
TL;DR
Add monthly recurring Stripe subscriptions to the API so the product can charge customers automatically instead of one-off invoices. Targets B2B customers on Pro and Team plans.
Problem
- Today we issue invoices manually each month — sales spends ~3 hours per customer per renewal cycle.
- Cancellation handling is ad-hoc; revenue leakage on lapsed customers happens monthly.
- New customers churn before invoice #2 lands because the friction of "expect an email" feels manual.
Goals
- Convert all Pro/Team customers from manual invoicing to Stripe subscriptions by Q3.
- Reduce billing-ops time per customer from 3h to <5min per renewal.
- Surface a self-serve "manage subscription" page customers can use without contacting support.
Non-goals
- Per-seat or usage-based billing (next quarter).
- Refund automation — refunds stay manual.
- Enterprise tier; those stay on contract billing.
Target users
- Product admins at our B2B customers (decision-makers, billing email recipients).
- Internal sales team during renewal cycles.
Requirements
Must have
- Create Stripe customer + subscription on plan purchase.
- Handle
customer.subscription.updatedandcustomer.subscription.deletedwebhooks. - Sync subscription state (active, past_due, canceled) to internal
subscriptionstable. - Block API access when subscription is
past_duefor >7 days. - Send dunning emails on first failed payment.
Should have
- Self-serve plan changes (upgrade/downgrade) via customer portal.
- Prorated billing on mid-cycle changes.
- Receipt/invoice download from in-product settings.
Could have
- Annual billing toggle with discount.
- Multi-currency support.
Success metrics
- 90% of Pro/Team customers on Stripe subscriptions by 2026-09-30.
- <5 min average billing-ops time per renewal by 2026-10-31.
- 0 missed renewals due to manual error in the first 60 days post-launch.
Risks & assumptions
- Assumption: existing Stripe Connect account can handle direct subscriptions (verify with finance).
- Risk: webhook delivery failures cause sync drift; mitigate with daily reconciliation job.
- Risk: customers on legacy invoicing resist migration; mitigate with grandfathered pricing for 90 days.
Out of scope
- Migrating contract-billed Enterprise customers.
- Tax handling (Stripe Tax integration is a separate PRD).
- Sales-led pricing exceptions.
To take this PRD further against your actual API codebase, connect your repo in Tekk.
Free tool vs. full Tekk
The free tool gives you the structured first draft. Tekk grounds the rest of the work in your actual codebase.
| Feature | Free tool | Tekk |
|---|---|---|
| Structured PRD output | ✓ | ✓ |
| Markdown export | ✓ | ✓ |
| Edit in a real document editor | — | ✓ |
| References to your actual files and patterns | — | ✓ |
| Subtasks with acceptance criteria | — | ✓ |
| Kanban tracking for the work | — | ✓ |
| Multi-turn refinement with follow-up questions | — | ✓ |
| Runs against your real GitHub / GitLab / Bitbucket repo | — | ✓ |
How it works
- 1
Describe the product
Give the tool a one-line name, the problem you're solving, who it's for, and any constraints worth knowing.
- 2
Generate the PRD
We send your inputs to a tuned PRD prompt. The document streams back as editable markdown so you can read it as it writes.
- 3
Continue in Tekk for the real spec
One click hands the PRD into Tekk, where you connect your repo and turn it into an executable plan with subtasks, acceptance criteria, and Kanban tracking.
Frequently asked questions
- What is a PRD?
- A Product Requirements Document is a written description of what you're building, who it's for, why, and how success will be measured. PMs use it to align engineering, design, and stakeholders before any code gets written. Done well, it answers every question someone could have about scope before they ask.
- What sections does a good PRD include?
- The shape varies by org, but a strong PRD usually covers: a TL;DR, the problem, goals and non-goals, target users, requirements (often grouped by Must/Should/Could priority), success metrics, risks and assumptions, and an explicit out-of-scope section. The Non-goals and Out-of-scope sections are the most underrated — they're how you prevent scope creep before it starts.
- PRD vs MRD vs BRD — what's the difference?
- A BRD (Business Requirements Document) is the strategic 'why we're doing this' — usually owned by execs or sales. An MRD (Market Requirements Document) is the 'what problem exists and who has it' — usually owned by product marketing. A PRD is the product-level 'what we'll build to solve that problem' — owned by the PM. At smaller companies the PM typically just writes the PRD and skips the other two.
- How long should a PRD be?
- Short enough to read in one sitting, long enough to leave no major ambiguity. For most features that's 1–3 pages. If it's longer, the feature probably needs to be split into multiple PRDs.
- Who writes a PRD?
- The product manager, usually. At smaller startups, the founder or lead engineer writes it. The point is one accountable author — not a doc written by committee. Other people review and contribute, but one person owns the source.
- Can I edit the result?
- Yes — copy the markdown out and edit it anywhere. PRDs are living documents; this tool gives you a structured first draft, not the final answer. For an editable document with version history, follow-up questions, and codebase context, hit 'Continue in Tekk' to take the PRD into Tekk's planner.
- How is this different from ChatGPT?
- The prompt is tuned for PRD conventions (problem → users → goals → non-goals → requirements → metrics → risks). You get a consistent shape every time. ChatGPT can produce a PRD too, but you'd have to remember to ask for each section. Tekk's full planner goes much deeper than either — it reads your actual codebase and structures the PRD around your real files, models, and patterns.
- How is this different from Tekk's full planner?
- This free tool generates a static PRD from your text description. Tekk's planner reads your actual codebase (GitHub, GitLab, or Bitbucket), references your real files and patterns in the PRD, asks you follow-up questions, splits the PRD into executable subtasks with acceptance criteria, and tracks the work on a Kanban board. The free tool is the first 10% of what Tekk does.
- Does Tekk store my PRD inputs?
- The free tool doesn't store anything. Your inputs go to OpenAI for generation, then the result is rendered in your browser. If you click 'Continue in Tekk', the markdown is staged for 10 minutes so you can claim it after signup — after that it's deleted. Plans you create after signing up are stored in your Tekk account, same as any SaaS.
- Why only two free runs?
- AI generation costs us money on each request. Two runs is enough to convince yourself the output is useful before signing up. Signing up takes 30 seconds, connects your GitHub for codebase-aware planning, and unlocks unlimited generation.
- What model do you use?
- OpenAI's gpt-5-nano, with the minimum reasoning effort for speed. It's the cheapest model in OpenAI's current lineup that produces structured, decisive output. The system prompt does most of the lifting — we tell the model the exact section order, voice, and conventions.
Want a real spec for what you’re building?
Drop a sentence. Tekk grounds it in your actual code and turns it into an executable plan.
Free to try · Connect GitHub during signup