Agent skill

Prd V07 Epic Scoping

by mattgierhart in mattgierhart/PRD-driven-context-engineering

Transform v0.6 specifications into context-window-sized work packages (EPICs) during PRD v0.7 Build Execution.

MITAuto-check: notesProduct & Project Management

Install Prd V07 Epic Scoping

skills CLI
$ npx skills add mattgierhart/PRD-driven-context-engineering --skill prd-v07-epic-scoping -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install mattgierhart/PRD-driven-context-engineering prd-v07-epic-scoping --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/mattgierhart/PRD-driven-context-engineering.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/prd-v07-epic-scoping .claude/skills/prd-v07-epic-scoping && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
prd-v07-epic-scoping
GitHub stars
180
Token cost
~4.3k tokens
SKILL.md length
1,084 words
Files
4 (incl. references, assets)
Skills in repo
45
Repo updated
First seen
Licence
MIT

At a glance

Transform v0.6 specifications into context-window-sized work packages (EPICs) during PRD v0.7 Build Execution.

  • Works in 5 steps: EPIC created → git checkout -b… → Work happens → Commits reference IDs in… → Checkpoints → Commit with state saved in… → …
  • Requests to create epics
  • SKILL.md covers Consumes, Produces, Core Concept: Epic = Context… and Sizing Rules, plus 10 more sections
  • Calls supabase and git

What it does

Prd V07 Epic Scoping is an agent skill from mattgierhart/PRD-driven-context-engineering. Transform v0.6 specifications into context-window-sized work packages (EPICs) during PRD v0.7 Build Execution. Triggers on requests to create epics, scope work, break down implementation, or when user asks "create epics", "scope work", "break down work", "context window sizing", "what to build first?", "implementation planning", "epic breakdown". Consumes API-, DBT-, FEA-, ARC-. Outputs EPIC- entries with objectives, ID references, dependencies, and context windows. Feeds v0.7 Test Planning.

Its SKILL.md is about 4.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including reference files and assets (for example `assets/epic.md`, `references/dependency-mapping.md` and `references/examples.md`).

It sits in Product & Project Management, covering Context engineering, PRD writing and User stories. It works with dbt. The repository describes itself as: PRD-Led Context Engineering — Memory as Infrastructure. An ontology layer for product teams building products that solve real problems — with AI agents that remember. Gated PRD… The licence is MIT.

When your agent uses it

  • Requests to create epics
  • Break down implementation
  • User asks create epics
  • Break down work

Example prompts

  • “create epics”
  • “scope work”
  • “break down work”
  • “/prd-v07-epic-scoping”

Requirements

  • Pre-approved tools (allowed-tools): Read, Write, Edit, Glob, Grep, Bash

Workflow steps

5 steps, taken from the first numbered list in SKILL.md.

  1. EPIC created → git checkout -b epic/EPIC-{NUMBER}-{slug}
  2. Work happens → Commits reference IDs in messages
  3. Checkpoints → Commit with state saved in EPIC Section 1
  4. EPIC complete → PR opened
  5. PR merged → Branch deleted, EPIC marked Complete

What it can do on your machine

Read from SKILL.md and the folder at commit 30ed1b0. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • Edit
    • Glob
    • Grep
    • Bash

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • supabase
    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use supabase and git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Prd V07 Epic Scoping loads about 4.3k tokens when it runs, and up to ~6.8k if it reads all its reference files. Until then it costs about 129 tokens; SKILL.md has 1,084 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~129
When it runs · the whole SKILL.md, loaded when a task matches
~4.3k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~6.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Read, Write, Edit, Glob, Grep, Bash

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from mattgierhart/PRD-driven-context-engineering at commit 30ed1b0, republished under its MIT licence (© mattgierhart). 1,084 words, ~4,296 tokens.

Download SKILL.mdSave it as .claude/skills/prd-v07-epic-scoping/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
prd-v07-epic-scoping
description
Transform v0.6 specifications into context-window-sized work packages (EPICs) during PRD v0.7 Build Execution. Triggers on requests to create epics, scope work, break down implementation, or when user asks "create epics", "scope work", "break down work", "context window sizing", "what to build first?", "implementation planning", "epic breakdown". Consumes API-, DBT-, FEA-, ARC-. Outputs EPIC- entries with objectives, ID references, dependencies, and context windows. Feeds v0.7 Test Planning.
allowed-tools
Read, Write, Edit, Glob, Grep, Bash
context
fork

