PRD and ERD Agent Skills for Claude Code and Codex

Coding agents write code in minutes. A human still reviews it in hours.

That gap is where my time goes now. An agent opens a pull request before lunch. I spend the afternoon working out what it decided. Why this table? Why that API shape? Did anyone agree the feature should behave this way? I end up making those decisions during review. It is the slowest and most expensive place to make them.

So I built two Agent Skills that move those decisions earlier.

Review is the bottleneck

Dex Horthy of HumanLayer explains the problem well in his essay Why Software Factories Fail. When an agent does the building, building gets fast. Review does not. A person still has to read the change and test it. Taking that person out of the loop doesn't fix it.

His fix is old advice. Agree on the plan before anyone builds. He describes four steps that come before code: a product review, system architecture, program design, and vertical slices. A pull request that matches an agreed plan is quick to review.

My two skills follow that sequence. The PRD skill covers the product review. The ERD skill covers the other three. When the pull request arrives, you check the code against decisions you already made.

The PRD skill

The PRD skill pins down what you are building and why it matters. It starts by sizing the change. If the change is small, it tells you to skip the PRD and get on with it. I didn't want a tool that turns every bug fix into paperwork.

When the work does need a PRD, you get a Markdown document with rough HTML mockups. You also get a success measure you can check after launch. That last part matters to me. "Ship it and see" is not a measure. A number you can look up a month later is.

The ERD skill

The ERD skill picks up once you approve the PRD. It turns the PRD into a technical plan in three phases: system architecture, program design, and vertical slices you can build in order.

It stops after each phase and waits for your review. You approve the architecture before it moves on to program design. You approve the program design before it plans the slices. Each review is small, so you catch a wrong turn while it is still cheap to fix.

One note on the name. ERD here means Engineering Requirements Document. It is not an entity-relationship diagram.

Plain Markdown, in your repo

Both skills write plain Markdown files. A change to the plan shows up as a normal Git diff, and you review it like any other change. The next agent can read the files too. When you hand the build to a fresh session, it starts from the decisions already in the repo.

Using the skills

You talk to your agent in plain language. In Claude Code, you might start with this:

Write a PRD for saved-search alerts

After you review and approve the PRD, you follow up:

Now make the implementation plan

Codex works the same way, and you can also call the skills by name as $prd and $erd. Agensi lists Cursor, Gemini CLI, GitHub Copilot and Windsurf as compatible too, along with any other agent that reads the SKILL.md format.

Get the skills

If you want to try them, both skills are on Agensi as the Engineering Workflow bundle. You can also get the PRD skill or the ERD skill on its own.

To install, click Copy prompt to install on the Agensi page and paste the prompt into your agent. The agent connects to Agensi and installs the skills.

Next time an agent hands you a pull request, the decisions behind it should already be on paper. Your review can confirm them instead of making them.