reverse-document

Generate design or architecture documentation by analyzing existing implementation.

Updated Mar 28, 2026
One-click install
npx skills add https://github.com/scomofo/dragon-forge --skill reverse-document-scomofo
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: reverse-document
Source: https://github.com/scomofo/dragon-forge/tree/main/.agents/skills/reverse-document
Command: npx skills add https://github.com/scomofo/dragon-forge --skill reverse-document-scomofo

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Reverse-documentation helps you recover missing game design or technical documentation by analyzing how the code and prototypes actually behave, so you can write docs that reflect reality rather than guesswork.

Core Features & Use Cases

  • Generates design documentation (GDD) by extracting mechanics, rules, formulas, and state/progression behaviors directly from implementation.
  • Generates architecture documentation (ADR) by identifying technical patterns and trade-offs (e.g., coupling, serialization approach, performance constraints) from the codebase.
  • Generates concept documentation by analyzing prototypes to capture the core mechanic, emergent gameplay patterns, and feasibility insights.
  • Interactive intent clarification by asking targeted questions about “why” before writing anything that asserts rationale.

Quick Start

Run reverse-document with the target type and path you want analyzed, for example: instruct the AI to generate a design doc from combat system code under src.

Frequently Asked Questions about reverse-document

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

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

To generate design documentation from existing game code, you analyze the implementation to extract mechanics, rules, formulas, and state behaviors, then formalize these patterns backwards into a structured game design document.

What is reverse documentation for inherited codebases?

Reverse documentation for inherited codebases is the process of analyzing existing implementation behaviors and working backwards to produce accurate architecture or design docs that reflect actual code reality rather than guesswork.

How do I create architecture decision records from an existing codebase?

You create architecture decision records by analyzing the codebase to identify technical patterns, coupling, serialization approaches, and performance constraints, extracting the trade-offs to formalize ADRs.

Can I analyze prototypes to capture emergent gameplay patterns and feasibility?

Yes, you can analyze prototypes to generate concept documentation that captures the core mechanic, emergent gameplay patterns, and feasibility insights by working backwards from the implemented prototype behavior.

Does generating documentation from code require clarifying design intent first?

Generating documentation from code requires interactive intent clarification, asking targeted questions about rationale before writing anything, ensuring asserted design decisions are confirmed by the user prior to repository writes.

What are the limitations of reverse documenting code into specs?

A limitation of reverse documenting code is identifying unclear intent areas where the rationale behind implementation choices is ambiguous, requiring structured argument parsing and explicit user confirmation before finalizing docs.