game-reverse-document

Reverse-engineer game codebases into design documents and architecture ADRs.

23|2|Updated Mar 25, 2026
One-click install
npx skills add https://github.com/AlterLab-IEU/AlterLab_GameForge --skill game-reverse-document
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: game-reverse-document
Source: https://github.com/AlterLab-IEU/AlterLab_GameForge/tree/main/skills/workflows/game-reverse-document
Command: npx skills add https://github.com/AlterLab-IEU/AlterLab_GameForge --skill game-reverse-document

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Reverse-engineers codebases to generate human-readable design documentation that captures intent, architecture, and game systems directly from the source.

Core Features & Use Cases

  • Cross-engine analysis: detects game systems (movement, combat, UI, progression) and maps their interactions to a living design document.
  • Output formats: produces a design document, an Architecture Decision Record, and a concept overview to guide further development.
  • Three-phase workflow: project scan, system detection, mechanics extraction, with dependency mapping and gap identification.

Quick Start

Run the workflow on your codebase to generate a reverse-engineered design document.

Frequently Asked Questions about game-reverse-document

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

FAQPage Schema
How do I generate game design documentation from an existing codebase?

To generate game design documentation from a codebase, this Skill scans your source code to detect systems like movement and combat, then extracts mechanics to produce design documents and architecture decision records. It traces every claim to concrete files and marks uncertain intent as [UNVERIFIED].

What is reverse-engineering a game codebase for design docs?

Reverse-engineering a game codebase for design docs means analyzing source code to automatically capture game intent, architecture, and systems. The process detects cross-engine mechanics and maps their interactions into a living design document, concept summaries, and tunable parameter lists.

Can I use this to extract game mechanics from any indie-game engine?

Yes, you can extract game mechanics from indie-game projects across different engines. The workflow applies a three-phase scan to detect systems, map dependencies, and identify gaps, producing architecture ADRs and concept overviews directly from the source files.

What's the best way to document undocumented game architecture?

The best way to document undocumented game architecture is running an automated reverse-engineering workflow that scans code, detects cross-system interactions, and enumerates dependencies. This produces a human-readable design document that captures intent and architecture without manual tracing.

Does the generated design doc trace back to specific source files?

Yes, the generated design doc traces every claim back to concrete source files. Requirements for the documentation include mapping cross-system interactions, enumerating tunable parameters and dependencies, and explicitly marking any uncertain intent as [UNVERIFIED] to ensure accuracy.

What are the limitations of reverse-engineering game code into design docs?

A limitation of reverse-engineering game code is that it cannot perfectly infer original design intent, marking uncertain mechanics as [UNVERIFIED]. It relies entirely on the existing source code, so missing or highly obfuscated files may result in incomplete system detection and gap identification.