Skip to content
Skills Library
Management & product · Writing

implementation-prd

/implementation-prd

Create implementation-ready PRD/spec bundles for new apps, products, services, platforms, mobile or desktop software, SaaS systems, or complex features. Use when the user asks for a detailed PRD, build-ready spec, spec bundle, spec packet, PRD + contracts + schema + test plan, backend or API spec, frontend or mobile app spec, feature requirements, technical product brief, or documentation that Claude Code or Codex can implement with minimal follow-up or one-shot implementation. Produce a decisive bundle with PRD, contracts, storage or data-model artifact, test plan, acceptance criteria, defaul

Licence
MIT
Last repository change
26.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
10
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Create implementation-ready PRD/spec bundles for new apps, products, services, platforms, mobile or desktop software, SaaS systems, or complex features. Use when the user asks for a detailed PRD, build-ready spec, spec bundle, spec packet, PRD + contracts + schema + test plan, backend or API spec, frontend or mobile app spec, feature requirements, technical product brief, or documentation that Claude Code or Codex can implement with minimal follow-up or one-shot implementation. Produce a decisive bundle with PRD, contracts, storage or data-model artifact, test plan, acceptance criteria, defaul

Original author description

Create implementation-ready PRD/spec bundles for new apps, products, services, platforms, mobile or desktop software, SaaS systems, or complex features. Use when the user asks for a detailed PRD, build-ready spec, spec bundle, spec packet, PRD + contracts + schema + test plan, backend or API spec, frontend or mobile app spec, feature requirements, technical product brief, or documentation that Claude Code or Codex can implement with minimal follow-up or one-shot implementation. Produce a decisive bundle with PRD, contracts, storage or data-model artifact, test plan, acceptance criteria, defaul

How it works

  1. Default Output
  2. Working Rules
  3. Bundle Workflow
  4. One-Shot Quality Gates
  5. References
  6. Templates
Original SKILL.md headings · 76 lines, 641 words
SKILL.md preview
---
name: implementation-prd
description: >
  Create implementation-ready PRD/spec bundles for new apps, products,
  services, platforms, mobile or desktop software, SaaS systems, or complex
  features. Use when the user asks for a detailed PRD, build-ready spec, spec
  bundle, spec packet, PRD + contracts + schema + test plan, backend or API
  spec, frontend or mobile app spec, feature requirements, technical product
  brief, or documentation that Claude Code or Codex can implement with minimal
  follow-up or one-shot implementation. Produce a decisive bundle with PRD,
  contracts, storage or data-model artifact, test plan, acceptance criteria,
  default technical choices, and phased implementation order.
---

# Implementation PRD

Write specs that another coding agent can execute without reopening discovery.

## Default Output

Create or update a spec bundle with these files:

1. `<slug>_prd.md`
2. `<slug>_contracts.md`
3. one storage artifact:
   - `<slug>_schema.sql` for SQL-backed systems;
   - `<slug>_data-model.md` for frontend-only work, NoSQL systems, or features with no relational schema change.
4. `<slug>_testplan.md`

Do not omit state design. If there is no durable storage delta, use the data-model artifact and state explicitly where state lives and why no schema change is needed.

When starting from scratch, use the bundled scaffold script.

Locate this installed `SKILL.md` through the current host's skill metadata or file tools. Resolve `../..` from its directory to get the absolute plugin root. Replace `<absolute-plugin-root>` below with that path and verify `scripts/init-spec-bundle.sh` exists. If the resource is unavailable, report the missing path and stop; do not assume a host environment variable supplies it.

```bash
bash "<absolute-plugin-root>/scripts/init-spec-bundle.sh" <slug> <product|feature|system> [output_dir] [sql|data-model]
```

Quote an explicit output directory after resolving it to an absolute path. Keep the script's refusal to overwrite existing files; choose a new destination or update existing specs deliberately.

## Working Rules

- Decide early whether the request is a net-new product, a service or platform subsystem, or a complex feature inside an existing system.
- Mirror the user's language for prose. Keep code, contract types, enum values, and filenames in English unless the repo already uses another convention.
- Make explicit assumptions instead of leaving hidden gaps.
- Choose one recommended default architecture or stack when that removes downstream ambiguity. Do not present option menus unless the user asked for trade-off analysis.
- Keep MVP and non-goals sharp. Downstream implementation should know what not to build.
- Make surfaces explicit. A surface can be a UI screen, route, API endpoint, CLI command, webhook, worker job, admin panel, SDK entry point, or automation hook.