Epic Scoping

Position in workflow: v0.6 Technical Specification → v0.7 Epic Scoping → v0.7 Test Planning

Consumes

This skill requires prior work from v0.6 Technical Specification:

  • API-* endpoint contracts (from v0.6 Technical Specification) — Endpoints define what must be built; API count signals complexity
  • DBT-* data model specifications (from v0.6 Technical Specification) — Data entities and relationships inform natural boundaries
  • ARC-* architecture decisions (from v0.6 Architecture Design) — System structure, module boundaries, and integration patterns define scoping boundaries
  • FEA-* feature entries with MVP-SCOPE (from v0.3 Features Value Planning) — MVP boundary determines EPIC scope; post-MVP features defer to backlog
  • Existing EPIC-* entries (if brownfield) — Inherited work packages constrain and sequence new EPICs

This skill assumes v0.6 Technical Specification is complete with API-/DBT- entries providing implementation contracts.

Produces

This skill creates/updates:

  • EPIC-* entries (context-window-sized work packages, status-based) — Scope of work that fits in AI agent working memory with explicit dependencies, pre-load context budget, session state tracking, and acceptance criteria
  • EPIC dependency graph — Sequencing showing which EPICs must complete before others; identifies infrastructure/foundation EPICs, critical path EPICs, and optional/secondary EPICs
  • Context capsule specification — Pre-load checklist (SoT files, key IDs, code references) and working room estimate ensuring EPIC doesn't exceed 100k context tokens

All EPIC- entries are work package specifications, not confidence-based. They are:

  • Sized for context windows (3-5 APIs, 2-4 DBT tables, 1-2 UJs, <100k pre-load tokens)
  • Fully traceable (every EPIC references API-, DBT-, BR-, UJ-, TEST- from upstream)
  • Sequenced explicitly (dependencies form a DAG; no circular dependencies)
  • Deliverable-focused (measurable completion with acceptance criteria)

Example EPIC- entry (Auth Infrastructure):

markdown
EPIC-01: User Authentication
State: Planned
Lifecycle: v0.7 Build Execution
Branch: epic/EPIC-01-auth

## 0. Context Capsule
### Resource Envelope
| Dimension | Target | Notes |
|-----------|--------|-------|
| Pre-load Context | ~40k tokens | Auth SoT + API-001–005 specs + DBT-010/011 schema |
| Working Room | ~160k tokens | Plenty of space for implementation |
| Session Goal | Checkpoint C1 | Database schema complete |

### Dependencies
| Type | Items | Status |
|------|-------|--------|
| Requires | None | First EPIC — foundation |
| External | Supabase project created | Ready |
| Enables | EPIC-02 (reports), EPIC-03 (data sources) | Blocked until auth completes |

### Pre-load Checklist
- [ ] SoT/SoT.BUSINESS_RULES.md — IDs: BR-001, BR-002 (auth rules)
- [ ] SoT/SoT.API_CONTRACTS.md — IDs: API-001–005 (auth endpoints)
- [ ] SoT/SoT.TECHNICAL_DECISIONS.md — IDs: TECH-003 (Clerk), ARC-003 (JWT strategy)

## 2. Objective & Scope
Goal: Enable users to authenticate with email/password, manage sessions, and maintain security.

Deliverables:
  - [ ] User registration with email/password (API-001)
  - [ ] Login/logout functionality (API-002, API-003)
  - [ ] Session management with refresh tokens (API-004)
  - [ ] Password reset flow (API-005)
  - [ ] Users and sessions schema (DBT-010, DBT-011)

Out of Scope: Social auth (EPIC-02), team invites (EPIC-05), admin user management (EPIC-07)

## 3. Context & IDs
| Type | IDs |
|------|-----|
| Business Rules | BR-001 (email uniqueness), BR-002 (password requirements), BR-010 (auth workflow) |
| User Journeys | UJ-000 (onboarding), UJ-010 (login) |
| APIs | API-001 to API-005 |
| Data Models | DBT-010 (users), DBT-011 (sessions) |
| Architecture | ARC-003 (JWT strategy), TECH-003 (Clerk) |
| Features | FEA-010 (signup), FEA-011 (login) — both in MVP-SCOPE |
| Tests | TEST-001 to TEST-015 (auth test suite) |

