reverse-document

Generate GDDs, ADRs, or concept docs from existing codebases and prototypes.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Generates design and architecture documentation by reverse-engineering existing implementation, prototypes, or legacy code to create missing planning artifacts that teams can reference.

Core Features & Use Cases

  • Reverse-engineer from code to create GDDs, ADRs, or concept docs.
  • Create documentation for inherited codebases, prototypes, or newly implemented features after code delivery.
  • Use cases include onboarding teammates, aligning architecture decisions, and capturing rationale behind complex systems.

Quick Start

Run the reverse-document command with a type and path to generate the corresponding document from your codebase.

Frequently Asked Questions about reverse-document

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

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

You can generate architecture documentation from an existing codebase by reverse-engineering the implementation structure, identifying mechanics and decisions, and mapping them into standard templates like ADRs or design docs.

What is the best way to create a Game Design Document from prototype code?

Creating a Game Design Document from prototype code involves parsing paths like 'prototypes/' or 'src/gameplay/', extracting mechanics and system rationale, and mapping those elements into a formal GDD template for review.

How do I write an Architecture Decision Record for inherited legacy code?

Writing an Architecture Decision Record for inherited legacy code requires reverse-engineering the existing implementation to identify historical mechanics and decisions, then mapping them into a ready-to-review ADR format.

Can I reverse-engineer undocumented features to create concept docs?

Yes, you can reverse-engineer undocumented features by parsing the code structure to identify mechanics and decisions, then mapping them into standard concept doc templates to capture the missing rationale.

When should I reverse-engineer code into design docs instead of writing them first?

You should reverse-engineer code into design docs when working with inherited codebases, newly implemented features delivered without planning artifacts, or prototypes that need formal documentation for team onboarding and alignment.