# Implement PRD and Issue Work

Detailed requirements can still produce inconsistent implementation and verification. This skill executes PRD or issue work with regular checks, final testing, review, and commit.

## Install

```bash
npx skillstore add mattpocock/implement
```

## Metadata

- Status: approved
- Slug: mattpocock-implement
- Skillstore revision: r2
- Version status: missing
- Tree hash: 94d4c8fc5ce95caea6bb4962be6834cfc11ef43cb3b5f24f71cd1f1bb1f3565b
- Author: mattpocock
- GitHub username: mattpocock
- License: MIT
- Repository: https://github.com/mattpocock/skills/tree/main/skills/engineering/implement/
- Ref: ebdfe608f5de2b66ff37ab4af12af8ac4f5e8006
- Supported tools: Claude, Codex, Claude Code
- Audit status: complete
- Agent install advisory: allowed
- Manual install advisory: allowed
- Artifact signature: available
- Audit attestation: unavailable
- Human verification: not\_verified
- Quality score: 77
- Quality tier: bronze
- Public page: https://skillstore.pages.dev/skills/mattpocock-implement
- Manifest: https://skillstore.pages.dev/api/skills/mattpocock-implement/manifest

## Capabilities

- Implements work described in a PRD or set of issues.
- Uses the TDD workflow where possible at pre-agreed seams.
- Runs type checking and focused test files regularly during implementation.
- Runs the full test suite once after implementation is complete.
- Uses the code review workflow after completing the work.
- Commits completed work to the current branch.

## Use Cases

- Deliver a Product Requirement: Implement a defined feature from its PRD, verify it incrementally, review the result, and commit the completed work.
- Resolve a Scoped Issue Set: Complete related repository issues while keeping tests and type checks active throughout the implementation.
- Execute Approved Engineering Work: Apply an agreed implementation process with TDD seams, final validation, code review, and a branch commit.

## Prompt Templates

### Implement One Issue

```
Implement [issue]. Run type checking and focused tests regularly. Run the full test suite, review the result, and commit the completed work.
```

### Build from a PRD

```
Implement [PRD] against [acceptance criteria]. Use TDD at the agreed seams. Verify focused tests throughout, then run full tests, review, and commit.
```

### Complete Related Issues

```
Implement issues [list] in dependency order. Keep each change scoped and verified. Complete full testing and code review before committing to the current branch.
```

### Implement a Cross-Cutting Change

```
Implement [requirement] across [modules]. Apply TDD at [agreed seams] and preserve [constraints]. Validate incrementally, review all changes, then commit.
```

## Limitations

- Requires a clear PRD or issue set from the user.
- Does not define project-specific commands, dependencies, or acceptance criteria.
- References TDD and code review workflows that must be available separately.
- Commits to the current branch, so users should confirm the branch and staged changes.

## Best Practices

- Provide the complete PRD, issue text, and acceptance criteria before implementation.
- Agree on TDD seams and project verification commands before work begins.
- Confirm the current branch and staged files before allowing the final commit.

## Anti Patterns

- Starting implementation from vague requirements without acceptance criteria.
- Delaying all focused tests until the full suite runs at the end.
- Mixing unrelated refactors into the requested implementation.

## Security Audit

- Audited at: 2026-07-23T19:01:52.515\+00:00
- Summary: The skill contains only prompt instructions and no executable code. No static findings or semantic evidence of prompt injection, data exfiltration, or malicious intent were found.

## Stats

- Views: 0
- Downloads: 4
- Favorites: 0
- Popularity score: 0