name: game-prd-builder description: Use when turning a game concept, prototype, or brainstorm into a production-ready PRD for a video game, especially for systemic games that need core-loop definition, progression, replayability, balance constraints, MVP scope, content pipelines, or expansion hooks.

Game PRD Builder

Overview

Turn game ideas into implementable PRDs. Preserve the user's non-negotiable core rules, then expand them into systems, constraints, and production-ready scope.

Workflow

1. Lock the immutable core first.
   • Separate fixed rules from expandable systems.
   • Treat user-stated foundation rules as hard constraints unless they explicitly approve changes.
2. Translate ideas into codeable systems.
   • For each mechanic, define trigger, state, resolution, player decision, failure case, and tuning knobs.
   • Reject vague design language that cannot be implemented or balanced.
3. Build the document from top to bottom.
   • Cover product overview, design goals, target players, run structure, core loop, immutable rules, major systems, UX feedback, balance risks, MVP scope, and milestones.
4. Write game-specific sections that generic PRDs often miss.
   • Include build identity, replayability, run length targets, risk-versus-stability decisions, meta progression, difficulty layers, and future expansion hooks.
   • If the design should be theme-agnostic, separate system semantics from content skinning.
5. Validate before finalizing.
   • Remove flavor-only sections with no gameplay consequence.
   • Flag infinite scaling, dominant strategies, unwinnable states, and systems that are too broad for MVP.

Output Rules

• Preserve the user's fixed gameplay foundation.
• Prefer system interactions over isolated feature lists.
• Use requirement language that can be implemented, tested, and balanced.
• Explicitly mark in-scope, out-of-scope, and future-extension sections.
• State unresolved decisions instead of hiding them.

Reference Use

• Read references/prd-template.md to structure the final document.
• Read references/design-checklist.md before finalizing to catch common gaps.

Common Failure Modes

• Writing a software-product PRD instead of a game-systems PRD.
• Replacing the user's fixed rules with a cleaner but different game.
• Describing mechanics as fantasy without triggers, states, and constraints.
• Skipping balance risks, anti-patterns, and failure states.
• Letting future-content ideas bloat the MVP.

Example Trigger

Use $game-prd-builder to turn this roguelike board-building concept into a full PRD without changing the immutable core loop.

Game PRD Builder

A skill for turning game concepts, prototypes, and brainstorm notes into production-ready PRDs for video games.

What It Solves

Generic PRD workflows often fail on game projects in predictable ways:

• They describe the game like a software product instead of a playable system.
• They keep mechanics at the fantasy layer and skip triggers, state, resolution, and tuning knobs.
• They blur immutable core rules with optional expansion systems.
• They omit replayability, build identity, balance risks, and MVP boundaries.

game-prd-builder is designed to prevent those failures.

Best Fit

Use this skill when you need to turn any of the following into a complete game PRD:

• a rough game idea
• a brainstorm session
• a prototype ruleset
• a pitch with partial mechanics
• an existing design doc that is too vague to implement

It works best for systemic games such as roguelikes, deckbuilders, board-builders, auto-battlers, strategy games, and other content-scalable designs.

Core Principles

• Preserve the user's non-negotiable gameplay foundation.
• Translate mechanics into codeable systems.
• Separate immutable rules from expandable systems.
• Write MVP scope before long-term expansion.
• Document balance risks and unwinnable states explicitly.
• Favor system interactions over disconnected feature lists.

Skill Structure

• SKILL.md: main skill instructions and trigger conditions.
• agents/openai.yaml: UI metadata.
• references/prd-template.md: game-specific PRD structure.
• references/design-checklist.md: final review checklist.
• examples/example-prompts.md: example prompts for real usage.
• testing/red-baseline.json: baseline failure modes this skill is meant to address.
• README.zh-CN.md: Chinese documentation for distribution.

Example Prompt

Use $game-prd-builder to turn this roguelike board-building concept into a full PRD without changing the immutable core loop.

Output Expectations

A good result should:

• define the core loop and run structure clearly
• preserve fixed rules stated by the designer
• specify major systems in implementable terms
• include progression, difficulty, replayability, and expansion hooks where relevant
• flag balance risks, dominant strategies, and dead-state risks
• separate MVP from future scope

Recommended Publish Targets

• GitHub: best default choice for source distribution, versioning, issues, and discoverability.
• MCP Market or similar skill directories: useful after GitHub, once the repository is stable and documented.
• Personal site or design blog: useful only as a secondary mirror or showcase.

Minimal Release Checklist

• Ensure SKILL.md is final.
• Keep the English skill files concise and ASCII-safe where possible.
• Include this README and the Chinese documentation.
• Validate the skill folder before release.
• Add a license before publishing publicly.
• Include at least 3 to 5 example prompts.