## 4. Execution Plan (5 Phases)
[Phase structure from skill as is]

Related IDs: TECH-003, ARC-003, FEA-010/011, API-001–005, DBT-010/011, BR-001/002/010

Core Concept: Epic = Context Window

An EPIC is not a "big user story." It is a cognitive boundary—a scope of work that fits in working memory (human or AI). The goal is to load exactly what's needed to complete a focused task without distraction.

The question is not "How long will this take?" but "Can an agent complete this without needing more context than fits in a session?"

Sizing Rules

SizeCharacteristicsAction
Right-sized3-5 API endpoints, 2-4 DBT tables, 1-2 UJ flowsGood fit ✓
Too big>10 APIs, >5 tables, multiple unrelated featuresSplit by domain
Too smallSingle endpoint, no meaningful deliverableMerge with related

Rule of thumb: If you can't describe the EPIC's goal in one sentence, it's too big.

Context Budget Guidelines

EPICs are context capsules — work units sized for AI agent handoffs.

DimensionTargetRationale
Pre-load context<100k tokensSoT files + EPIC + code references
Working room>100k tokensSpace for tool outputs, debugging, iteration
Session goal1 checkpointClear "done" state per session

Context Monitoring: Don't estimate upfront — monitor during work. If context exceeds 100k tokens mid-session, pause and checkpoint immediately.

Splitting Signal: If you need to load >5 SoT files or >10 code files to understand the EPIC, it's probably too big.

Simplicity Signal: Resist creating more EPICs "just in case." Each EPIC adds coordination overhead (context capsule, session state, branch management, dependency tracking). If the MVP has 12 APIs and 6 tables, 3-5 EPICs is almost always sufficient. The overhead of an unnecessary EPIC is higher than a slightly larger EPIC that stays within context budget.

Branch Convention

Each EPIC gets its own branch. This creates:

  • Clear ownership (one EPIC = one branch = one PR)
  • Easy rollback (delete branch, EPIC never happened)
  • Natural checkpoint = commit

Naming: epic/EPIC-{NUMBER}-{slug}

Examples:

  • epic/EPIC-01-auth-endpoints
  • epic/EPIC-02-user-dashboard
  • epic/EPIC-03-payment-integration

Workflow:

  1. EPIC created → git checkout -b epic/EPIC-{NUMBER}-{slug}
  2. Work happens → Commits reference IDs in messages
  3. Checkpoints → Commit with state saved in EPIC Section 1
  4. EPIC complete → PR opened
  5. PR merged → Branch deleted, EPIC marked Complete
Show full SKILL.md (497 more words)Show less

Scoping Process

  1. Inventory implementation items from API-, DBT-, FEA-, ARC-

    • What must be built?
  2. Identify natural boundaries

    • Feature clusters (features that work together)
    • Data domains (tables that belong together)
    • Architectural seams (module boundaries from ARC-)
    • Surface ambiguous assignments: When an API/DBT could logically belong to either EPIC, state the ambiguity explicitly: "API-012 could belong to EPIC-02 or EPIC-03 because it serves both UJ-005 and UJ-008." Record the reasoning for the final placement in the EPIC's Context & IDs section. Do not silently assign items to whichever EPIC you encounter first.
  3. Size each potential EPIC against context window capacity

    • Can an agent hold all relevant IDs in one session?
  4. Sequence EPICs by dependencies

    • What must be built first?
    • What enables other EPICs?
  5. Create EPIC- entries with full ID references

  6. Validate: Can an agent complete this EPIC without needing more context than fits in a session?

Sequencing Framework

OrderPriorityRationaleExamples
1Infrastructure EPICsEverything depends on theseAuth, DB setup, project scaffold
2Core data model EPICsFoundation for featuresUser, Workspace, base entities
3Critical path EPICsJourneys that drive KPIsUJ- that affects KPI-001
4Supporting feature EPICsSecondary featuresSettings, admin, nice-to-haves

EPIC- Output Template

