Prd Implementation Precheck
Run a structured PRD preflight so your agent surfaces scope creep, missing dependencies, and test gaps before writing implementation code.
Overview
prd-implementation-precheck is an agent skill most often used in Validate (also Build, Ship) that reviews a PRD for scope, risks, and gaps and blocks coding until you confirm the precheck report.
Install
npx skills add https://github.com/charon-fan/agent-playbook --skill prd-implementation-precheckWhat is this skill?
- Mandatory precheck before PRD implementation instead of jumping straight to coding
- Six-category review: scope, alignment, dependencies, behavior, risks, and testing
- Presents findings and questions, then waits for user confirmation
- Implements after approval with emphasis on minimal, consistent changes
- Fits agent-playbook install via symlink into ~/.claude/skills
- Six precheck categories: scope, alignment, dependencies, behavior, risks, testing
Adoption & trust: 588 installs on skills.sh; 58 GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You pointed an agent at a PRD and risk silent mis-scoping, missed dependencies, or untestable requirements landing in code before anyone reviewed them.
Who is it for?
Indie developers using Claude Code with written PRDs who want a human-in-the-loop gate before autonomous implementation.
Skip if: Tiny one-file fixes with no PRD, or teams that already finished formal spec review and only need execution without another pause.
When should I use this skill?
You ask to implement a PRD or feature requirements document and the skill should analyze it before writing code.
What do I get? / Deliverables
You receive a precheck report and answered questions, then implementation starts only after approval with smaller, pattern-aligned changes.
- Precheck report with categorized findings and open questions
- Implementation changes after explicit user approval
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Validate → scope is the canonical shelf because the skill gates work at PRD intake—before build execution—by clarifying boundaries and risks. Scope subphase matches the first checklist pillar (over-broad changes, targeted approach) and the confirm-before-code contract.
Where it fits
You drop a feature PRD path and need the agent to flag over-broad refactors before you commit to the milestone.
The PRD is approved verbally but you want alignment checks against existing hooks and providers before edits land.
Success criteria in the PRD are vague; precheck forces explicit test coverage questions before implementation merges.
How it compares
Use this checker workflow instead of ad-hoc “implement this doc” prompts that skip dependency and regression analysis.
Common Questions / FAQ
Who is prd-implementation-precheck for?
Solo and small-team builders who delegate PRD-based features to coding agents but want structured review before any files change.
When should I use prd-implementation-precheck?
Use it in Validate when scoping a feature PRD, in Build when turning an approved spec into code, and in Ship when the PRD’s testing section needs clarity before merge.
Is prd-implementation-precheck safe to install?
It encourages reading and editing your repo after your explicit confirmation; check the Security Audits panel on this page and treat the precheck pause as your control point.
SKILL.md
READMESKILL.md - Prd Implementation Precheck
# PRD Implementation Precheck A skill that performs mandatory preflight review before implementing PRDs, ensuring issues are caught before coding begins. ## Overview Instead of blindly implementing a PRD, this skill: 1. Reviews the PRD for scope, alignment, dependencies, and risks 2. Presents findings and questions to the user 3. Waits for confirmation before proceeding 4. Implements with minimal, consistent changes ## Installation ```bash mkdir -p ~/.claude/skills ln -s ~/Documents/code/GitHub/agent-playbook/skills/prd-implementation-precheck ~/.claude/skills/prd-implementation-precheck ``` ## Usage ```bash # Ask to implement a PRD "Implement the PRD at docs/feature-prd.md" # The skill will: # 1. Read and analyze the PRD # 2. Present precheck report with questions # 3. Wait for your confirmation # 4. Implement after approval ``` ## Precheck Checklist | Category | What's Checked | |----------|---------------| | **Scope** | Over-broad changes? Suggest targeted approach | | **Alignment** | Conflicts with existing patterns? Propose alternatives | | **Dependencies** | Missing hooks/providers/data sources? | | **Behavior** | Flows and edge cases specified? | | **Risks** | Performance, regression, migration issues? | | **Testing** | Success criteria and test coverage clear? | ## Workflow ``` ┌─────────────────────────────────────────────────────────────┐ │ PRD Implementation │ ├─────────────────────────────────────────────────────────────┤ │ │ │ 1. Locate PRD → Read all referenced files │ │ 2. Precheck → Run checklist, identify issues │ │ 3. Present → Show findings, ask questions │ │ 4. Confirm → User approves or updates PRD │ │ 5. Implement → Minimal, consistent changes │ │ 6. Validate → Tests or manual verification │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ## Output Example ```markdown ## Precheck Report for {PRD} ### Intent {1-2 sentence summary} ### Blockers - [ ] Blocker 1 - [ ] Blocker 2 ### Questions 1. Question about scope? 2. Question about dependencies? ### Risks - Risk 1 - Risk 2 ### Recommendation Proceed as-is, or update the PRD first? ``` ## Benefits | Problem | Solution | |---------|----------| | Implementing unclear PRDs | Precheck catches gaps | | Scope creep | Identified early | | Breaking existing patterns | Flagged before coding | | Missing dependencies | Found before implementation | | Unclear success criteria | Clarified upfront | ## License MIT --- name: prd-implementation-precheck description: Implement PRDs/specs with a mandatory precheck review before coding. Use when a user asks to implement a PRD/feature spec/requirements doc or says "implement PRD/spec". Perform a preflight review, raise questions on scope/consistency/risks, then implement after confirmation. allowed-tools: Read, Write, Edit, Bash, Grep, Glob, AskUserQuestion metadata: hooks: after_complete: - trigger: self-improving-agent mode: background reason: "Learn from implementation patterns" - trigger: session-logger mode: auto reason: "Log PRD implementation activity" --- # PRD Implementation Precheck ## Overview Perform a short PRD precheck, present issues and questions, then implement only after the user confirms or adjusts the PRD. ## Workflow 1. Locate the PRD and any referenced files. 2. Precheck the PRD and summarize intent in 1-2 sentences. 3. List findings and questions (blockers first), then ask for confirmation to proceed. 4. After confirmation, implement the PRD with minimal, consistent changes. 5. Validate (tests or manual steps) or state what was not run. ## Precheck Checklist ### Basic Checks - **Scope**: Identify over-broad changes; suggest a smaller, target