- Home
- Skills
- Productivity
- PRD and Coding-Agent Build Spec from a Rough Software Idea
Works with the AI Agents you already use
PRD and Coding-Agent Build Spec from a Rough Software Idea
Then it writes a 20-section PRD and offers a build spec for Claude Code, Codex, Cursor or a similar agent.
$5
PRD and Coding-Agent Build Spec from a Rough Software Idea
Example session with this skill installed
I run a small bike shop. I want an app where customers book repairs, see a live status of their bike (diagnosed, waiting on parts, ready), and get a text when it's done. Two mechanics, ~40 repairs a week, currently everything is on a whiteboard and phone calls. Skip the questions, make reasonable assumptions and give me the PRD and a build spec I can hand to a coding agent.
- Read your context and instructions
- Compiled the prd and coding-agent
Excerpt. Every line below except the bracketed markers is copied verbatim, unedited, from the agent's complete response (40,492 characters). The full response is examples/bike-shop-fast-mode.md in the skill package. Before loading the skill the agent wrote one line: "I'll use the idea-to-prd skill in fast mode to produce the PRD and build spec directly."
Assumptions
| ID | Assumption | Affects | Confidence |
|---|---|---|---|
| A1 | Single-location independent shop, one business entity | Scope | High |
| A2 | Customers are individuals, not fleet/commercial accounts | Data model, scope | High |
| A3 | "Booking" means a customer requests a drop-off time; the shop still confirms it (you keep control of the schedule, same as phone calls today) | Scope, UX | Medium |
| A4 | 40 repairs/week is a shop-wide capacity limit, not per-mechanic; no complex auto-assignment logic needed | Architecture, scope | Medium |
| A5 | SMS is the only notification channel (no email, no native push app) | Architecture, integrations | High |
| A6 | Status lifecycle expands your 3 states into: Booked → Dropped Off → Diagnosed → Waiting on Parts → In Progress → Ready for Pickup → Picked Up | Data model, UX | Medium |
| A7 | Staff need a simple list/board view, not a drag-and-drop Kanban — appropriate for 2 mechanics / ~40 repairs/week | Scope, UX | Medium |
| A8 | No online payment in V1 — payment still happens in person at pickup, as today | Scope | High |
| A9 | Twilio is the SMS provider (industry-standard, pay-as-you-go, no enterprise minimums) | Architecture, cost | High |
| A10 | Mobile-responsive web app for both customers and staff, not native iOS/Android apps | Architecture | High |
| A11 | Two roles only: Staff (owner + mechanics, same permissions) and Customer | Data model, security | Medium |
| A12 | "Waiting on parts" is a manual status flag typed by staff — no parts-inventory/ordering system integration | Scope | High |
| A13 | Customers authenticate by phone number with an SMS one-time code (no passwords, no email required) | Architecture, data model | Medium |
| A14 | Each repair ticket covers one bike with one or more requested services; multi-bike drop-offs create multiple tickets | Data model | Medium |
Check these first: A3 (confirmed vs. self-service booking changes the whole flow), A6 (status granularity changes the data model and staff UI), A9/A5 (SMS provider and channel drive real recurring cost), A13 (phone-based auth vs. email/password changes auth architecture).
Biggest Risks
SMS compliance isn't instant. Sending business texts in the US generally requires carrier registration (10DLC) before high-volume delivery works reliably — this can take days, not minutes, and is an unverified, carrier-side process. Budget lead time before launch; don't assume you can text customers the day you deploy.
2.
Staff adoption is the real risk, not the tech. Two mechanics currently use a whiteboard because it's zero-friction. If updating ticket status in the app is slower than scribbling on a board, they'll stop doing it and the "live status" promise breaks. The status-update UI needs to be faster than the whiteboard, not just digital.
3.
Booking without real scheduling logic can overpromise. Because A3 assumes staff-confirmed bookings (not guaranteed slots), the UI must be clear that a booking request is "pending" until confirmed — otherwise customers will show up expecting a slot that was never actually accepted.
Product Requirements Document: Bike Shop Repair Tracker
v0.1 — based on the assumptions above
[... excerpt: PRD sections 1 to 5 (executive summary, problem statement, target users and core jobs, goals and non-goals, user stories) omitted ...]
6. MVP Scope
Must Have
- Customer booking request form (bike info, service needed, preferred date) — ticket status starts as "Booking Requested"
- Staff view to confirm/decline booking requests
- Full ticket status lifecycle: Booked → Dropped Off → Diagnosed → Waiting on Parts → In Progress → Ready for Pickup → Picked Up [A6]
- Customer-facing status page per ticket (phone-OTP login, or a private link)
- Staff dashboard: list of all active tickets, filterable by status
- One-tap status update per ticket
- Automatic SMS to customer when status becomes "Ready for Pickup"
- Staff notes field per ticket (free text, e.g., "waiting on brake cable")
Should Have
- SMS confirmation when a booking request is confirmed by staff (with date/time)
- Ticket history log (timestamps of each status change, visible to staff)
- Basic customer record (name, phone, past repairs) so repeat customers don't re-enter info
Could Have
- SMS notification on earlier status changes too (e.g., "Diagnosed"), not just "Ready"
- Simple weekly throughput count for the owner (tickets completed per week)
- Customer cancels a pending booking request themselves
Will Not Have in V1
- Online payment
- Parts inventory integration
- Multi-location support
- Native mobile apps
- Automated/optimized scheduling
[... excerpt: PRD sections 7 to 17 (13 numbered requirements, user flows and key screens, architecture with a Mermaid diagram, data model, API surface, NFRs, security and privacy, metrics, risk register, open questions) omitted ...]
18. Implementation Milestones
| Milestone | Goal | Deliverables | Acceptance Criteria | Dependencies | Complexity |
|---|---|---|---|---|---|
| M1: Core data + staff auth | Foundational scaffold | DB schema, staff login | Staff can log in; tickets/customers/bikes tables exist | None | Low |
| M2: Booking + confirmation flow | Customers can request, staff can confirm | Booking form, pending-requests view, confirm/decline | A request becomes a confirmed "Booked" ticket end-to-end | M1 | Medium |
| M3: Status lifecycle + staff dashboard | Core daily-use tool | Dashboard, one-tap status advance/revert, notes | Staff can move a ticket through all statuses and add notes | M1 | Medium |
| M4: Customer status view + auth | Customers can self-serve check status | Phone OTP login, status page | Customer sees correct live status without calling | M1, M3 | Medium |
| M5: SMS integration | The "get a text when it's done" promise | Twilio integration, ready-for-pickup + confirmation SMS, SmsLog | Status change to Ready triggers a real SMS within 1 minute | M3, Twilio account/10DLC setup | Medium-High |
| M6: Polish + pilot | Ready for real shop use | History log UI, empty states, edge cases handled | Both mechanics use it for a real week of repairs without reverting to the whiteboard | M1–M5 | Low |
Coding Agent Task Breakdown
- Scaffold project (frontend + backend + Postgres connection, deployment config)
- Implement data models: Customer, StaffUser, Bike, Ticket, StatusHistory, TicketNote, SmsLog
- Build staff auth (email/password) and customer auth (phone OTP)
- Build booking request API + form, and staff confirm/decline flow
- Build staff dashboard (ticket list, filters, pending requests)
- Build ticket status update (advance/revert) with history logging
- Build ticket notes feature
- Build customer status page (login-gated + tokenized link fallback)
- Integrate Twilio for confirmation SMS and ready-for-pickup SMS, with SmsLog
- Add tests for status transitions, auth, and SMS trigger logic
- Add deployment config and environment variable setup for Twilio credentials and DB connection
19. Acceptance Criteria
- A customer can submit a booking request without a password and see on-screen confirmation.
- A staff member can confirm that request, setting a scheduled date, and the customer receives an SMS with that date.
- A staff member can advance a ticket through every lifecycle status in one tap each, and revert if needed, with each change timestamped.
- The moment a ticket reaches "Ready for Pickup," the customer receives an SMS within 1 minute (barring carrier delay).
- A customer can log in with phone + OTP (or use a private link) and see their ticket's current status without calling the shop.
- A failed SMS send is visible to staff in the ticket's history, not silently lost.
[... excerpt: PRD section 20 (feasibility review, engineering questions, decision log) omitted ...]
Bike Shop Repair Tracker: Build Spec
Overview
A mobile-responsive web app for a small bike repair shop (2 mechanics, ~40 repairs/week) that replaces a whiteboard-and-phone-calls workflow. Customers submit repair requests and check live status online; staff manage all tickets from a dashboard and advance ticket status in one tap; customers get an automatic SMS when their bike is ready for pickup.
[... excerpt: build spec Core Features 1 to 6, User Experience, Data Model, Technical Approach and Scope & Boundaries omitted ...]
Build Order
- Scaffold the project: full-stack framework, Postgres connection, environment config for DB and Twilio credentials, deployment config for a single small hosting platform. Verify: app boots and connects to the database.
- Implement data models: Customer, Bike, Ticket, StatusHistory, TicketNote, SmsLog, StaffUser, with the fixed ticket status enum. Verify: migrations run cleanly; can manually insert/read each entity.
- Build staff authentication (email/password, session-based). Verify: a seeded staff account can log in and reach a protected route.
- Build customer authentication (phone number + SMS OTP via Twilio). Verify: a test phone number can request and verify a code, and gets redirected to a status page.
- Build the public booking request form and its API endpoint, creating Customer/Bike/Ticket records with status
booking_requested. Verify: submitting the form creates the right records and shows an on-screen pending confirmation message. - Build the staff dashboard's "Pending Requests" section with confirm/decline actions; confirming sets status to
bookedand triggers an SMS (stub Twilio in tests). Verify: confirming a request updates status, logs history, and attempts an SMS send. - Build the staff dashboard's active-ticket list, filterable by status, with a one-tap status-advance control; build the ticket detail view with full history and a notes editor. Verify: a ticket can be advanced through the full lifecycle and reverted, each change appearing correctly in the history log.
- Wire the
ready_for_pickuptransition to trigger a real SMS send through Twilio, logging the outcome to SmsLog; surface failed sends on the ticket detail view. Verify: in a staging environment with a real Twilio test number, advancing a ticket to Ready triggers an actual text within about a minute. - Build the customer status page: phone-OTP-gated ticket list/detail, plus a private tokenized-link fallback that doesn't require login. Verify: a customer can see correct live status through both access paths, and cannot see another customer's ticket.
- Add automated tests covering status transitions (including backward/revert logging), auth flows (staff and customer), and the SMS-trigger logic (mocked Twilio calls). Verify: test suite passes and covers each Must-have requirement.
- Handle the Twilio STOP/opt-out webhook to suppress future sends to opted-out numbers. Verify: a test STOP reply prevents a subsequent send attempt to that number.
- Finalize deployment configuration (environment variables for DB and Twilio, hosting platform setup) and do a pilot run with real staff data before full cutover from the whiteboard.
[... excerpt: build spec Implementation Notes omitted ...]
Scope note on assumptions
Several features above are driven by assumptions the shop owner should confirm or correct: the 7-stage status lifecycle (A6), staff-confirmed rather than self-service booking (A3), phone-OTP customer auth (A13), and SMS as the only notification channel (A5). If any of these don't match how the shop actually wants to operate, flag it before building rather than after.
This is ready for your coding agent: paste the build spec into its planning mode, or save it in the repo and point the agent at it. Want me to adjust anything first?
Correct any assumption and I'll update both the PRD and the build spec.
Connects securely to your tools. The creator never sees your data.
About this skill
What it does
Give your agent the idea in any form: a braindump, bullet points or a voice transcript. Guided mode (the default) is a conversation. It asks 2 to 3 rounds of plain-language questions, then works through validation in three groups: problem and scope; feasibility, architecture and data; risks and milestones. Each group ends with the decisions it needs you to confirm. Then it writes a 20-section PRD and offers a build spec for Claude Code, Codex, Cursor or a similar agent.
Say "skip the questions" and it asks nothing. It lists every assumption with an ID and a confidence level, flags the few that matter most, puts the biggest risks first, and writes the PRD in one pass. It adds the build spec if you mention a coding agent. With file access it saves PRD.md and BUILD_SPEC.md; otherwise it answers in chat. Already have a PRD? It checks it against a 14-question quality bar, asks about the gaps, then writes the spec.
Why this instead of a prompt
A "write me a PRD" prompt fills a template with guesses and presents them as settled. This skill tells the agent to challenge vague claims and to name over-scoped or fragile ideas. Whatever you did not say about your setup goes in as an assumption, and unverified vendor plans, fees, regulations and numbers are labeled hypotheses. Before the PRD is shown, an internal checklist cross-checks it: promised actions need a screen and an endpoint, metrics must be computable, and every Must Have has to sit in a milestone. The build spec adds no features, cites its assumptions, and lists testable build steps in order.
In the demo, a two-mechanic bike shop wants booking, live repair status and a "ready" text. Three risks come before any requirement: US texting needs carrier registration (marked unverified), the status stays live only if updating it beats the whiteboard, and booking without slot logic can overpromise. The demo field is a verbatim excerpt of one unedited run. The full response is in the zip.
Key features
- Three modes: guided (the default), fast (no questions, with an assumptions table) and spec only (turns an existing PRD into a build spec).
- 3 to 5 plain-language questions per round, smart defaults, and options with a recommendation when you say "I don't know".
- A 20-section PRD with a set place for each phase output, and a build spec sized to the project.
- Two internal checklists: one checks the PRD against itself, the other checks the build spec against the PRD.
- Iteration ("make it simpler", "add a feature") keeps the PRD and the spec in step and logs every decision.
Who it is for
Founders and small-business owners handing an idea to a coding agent or a freelancer, developers who want a plan-mode input, students scoping a project, and PMs who want a first PRD with risks and open questions written down.
How it is built
A single SKILL.md: 748 lines of plain Markdown. There are no scripts, dependencies, API keys or network calls. The zip also holds examples/bike-shop-fast-mode.md, the full unedited demo response, which the skill never loads.
Known limitations
- It does not research. Vendor and legal claims are labeled unverified rather than checked, but the demo still stated one vendor pricing claim without a label.
- The checklist reduces cross-reference gaps but does not remove them. The demo promises a private status link that has no token field or endpoint. Check the data model and API against the features.
- Fast-mode output is long: the demo response was 40,492 characters.
- Only fast mode has been demo-tested, once, in Claude Code. It writes documents only, with no code, designs or cost estimates.
Writes documents only: no research, code or designs. There is no web-search step; vendor plans, fees and regulations are labeled unverified instead of checked, though the demo still stated one SMS vendor pricing claim without a label. The internal consistency checklist reduces cross-reference gaps but does not remove them (the unedited demo promises a private status link with no token field or endpoint, and needs SMS webhooks missing from its API table), so read the data model and API against the features before you build. Fast-mode output is long (the demo was 40,492 characters). Only fast mode has been demo-tested, once, in Claude Code. Milestones carry complexity ratings, not hours or costs. Regulatory points are flags to check, not legal advice.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 27 days ago
Permissions
The skill is a set of instructions for how the agent interviews you, checks the idea and lays out the documents, so all of the work happens in the conversation. It runs no code, makes no network calls and does not contact any service. Write Files is optional and used only for PRD.md and BUILD_SPEC.md; Read Files only if you point the agent at your own notes or an existing PRD. The PRD may recommend third-party services for your product (in the demo, an SMS provider and a hosted database), but the skill never signs up for, logs in to or connects to them.