EPIC-XXX: [Epic Name]
State: [Planned | In Progress | Testing | Complete]
Lifecycle: v0.7 Build Execution
Branch: epic/EPIC-XXX-[slug]

## 0. Context Capsule
### Resource Envelope
| Dimension | Target | Notes |
|-----------|--------|-------|
| Pre-load Context | ~[N]k tokens | SoT files + EPIC + code |
| Working Room | ~[200-N]k tokens | Space for work |
| Session Goal | [Checkpoint target] | What "done" looks like |

### Dependencies
| Type | Items | Status |
|------|-------|--------|
| Requires | EPIC-YYY | Complete/Pending |
| External | [Setup needed] | Ready/Blocked |
| Enables | EPIC-ZZZ | Blocked until this completes |

### Pre-load Checklist
- [ ] SoT/SoT.[X].md — IDs: [key IDs]
- [ ] SoT/SoT.[Y].md — IDs: [key IDs]

## 1. Session State (The "Brain Dump")
### Current State
- **Last Action**: [What was just completed — reference IDs]
- **Stopping Point**: [File/line or test failure]
- **Next Steps**: [Exact instructions for next session]
- **Blockers**: [Any blockers — or "None"]
- **Decisions Made**: [Key decisions with rationale]

### Resume Instructions
[Exactly what the next session should do — or "N/A - EPIC Complete"]

## 2. Objective & Scope
Goal: [One sentence describing what this EPIC achieves]

Deliverables:
  - [ ] [Specific deliverable A]
  - [ ] [Specific deliverable B]
  - [ ] [Specific deliverable C]

Out of Scope: [What we are NOT doing in this EPIC]

## 3. Context & IDs
| Type | IDs |
|------|-----|
| Business Rules | BR-XXX, BR-YYY |
| User Journeys | UJ-XXX, UJ-YYY |
| APIs | API-XXX to API-ZZZ |
| Data Models | DBT-XXX, DBT-YYY |
| Architecture | ARC-XXX |
| Features | FEA-XXX, FEA-YYY |
| Tests | TEST-XXX to TEST-ZZZ |

## 4. Execution Plan (The 5 Phases)

### Phase A: Plan
- [ ] Context loaded
- [ ] Dependencies verified
- [ ] Strategy defined
- [ ] Branch created

**Checkpoint A**: Planning complete, branch exists.

### Phase B: Design
- [ ] Specs updated
- [ ] Architecture documented
- [ ] TEST- entries created

**Checkpoint B**: Specs drafted, tests defined.

### Phase C: Build (Context Windows)
Window 1: [Focus Area]
  - [ ] Task A
  - [ ] Task B
  - [ ] Verification: [How to confirm complete]

**Checkpoint C1**: [What exists when done]

Window 2: [Focus Area]
  - [ ] Task C
  - [ ] Task D

**Checkpoint C2**: [What exists when done]

### Phase D: Validate
- [ ] All TEST- entries pass
- [ ] Manual verification of UJ-
- [ ] Code has @implements tags
- [ ] SoT matches implementation

**Checkpoint D**: Tests green, verification complete.

### Phase E: Finish
- [ ] Temp cleanup
- [ ] SoT finalized
- [ ] Learning capture
- [ ] Resume Instructions = "N/A - EPIC Complete"
- [ ] PR ready

**Checkpoint E**: EPIC complete.

## 5. Acceptance Criteria
- [ ] All deliverables done
- [ ] All TEST- entries pass
- [ ] Resume Instructions = "N/A - EPIC Complete"
- [ ] No orphan ID references
- [ ] Branch merged or PR approved

Example EPIC- entry:

EPIC-01: User Authentication
State: Planned
Lifecycle: v0.7 Build Execution
Branch: epic/EPIC-01-auth

## 0. Context Capsule
### Resource Envelope
| Dimension | Target | Notes |
|-----------|--------|-------|
| Pre-load Context | ~40k tokens | Auth SoT + API specs + schema |
| Working Room | ~160k tokens | Plenty of space |
| Session Goal | Checkpoint C1 | Database schema complete |

### Dependencies
| Type | Items | Status |
|------|-------|--------|
| Requires | None | First EPIC |
| External | Supabase project | Ready |
| Enables | EPIC-02, EPIC-03 | Blocked until this completes |