## Bundle Workflow

1. Normalize inputs: problem, persona or caller/operator, target action, constraints, monetization or entitlement, integrations, data sensitivity, and delivery surface.
2. Draft the PRD first. Lock scope, scenarios, functional requirements, architecture, business rules, acceptance criteria, epics, implementation order, default technical decisions, risks, and Definition of Done.
3. Derive contracts from the PRD. Cover domain types, service boundaries, API or IPC payloads, async job events, validation rules, and error envelopes.
4. Derive the storage or data model artifact. Add durable entities, invariants, lifecycle states, and migration notes, or explicitly state that no schema change is needed and how state is represented.
5. Derive the test plan from critical paths and failure modes. Cover fixtures, unit, integration, E2E, snapshots or golden tests when rendering or formatting matters, performance or smoke, negative cases, and exit criteria.
6. Cross-check the files so naming, state machines, IDs, limits, and enum values match exactly.

## One-Shot Quality Gates

Before finishing, verify all of these:

- Scope, non-goals, and acceptance criteria are objective and testable.
- Every non-trivial user, caller, or operator flow has a happy path and at least one failure path.
- Long-running or async stages define job state, retry behavior, error reporting, and restart safety.
- Security, privacy, entitlement, billing, or quota rules are explicit when relevant.
- Contracts are serializable and precise enough for direct implementation.
- The spec contains default decisions, not TODOs disguised as choices.
- The test plan can prove the acceptance criteria, not just restate them.
- The Definition of Done includes code, contract or data-model updates, tests, error handling, surface or entry-point exposure, and persistence or restart behavior where applicable.

## References

- Read [references/spec-bundle-blueprint.md](references/spec-bundle-blueprint.md) for the canonical bundle structure and section-by-section expectations.
- Read [references/quality-gates.md](references/quality-gates.md) before finalizing any bundle that should be handed to a coding agent.

## Templates

Use the templates under `assets/templates/` when you need to scaffold or compare file structure:

- `product-prd-template.md`
- `system-prd-template.md`
- `feature-prd-template.md`
- `contracts-template.md`
- `schema-template.sql`
- `data-model-template.md`
- `testplan-template.md`
Files in this package (10)
  • SKILL.md 5 KB
  • assets/templates/contracts-template.md 2 KB
  • assets/templates/data-model-template.md 1 KB
  • assets/templates/feature-prd-template.md 3 KB
  • assets/templates/product-prd-template.md 4 KB
  • assets/templates/schema-template.sql 1 KB
  • assets/templates/system-prd-template.md 3 KB
  • assets/templates/testplan-template.md 2 KB
  • references/quality-gates.md 3 KB
  • references/spec-bundle-blueprint.md 6 KB

Versions

The database has no other skills named implementation-prd.

Database snapshot: 13.11.2026 · package version 0e97594525a2 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100prd
    Use when the user wants to write a PRD, product spec, or feature brief, capture requirements, or update an existing PRD to match design or implementation changes.
  • 91implementation-spec
    Master orchestrator that generates all implementation specs (PRD, Architecture, UX, Implementation, Test, Release) from product plan. Use when generating complete specification package.
  • 100workflow-prd-to-plan
    Transforms a PRD into a detailed implementation plan broken into user stories with per-layer tasks, acceptance criteria, and user validation steps. Use when the user wants to plan the implementation of a feature, break down a PRD into tasks, or mentions "implementation plan".
  • 84prd
    Guide the user through writing a Product Requirements Document or feature spec. Uses a four-phase gated flow (Discovery → Specify → Plan → Tasks) to produce spec.md, plan.md, and tasks.md in the project's planning/prd/ directory. Use when the user says "write a PRD", "write a…
  • 100prd-to-spec
    Transform a PRD into a technical SPEC document — architecture, API design, data model, error handling, and implementation contracts. Triggers on: prd-to-spec, prd to spec, prd转spec, 需求转设计, 需求转规格, generate spec from prd, design from prd, 技术方案, 设计方案.
  • 100create-plan
    Create a repository-aware implementation plan, PRD, technical spec, or roadmap item. Use when the user asks to plan a feature, write a PRD or spec, draft a roadmap plan, or produce an implementation-ready feature plan. Discovers local plan conventions; supports quick, standard,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.