Mohammad Jazim

From Prompt → PRD → PROMPT.md → Warp: AI-Native Build Loop

3–4 minutes

Alright, so here’s how I build projects these days. It’s half prompt engineering, half product design, and half automation sorcery. (Yes, that’s three halves. Welcome to modern dev.)

🧩 Step 1: Turn the idea into a PRD

Every project starts with a single line in ChatGPT Pro. Something like:

“Build an LSP for Strudel files that includes autocomplete and diagnostics.”

That “initial prompt” goes through a 10-step pipeline that spits out a Product Requirements Document (PRD). It’s not fancy, just structured:

  1. Normalize intent (who/what/why/constraints).
  2. Fetch related context (past tickets, metrics, etc.).
  3. Define outcomes and KPIs.
  4. Identify users and scenarios.
  5. Outline scope/non-goals.
  6. Sketch UX flows.
  7. Write functional requirements (Given/When/Then).
  8. Add non-functional reqs (SLOs, reliability, cost).
  9. Design rollout and experiment gates.
  10. Log risks, decisions, and open questions.

The result is a clean, review-ready PRD in markdown: the “human contract” for the project.

The build loop becomes more useful when the problem has already been explored and validated. My product-discovery workflow covers the upstream work that informs a stronger PRD.

🤖 Step 2: Generate the (the machine contract)

Once the PRD is solid, I feed it into ChatGPT to generate a PROMPT.md file — basically the machine-readable version of the spec.

It’s got:

---
prompt_name: <feature>-agent
model: gpt-4o
fallback_models: [claude-opus, gpt-4o-mini-high]
tags: [prd-derived, agentic, production-ready]
---

Then sections like:

  • SYSTEM – defines the agent’s role and tone.
  • CONTEXT – condensed PRD details.
  • TASK – numbered objectives.
  • CONSTRAINTS – guardrails and safety checks.
  • ACCEPTANCE TESTS – from the PRD.

That file tells the AI how to work, what to output, what “done” means, and how to self-check without hallucinating its reasoning. It’s the bridge between documentation and orchestration.

⚙️ Step 3: Drop both into Warp and hit go

I upload both the PRD.md and PROMPT.md into the repo, then tell Warp:

“Build this project according to these two files and my global rules.”

The Warp agent evaluates the PRD and PROMPT.md, drafts a multistage plan, and shows me the steps. I can approve, revise, or deny each one. Once approved, it scaffolds the repo, generates a task list, and starts executing.

🧪 Step 4: Iterative build, not one-shot delusion

Look, I don’t believe in “one-shotting.” Software design principles and sane engineering practice preclude me from such delusions. Real systems are iterative, test-driven, and full of tradeoffs.

That said… this setup is the closest I’ve ever gotten to feeling like I one-shotted a project. Warp ingests the PRD, reads the PROMPT.md like scripture, and starts building in verifiable steps. I still guide it, but it gets shockingly close to “prompt-to-product.”

🧠 Step 5: How the agent actually builds

It runs a tight loop:

  1. Validate PRD and PROMPT structure.
  2. Decompose acceptance criteria into testable tasks.
  3. Write failing tests first (TDD).
  4. Implement minimal code to pass.
  5. Lint → typecheck → test → print results.
  6. Commit with Conventional Commits (multi-line, meaningful).
  7. Block merge if gates or tests fail.
  8. Open PR linking PRD for human review.

Everything is transparent, logged, and traceable. And I can still step in mid-build, request revisions, or provide updated constraints.

🔒 Step 6: Hygiene and exclusions

Global rule: the PRD, PROMPT.md, and WARP.md all live in the repo but are excluded from git (.git/info/exclude). That keeps the scaffolding logic private while still versioning the actual deliverables.

🚀 The punchline

The whole setup’s basically a handshake between what we want and what the machine knows how to do:

  • PRD.md — the human side: clarity, scope, purpose.
  • PROMPT.md — the machine side: instructions, guardrails, tests.
  • Warp — the executor that translates both into working code.

You’re not hitting a magic button here. You’re setting up a loop you can trust, where humans lay out the context and the AI builds from the ground up.

It’s as close to “push-button engineering” as I’m ever gonna get, and I’ll take it.

If you’re running similar prompt-to-PRD-to-code loops (Warp, Claude, Codex, MCP, Obsidian, whatever), drop your setup. Always curious how others are taming the chaos.

Share this article

Explore more of my work

Read original research and practical product notes, or explore the products and systems I have worked on.

Comments

Leave a Reply