Open GDD. For AI Agents.
Escape vibe coding chaos. Turn a game idea into a 13-chapter, reviewable real GDD. Agents work one chapter at a time, and your team can review every change in Git.
Changelog. Markdown files. People.
Everything is reviewable: version history, Markdown files, and who maintains it.
Author & Links
Connect with the maintainer and follow updates.
A chaptered GDD template designed for agents.
13 standalone Markdown chapters you can version, review, and cite. Give an agent a chapter slug, and it stays scoped—so changes stay reviewable.
Standalone by design
Each chapter is its own file, so iteration stays precise and reviewable.
Structure beats vibes
The outline prevents blind spots and aligns teams on scope, constraints, and terms.
Promptable without loss
Feed only the chapter you need, keep context tight, and reduce token waste.
Use the tools you already ship with.
Open GDD is just Markdown in Git—so it fits into your existing AI and review workflow.
License clarity and commercial boundaries.
Know what you can reuse, what you own, and what you’re responsible for when you ship. Template repo: https://github.com/wanghaisheng/GDDMarkdownTemplate
Vibe Coding (Downstream Symptom)
Why AI game projects drift without a real GDD
Downstream: Vibe Coding Crisis
Fast prototypes today, messy rework tomorrow.
- Context drift: the agent forgets decisions and contradicts systems.
- System mismatch: mechanics, economy, levels, and content don’t align.
- Unreviewable changes: no chapter boundaries, no clean diffs, no ownership.
- Token waste: you paste everything just to fix one small thing.
Upstream: Open GDD → Real GDD
Build the bridge first: a chaptered spec agents can cite and follow.
- Chapter-level context: cite a slug instead of re-explaining everything.
- Consistent decisions: gameplay, content, AI, and tech stay aligned.
- Reviewable workflow: diffs, PRs, and approvals become normal again.
- Lower token costs: send only what the agent needs.
What Breaks in AI Game Dev Without a Spec
Most projects don’t fail at coding. They fail at alignment across gameplay, content, economy, and compounding decisions. Open GDD turns an idea into a spec you can execute and review.
Context Drift
Without a stable reference, the agent re-invents decisions and your design contradicts itself.
Hidden Assumptions
Difficulty curves, economy constraints, performance budgets, and edge cases explode later as bugs.
Unreviewable Edits
Big prompts create big edits. Without chapter boundaries, it’s hard to review, rollback, or delegate safely.
The Prototype Wall
It “looks playable”, but without data schemas, rules, and contracts, it can’t become a real production plan.
It’s written for humans—and structured for agents.
Coverage by Default
The 13-chapter outline prevents blind spots: gameplay, UI, AI, tech, and production considerations.
Markdown-First Collaboration
PR reviews, diffs, and merge conflicts are solvable. Your doc becomes a real asset, not a PDF tomb.
Agent-Friendly Granularity
Standalone chapters let you prompt and revise without drowning an agent in a single giant file.
Production-Ready Appendices
Assets lists, terminology, KPI definitions, and checklists live where teams actually update them.
A GDD that AI can actually execute.
Indie Game Makers
Turn a vague idea into a structured doc you can iterate daily.
Design & Narrative Teams
Keep mechanics, story, UI, and tuning in sync across roles.
Producers & Leads
Make scope, dependencies, and approvals explicit before building.
AI-Assisted Studios
Feed chapters to agents without losing context or structure.
What You Get
A complete, reviewable structure—chapter by chapter.
13 Structured Chapters
From Overview to Technical, UI, AI, and Appendices—no gaps.
Markdown-First
Diffable, mergeable, searchable. Works with any workflow.
AI-Ready Prompts
Each chapter is designed to be expanded by an agent safely.
Team Alignment
Make decisions visible, traceable, and easy to review.
13 Chapters. Zero Lock-in.
Each chapter is a standalone Markdown file—easy to version, easy to review, easy to feed to AI agents without losing structure.
Generate a real GDD from Open GDD with AI
Work one chapter at a time: citeable, reviewable, versioned.
Copy the template into your repo
Start from your game idea and keep the 13 chapters as your single source of truth.
Ask AI for minimum reviewable detail
Generate chapter-by-chapter. Capture goals, constraints, examples, and key numbers first.
Review and lock decisions
Review diffs, make trade-offs, and turn assumptions into explicit rules and data.
Drive AI tools with chapter citations
Reference /docs/{slug} in prompts so Cursor/Claude Code/agents implement within constraints.
We’ll productize this workflow: generate a real GDD fast, then expand into game dev driven from the GDD.
Join the High-Velocity Builders
Get updates to the Open GDD template, new chapter guides, and workflow examples.
Open GDD, Real GDD, and how to use them with AI.
Open GDD is a public 13-chapter structure and writing template. A real GDD is your project-specific version: decisions made, numbers filled, reviewable and executable.
Yes—treat it as downstream acceleration. Use Open GDD to lock key decisions first, then let AI implement and expand within those constraints. Vibe coding without an upstream spec is what creates the "vibe coding crisis".
Start with chapters that set direction and scope: core loop, audience/platform, progression/economy, content/levels, then tech and production planning. Keep each chapter at "minimum reviewable detail".
Give your idea and constraints, and ask the agent to fill one chapter at a time. Require concrete examples, numbers, and tables where relevant. Review diffs chapter-by-chapter to prevent long-form hallucination.
Use chapter slugs as citations in prompts: "only follow /docs/{slug} constraints." Convert each chapter into executable tasks: data schemas, rules, UI requirements, asset lists, and integration contracts.
Both. Studios get alignment and handoff; indies get focus and less rework. For small games, mark non-essential chapters as N/A or "later".
No. Write just enough to ship a first playable, then expand as you validate. The point is to keep a clear upstream reference for every iteration.
Not if it’s chaptered. Open GDD is structure: fill the minimum, cite chapters in prompts, and review changes as diffs to reduce token cost and rework.