create-epics

Translates approved game design documents and architecture into module-aligned epics with dependency-safe ordering and ADR coverage validation.

Updated Jul 16, 2026
One-click install
npx skills add https://github.com/johnatas-henrique/overdrive --skill create-epics-johnatas-henrique
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: create-epics
Source: https://github.com/johnatas-henrique/overdrive/tree/main/.opencode/skills/create-epics
Command: npx skills add https://github.com/johnatas-henrique/overdrive --skill create-epics-johnatas-henrique

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Manually creating epics from game design documents (GDDs) and architecture docs leads to inconsistent scope, missed ADR coverage, untraced requirements, and violations of layer dependency order, causing rework and build conflicts during game development.

Core Features & Use Cases

  • Automated Epic Structuring: Translates approved GDDs and architecture docs into bounded epics mapped 1:1 to architectural modules, with clear scope and ownership.
  • Compliance & Risk Validation: Automatically checks ADR coverage for all requirements, flags untraced items, and assesses engine risk per epic to avoid technical debt.
  • Dependency-Safe Processing: Enforces the correct layer processing sequence (Foundation → Core → Feature → Presentation) to prevent downstream build issues.
  • Use Case: For a 90s F1-style racing game, use this skill to turn the core vehicle physics system GDD into a fully scoped, ADR-aligned epic before breaking it into implementable stories.

Quick Start

Use the create-epics skill to generate epics for the core layer of your current game project.

Frequently Asked Questions about create-epics

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I translate game design documents into epics for structured development?

Translating game design documents (GDDs) into epics involves mapping approved architecture into bounded, module-aligned units. This process enforces dependency-safe layer sequencing and validates ADR coverage to ensure requirements traceability during pre-production.

Why does epic creation from GDDs cause downstream build conflicts in game development?

Epic creation from GDDs causes build conflicts when it violates layer dependency order. Enforcing a strict Foundation, Core, Feature, and Presentation processing sequence prevents these downstream issues and ensures architectural alignment across modules.

How do I enforce dependency-safe processing order for game development epics?

To enforce dependency-safe processing order for game development epics, apply a strict layer sequence from Foundation to Core, then Feature, and finally Presentation. This prevents downstream build issues and maintains architectural alignment.

Can I validate ADR coverage for requirements traceability in game development epics?

Validating ADR coverage for requirements traceability in game development epics is achievable. The process automatically checks architecture decision records, flags untraced requirements, and assesses engine risk per epic to avoid technical debt.

What is the best way to scope game architecture modules into bounded epics?

The best way to scope game architecture modules into bounded epics is to map them 1:1 from approved GDDs. This ensures clear scope and ownership while satisfying scope governance and risk assessment requirements.

Does automated epic structuring work for layered game projects transitioning to production?

Automated epic structuring works effectively for layered game projects transitioning to production. It translates approved GDDs into bounded epics, enforcing dependency-safe processing order and validating ADR coverage for all traced requirements.