### Pre-load Checklist
- [ ] SoT/SoT.BUSINESS_RULES.md — IDs: BR-001, BR-002
- [ ] SoT/SoT.API_CONTRACTS.md — IDs: API-001 to API-005
- [ ] SoT/SoT.TECHNICAL_DECISIONS.md — IDs: TECH-003, ARC-003

## 1. Session State (The "Brain Dump")
### Current State
- **Last Action**: N/A (not started)
- **Stopping Point**: N/A
- **Next Steps**:
  1. Create branch epic/EPIC-01-auth
  2. Begin with Phase A: Plan
  3. Load context from pre-load checklist
- **Blockers**: None
- **Decisions Made**: Using Supabase Auth per TECH-003

### Resume Instructions
> Start fresh: create branch and load context per pre-load checklist.

## 2. Objective & Scope
Goal: Enable users to sign up, log in, and manage their sessions.

Deliverables:
  - [ ] User registration with email/password
  - [ ] Login/logout functionality
  - [ ] Session management with refresh tokens
  - [ ] Password reset flow

Out of Scope: Social auth (EPIC-02), team invites (EPIC-05)

## 3. Context & IDs
| Type | IDs |
|------|-----|
| Business Rules | BR-001, BR-002 |
| User Journeys | UJ-000, UJ-010 |
| APIs | API-001 to API-005 |
| Data Models | DBT-010, DBT-011 |
| Architecture | ARC-003, TECH-003 |
| Features | FEA-010, FEA-011 |
| Tests | TEST-001 to TEST-015 |

## 4. Execution Plan

### Phase A: Plan
- [ ] Context loaded
- [ ] Dependencies verified (Supabase ready)
- [ ] Strategy: Database → API → UI
- [ ] Branch created: epic/EPIC-01-auth

**Checkpoint A**: Planning complete, branch exists.

### Phase C: Build
Window 1: Database Schema
  - [ ] Create users table with RLS
  - [ ] Create sessions table
  - [ ] Set up Supabase Auth triggers

**Checkpoint C1**: Schema deployed, migrations tested.

Window 2: API Endpoints
  - [ ] POST /auth/signup (API-001)
  - [ ] POST /auth/login (API-002)
  - [ ] POST /auth/logout (API-003)
  - [ ] POST /auth/refresh (API-004)
  - [ ] POST /auth/reset-password (API-005)

**Checkpoint C2**: All endpoints return correct responses.

Window 3: UI Integration
  - [ ] Signup form (SCR-001)
  - [ ] Login form (SCR-002)
  - [ ] Password reset flow (SCR-003)
  - [ ] Auth state management

**Checkpoint C3**: Full auth flow works E2E.

## 5. Acceptance Criteria
- [ ] All deliverables done
- [ ] TEST-001 to TEST-015 pass
- [ ] Resume Instructions = "N/A - EPIC Complete"
- [ ] UJ-000 and UJ-010 verified manually
- [ ] Branch merged

EPIC Phase Structure

Each EPIC follows 5 phases:

PhasePurposeActivities
A: PlanLoad contextRead EPIC, load referenced IDs, verify Session State
B: DesignUpdate SoTDraft/refine ID entries in SoT/ before coding
C: BuildImplementWork through Context Windows, test-first
D: ValidateVerifyRun tests, manual checks, traceability audit
E: FinishClean upUpdate SoT, archive temp/, mark complete

Anti-Patterns to Avoid

Anti-PatternSignalFix
Epic explosion20+ EPICs for MVPConsolidate; most MVPs need 3-7
One mega-EPICEverything in one EPICSplit by architectural boundary
No ID referencesEPIC without BR-, API-, DBT- linksEvery EPIC must reference SoT/
Circular dependenciesEPIC-01 needs EPIC-02 needs EPIC-01Identify shared foundation, extract to EPIC-00
Context overloadAgent can't hold full EPIC contextSplit into smaller Context Windows
Missing sequencingNo build order definedEstablish explicit dependency chain
Vague objectives"Build the backend"Specific, measurable: "Implement API-001–005"
Silent scope assumptionsEPIC assigns items without explaining boundary rationaleEvery ambiguous assignment must note "API-XXX placed here because [reason]; alternative was EPIC-YYY"

