backend-service-spec-bootstrap

Reverse-engineer backend service source code into verified specifications.

Updated May 27, 2026
One-click install
npx skills add https://github.com/santanapol/agent-skills --skill backend-service-spec-bootstrap
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: backend-service-spec-bootstrap
Source: https://github.com/santanapol/agent-skills/tree/main/.cursor/skills/backend-service-spec-bootstrap
Command: npx skills add https://github.com/santanapol/agent-skills --skill backend-service-spec-bootstrap

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Backend services with existing legacy code and scattered, outdated documentation often lack a centralized, reliable specification for spec-driven development, leading to wasted time reconciling conflicting docs, guessing business logic from stale notes, and risky drift between code and documentation.

Core Features & Use Cases

  • Full source code reverse-engineering: Reads every file in a backend service's src/ directory to capture actual behavior, business rules, and side effects, rather than relying on outdated legacy docs.
  • Scattered doc consolidation: Merges docs spread across package docs/ folders into a standardized central spec structure aligned with team conventions.
  • Drift detection and resolution: Identifies mismatches between code, OpenAPI contracts, and legacy documentation, with a gated workflow to resolve all drift before finalizing specs.
  • Automated consistency checks: Includes a reference implementation for a spec:consistency CI gate that validates cross-doc links, shared constants (like role lists and password policies), and alignment between prose and code.
  • Re-audit lifecycle: Provides a formal process for re-verifying implemented specs to catch drift over time, without ad-hoc patching that leaves specs in an unreliable state. Use case: A team maintaining a legacy auth service with code in backend/auth/ and docs scattered across backend/auth/docs/ can use this skill to produce a verified, implemented spec in docs/specs/backend/auth/ ready for spec-driven feature development.

Quick Start

Use the backend-service-spec-bootstrap skill to bootstrap a complete, verified spec for your legacy backend service by confirming its package path when prompted.

Frequently Asked Questions about backend-service-spec-bootstrap

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

FAQPage Schema
How do I reverse-engineer specifications from legacy backend code?

To reverse-engineer specifications from legacy backend code, the skill scans every file in the `src/` directory to capture actual behavior and business rules, consolidating scattered documentation into a standardized central spec structure.

How do I detect drift between backend code and outdated documentation?

Drift detection identifies mismatches between legacy code, OpenAPI contracts, and outdated documentation. It enforces a gated workflow to resolve all detected drift before finalizing the production-ready implemented specifications.

What is the best way to consolidate scattered backend service documentation?

The best way to consolidate scattered backend documentation is merging docs spread across package `docs/` folders into a standardized central spec structure. This approach aligns with team conventions and ensures end-to-end behavioral traceability.

Can I automate consistency checks for cross-doc links and shared constants?

Yes, you can automate consistency checks using a reference implementation for a `spec:consistency` CI gate. This gate validates cross-doc links, shared constants like role lists, and alignment between prose and code.

How do I bootstrap a spec for a legacy backend service with no existing documentation?

Bootstrapping a spec for a legacy backend service with no documentation requires full source code reverse-engineering. It extracts actual behavior directly from the source files and applies gated human approval for spec finalization.

When should I use spec hardening for backend services?

You should use spec hardening when backend services have thin draft specs or scattered outdated docs. It consolidates documentation, detects code drift, and hardens specs to a production-ready implemented status through mandatory gated human approval.