current-prd

Reverse-engineers a Product Requirements Document from an existing codebase in three phases.

Updated Mar 11, 2026
One-click install
npx skills add https://github.com/t-hasuike/CLysis --skill current-prd
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: current-prd
Source: https://github.com/t-hasuike/CLysis/tree/main/legacy-knowledge/skills/current-prd
Command: npx skills add https://github.com/t-hasuike/CLysis --skill current-prd

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Generate structured PRDs by reverse-engineering an existing codebase, turning code reality into maintainable specifications.

Core Features & Use Cases

  • Phase 1 Global Scan: collect technology stack, entry points, infrastructure, database inventory, and directory structure.
  • Phase 2 Module Analysis: trace call hierarchy, input/output contracts, DB operations, external integrations, and business rules.
  • Phase 3 Structured Output: assemble findings into a PRD mapped to the knowledge structure with phase-specific reports.

Quick Start

Provide Phase 1, Phase 2, and Phase 3 outputs for a given repository to generate a living PRD.

Frequently Asked Questions about current-prd

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

FAQPage Schema
How do I reverse-engineer a PRD from an existing codebase?

To reverse-engineer a PRD from a codebase, you provide a local repository path and optional scope to trigger a global scan, module analysis, and final assembly, generating structured markdown reports for each phase.

What is the process for generating living documentation from source code?

Generating living documentation involves a three-phase process: scanning the technology stack and directory structure, analyzing module call hierarchies and database operations, and assembling these findings into a structured Product Requirements Document.

Can I extract business rules and external integrations from a local repository?

Yes, you can extract business rules and external integrations during the module analysis phase, which traces input/output contracts and database operations to map the functional requirements of your codebase.

Does this reverse-engineering approach work for software repositories of varying sizes?

Yes, this reverse-engineering approach applies to software repositories of varying sizes, allowing you to define an optional scope to focus the analysis on specific modules or let the global scan cover the entire codebase.

What outputs do I get when reverse-engineering requirements from code?

You receive phase-specific markdown reports for the global scan, module analysis, and the final assembled Product Requirements Document, providing clear living documentation mapped to the knowledge structure.

When should I use reverse-engineering to generate requirements instead of writing them manually?

You should use reverse-engineering to generate requirements when you lack up-to-date documentation and need to turn existing code reality into maintainable specifications and structured PRDs for ongoing reference.