Quality Gates

Before proceeding to Test Planning:

  • All API- and DBT- entries assigned to EPICs
  • No orphaned specifications (everything has an EPIC home)
  • Dependencies form a DAG (no circular dependencies)
  • Each EPIC has clear, measurable deliverables
  • Context Windows defined for each EPIC
  • Sequencing makes sense (foundations first)

Downstream Connections

EPIC- entries feed into:

ConsumerWhat It UsesExample
Test PlanningEPIC scope defines test boundariesTEST- entries for EPIC-01 scope
Implementation LoopEPIC is execution unitWork happens inside EPIC context
Session ManagementSession State section tracks progressResume from where we left off
Progress TrackingEPIC state shows overall progress3/7 EPICs complete

Detailed References

  • Epic scoping examples: See references/examples.md
  • EPIC- entry template: See assets/epic.md
  • Dependency mapping guide: See references/dependency-mapping.md

© mattgierhart, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (references, assets) in .claude/skills/prd-v07-epic-scoping of mattgierhart/PRD-driven-context-engineering.

  • SKILL.md
  • assets/epic.md
  • references/dependency-mapping.md
  • references/examples.md

Open the folder on GitHubat commit 30ed1b0

Compare with similar skills

Prd V07 Epic Scoping next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Prd V07 Epic Scoping compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Prd V07 Epic Scoping this skillmattgierhart/PRD-driven-context-engineering180—~4.3kAutomated safety check: NotesMIT
Project Planneradrianpuiu/claude-skills-marketplace1001 repos~6kAutomated safety check: PassNone
Feature ForgeJeffallan/claude-skills12k—~1.1kAutomated safety check: PassMIT
Spec Driven Loopsickn33/agentic-awesome-skills47k1 repos~3.4kAutomated safety check: PassMIT
Spec Workflowhashgraph-online/awesome-codex-plugins1.3k—~2.1kAutomated safety check: PassApache-2.0
Ralph Tui Create Beadssubsy/ralph-tui2.5k1 repos~2.6kAutomated safety check: PassMIT

Similar skills

  • Project Planner

    adrianpuiu/claude-skills-marketplace

    Comprehensive project planning and documentation generator for software projects.

    100 GitHub starsUsed in 1 repo~6k tokens
    Product & Project ManagementAuto-check passed
  • Feature Forge

    Jeffallan/claude-skills

    Runs a structured requirements interview to produce a feature specification with EARS requirements, acceptance criteria and an implementation checklist.

    12k GitHub stars~1.1k tokensUpdated 7 days ago
    Product & Project ManagementAuto-check passed
  • Spec Driven Loop

    sickn33/agentic-awesome-skills

    Freeze PRD, technical design, and acceptance criteria before medium-to-large Codex work; coordinate agents with explicit ownership, then judge delivery from diffs, tests, and evidence.

    47k GitHub starsUsed in 1 repo~3.4k tokens
    Product & Project ManagementAuto-check passed
  • Spec Workflow

    hashgraph-online/awesome-codex-plugins

    This skill should be used when the user asks to "create a spec", "write requirements", "design a feature", "plan implementation", "use EARS notation", "create user stories", "break down tasks"…

    1.3k GitHub stars~2.1k tokensUpdated yesterday
    Product & Project ManagementAuto-check passed
  • Ralph Tui Create Beads

    subsy/ralph-tui

    Convert PRDs to beads for ralph-tui execution. An agent skill from subsy/ralph-tui.

    2.5k GitHub starsUsed in 1 repo~2.6k tokens
    Product & Project ManagementAuto-check passed
  • Convert PRDs to beads for ralph-tui execution using beads-rust (br CLI).

    2.5k GitHub starsUsed in 1 repo~2.8k tokens
    Product & Project ManagementAuto-check passed

More from mattgierhart/PRD-driven-context-engineering

