I Open Sourced a PRD Builder Skill That's Going to 10x Your Development
Andrej Simunaj
AI agents win coding competitions. AI agents make junior-level mistakes.
Both are true. At the same time.
Mo Bitar’s “There’s no skill in AI coding” went viral arguing that no amount of prompting fixes it. Half a million views.
He’s wrong. This is absolutely fixable. AI agents can produce exceptionally well-done, production-level code, the kind senior engineers would be proud to ship.
The bridge is upfront planning combined with reflection loops, and a deep specification for what is to be created, before it is created. Get the spec right and the gap between “junior-level mistakes” and “production quality” collapses.
Today I’m open sourcing the PRD Builder skill I use to produce those specs. MIT licensed. Adaptable to any project type, any tech stack, any agent platform.
github.com/ZeroPointRepo/CRHQ-PRDs/skills/prd-builder/SKILL.md
Hand it to your agent. Watch what happens.
And stick around to the end. There’s a bonus goodie waiting.
Karpathy Called It
Andrej Karpathy posted this last week:
“The mistakes have changed a lot. They are not simple syntax errors anymore. They are subtle conceptual errors that a slightly sloppy, hasty junior dev might do. The most common category is that the models make wrong assumptions on your behalf and just run along with them without checking.”
The key phrase here is “without checking”, and the reason it happens is the exact reason it’s fixable.
Agents are sycophantic; they want to please you. When you tell one to “build me a feature,” its reward function reads: ship the feature, fast, in the shortest path possible. That’s what pleasing looks like from the inside.
So the agent makes assumptions about all the details you skipped, the edge cases you didn’t mention, and the architecture you never defined. Each assumption is a silent gamble, and most of them are wrong, because shortest-path defaults are rarely what production actually needs.
That’s the gap.
Now change one word. Tell the agent “plan the feature” instead, and the pleasing happens inside the plan rather than inside the code. Every assumption gets dragged into the open, every shortcut becomes a decision, and every gap surfaces, because surfacing gaps is exactly what good planning looks like.
If your prompt is also exceptionally specific about what the plan must cover (every entity, every endpoint, every state, every edge case, every authorization rule), the same pleasing reflex that produced sloppy code now drives the agent toward thoroughness. The eagerness that makes agents reckless executors is what makes them ferocious planners.
That’s the bridge.
What’s in the Skill
The PRD Builder ships as a single SKILL.md file. Environment-agnostic. MIT licensed. Everything an agent needs to follow the methodology end-to-end:
- Project-type adaptive structure. Full-stack, backend service, frontend app, library, refactor, internal tool, integration. Different shapes for different work.
- Seven-phase workflow. Discovery → draft → review → revise → review → revise → deliver.
- Parallel-drafting pattern. Split the writing across multiple agents so no single context window saturates.
- Dual-review perspectives. Architect plus project-specific lens (security/QA, UX/a11y, DX, SRE).
- Structured findings format. CRITICAL / HIGH / MEDIUM / LOW, plus a master contradiction table and prioritized action items. Vague feedback is rejected and re-requested.
- Cross-cutting reconciliation list. Naming, paths, response envelopes, pagination, soft-vs-hard delete, ID generation, validation. One canonical answer per category, enforced everywhere.
- Quality-marker checklist. What a finished PRD must pass before it ships.
- Anti-pattern guide. The failure modes you’ll be tempted to fall into, named so you can avoid them.
Hand it to a frontier model. It will follow the whole thing.
How It Works
My workflow has three stages: plan, execute, test. Each has its own rigor. But planning is where 90% of the leverage lives. Get the spec right and the rest mostly takes care of itself. The skill drives the planning stage.
Phase 1: Discovery. Classify the project type. Parse intent against fifteen requirement dimensions. If extending an existing codebase, read it first. Capture a tight requirement summary.
Phase 2: Draft 1. Split the writing across parallel agents. One owns schema, one owns API, one owns features, one owns executor instructions. Each gets full context for its slice. Serial drafting in one window saturates the context window and triggers lossy summarization. Parallel doesn’t.
Phase 3: Dual Review. Two reviewers in parallel with different lenses. Reviewer A is the architect, looking for gaps, contradictions, ambiguity, and naming drift. Reviewer B is project-specific: security plus QA for full-stack, security plus SRE for backend services, UX plus accessibility for UIs, DX for libraries. Both produce structured findings.
Phase 4: Draft 2. Synthesize all findings into one unified fix list. Launch parallel rewrite agents with copy-pasteable per-section instructions. Reconcile cross-cutting concerns. One canonical answer per category, enforced everywhere.
Phase 5: Final Review. Single reviewer, final pass. Catch what the dual review missed. Verify Draft 2 fixes landed without introducing new contradictions.
Phase 6: Draft 3. Apply remaining fixes. Mark as Final.
Phase 7: Delivery. Render via inline artifact. Produce a download/share link. Update working memory.
The same draft → review → revise pattern lives inside execute and test as well. Implement against the PRD, review your own implementation against it, fix gaps. Write a test checklist, review it for completeness, run tests in parallel, route any gaps back into the original plan.
The methodology is fractal. Same loop, every level.
Take It
The PRD Builder skill → github.com/ZeroPointRepo/CRHQ-PRDs/skills/prd-builder/SKILL.md
MIT licensed. Fork it. Hand it to your agent. Watch what happens.
And here’s the bonus.
I tested this skill end-to-end on a real project, a complete lightweight CRM. Full stack. React, Node, Postgres. Contacts, companies, deals pipeline, activities, email integration, attachments, role-based access.
The PRD itself took 40 minutes to produce.
The agents executed it in 2 hours and 15 minutes. One shot. No babysitting.
98% of features worked on the first run.
Sit on that math for a second. A 10,000-line spec built in 40 minutes. A complete working product two hours later. That is what this methodology unlocks once you have it.
The CRM PRD is in the same repo. MIT licensed too. Use it as a template. Use it as a reference for the bar. Use it as the starting point for your own product.