All 45 skills in this repo
  • Ghm Gate Check

    mattgierhart/PRD-driven-context-engineering

    Validates gate criteria before PRD lifecycle advancement by delegating to the readiness scoring pipeline (scripts/readiness.py).

    180 GitHub stars~1.3k tokensUpdated 1 mo ago
    Auto-check: notes
  • Ghm Harvest

    mattgierhart/PRD-driven-context-engineering

    Extracts durable insights from temp/ files to SoT during EPIC Phase E.

    180 GitHub stars~1.1k tokensUpdated 1 mo ago
    Auto-check passed
  • Ghm Id Register

    mattgierhart/PRD-driven-context-engineering

    Validates and registers new SoT IDs with cross-reference integrity.

    180 GitHub stars~1.5k tokensUpdated 1 mo ago
    Auto-check passed
  • Ghm Sot Builder

    mattgierhart/PRD-driven-context-engineering

    Creates new Source of Truth (SoT) files when existing templates don't fit your needs.

    180 GitHub stars~2k tokensUpdated 1 mo ago
    Auto-check passed
  • Prd V01 Problem Framing

    mattgierhart/PRD-driven-context-engineering

    Transform vague product ideas into evidence-anchored problem statements for PRD v0.1 Spark.

    180 GitHub stars~1.7k tokensUpdated 1 mo ago
    Auto-check passed
  • Prd V01 User Value Articulation

    mattgierhart/PRD-driven-context-engineering

    Transform validated pain points into articulated user value statements for PRD v0.1 Spark.

    180 GitHub stars~1.6k tokensUpdated 1 mo ago
    Auto-check passed

Works with

Questions about Prd V07 Epic Scoping

What does Prd V07 Epic Scoping do?

Transform v0.6 specifications into context-window-sized work packages (EPICs) during PRD v0.7 Build Execution. Prd V07 Epic Scoping is an agent skill from mattgierhart/PRD-driven-context-engineering.7 Build Execution.

When should I use Prd V07 Epic Scoping?

Prd V07 Epic Scoping fits situations like: requests to create epics; break down implementation; user asks create epics; break down work.

How do I install Prd V07 Epic Scoping in Claude Code?

Run `npx skills add mattgierhart/PRD-driven-context-engineering --skill prd-v07-epic-scoping -a claude-code`. Or copy the skill folder (.claude/skills/prd-v07-epic-scoping in mattgierhart/PRD-driven-context-engineering) into .claude/skills/prd-v07-epic-scoping in your project. Claude Code loads it when a task matches its description.

How do I install Prd V07 Epic Scoping in Codex?

Run `npx skills add mattgierhart/PRD-driven-context-engineering --skill prd-v07-epic-scoping -a codex`. Or copy the skill folder (.claude/skills/prd-v07-epic-scoping in mattgierhart/PRD-driven-context-engineering) into .agents/skills/prd-v07-epic-scoping in your project. Codex loads it when a task matches its description.

Can I use Prd V07 Epic Scoping in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add mattgierhart/PRD-driven-context-engineering --skill prd-v07-epic-scoping -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/prd-v07-epic-scoping, .gemini/skills/prd-v07-epic-scoping, .github/skills/prd-v07-epic-scoping and .opencode/skills/prd-v07-epic-scoping in your project.

What does Prd V07 Epic Scoping need to run?

Going by SKILL.md and its folder, Prd V07 Epic Scoping needs the command-line tools its instructions call (supabase and git). Its frontmatter pre-approves these tools: Read, Write, Edit, Glob, Grep, Bash.

Does Prd V07 Epic Scoping access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Prd V07 Epic Scoping safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Prd V07 Epic Scoping use?

Prd V07 Epic Scoping is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Prd V07 Epic Scoping use?

About 4.3k tokens (SKILL.md is roughly 17k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 2.5k tokens, read only when the agent opens those files.

What are the alternatives to Prd V07 Epic Scoping?

Skills that share tags, products or a category with Prd V07 Epic Scoping: Project Planner (adrianpuiu/claude-skills-marketplace, 100 stars), Feature Forge (Jeffallan/claude-skills, 12k stars), Spec Driven Loop (sickn33/agentic-awesome-skills, 47k stars) and Spec Workflow (hashgraph-online/awesome-codex-plugins, 1.3k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Prd V07 Epic Scoping?

mattgierhart (a GitHub user) maintains it in mattgierhart/PRD-driven-context-engineering, which has 180 GitHub stars. The repository holds 45 skills in this directory. The repository was last updated on August 31, 2026.

Source: mattgierhart/PRD-driven-context-engineering on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.