SDLC Studio

Manage project specifications and test artifacts. Supports the full pipeline from PRD creation through Epic decomposition, User Story generation, and streamlined test automation.

This file is the always-loaded router. It carries only what is needed to route a request: philosophy gates, the Progressive Loading Guide, and pointers. The full command catalogue, argument reference, workflow diagrams, and reference index are loaded on demand from help/help.md, help/arguments.md, and help/references.md.

Critical Philosophy (Read This First)

Two modes for every artifact type:

New to Create vs Generate? Read reference-philosophy.md - it explains why these modes exist and how they differ fundamentally.

Using generate mode? You MUST read reference-philosophy.md#generate-mode first - generated specs must be validated by tests.

Generate mode is NOT documentation. It produces a migration blueprint - a specification detailed enough that another team could rebuild the system in a different technology stack. Generated specs MUST be validated by running tests against the existing implementation.

Personas are working seats, not static artifacts - goal-directed (Cooper) personas that consult, seat-score the backlog, review diffs, and hold the author != reviewer gate. Resolve one for any review: scripts/persona_resolve.py resolve --seat <role> --render review.

Operating Doctrine – onboarding to a project? Read reference-doctrine.md first. It is the project-agnostic working discipline (the skill is the operating system; RFC/CR/ADR choice; files-are-truth + reconcile-from-census; reconcile/verify/review cadence; ship-paperwork-in-the-same-commit; consult gates; TDD; cross-repo numbering; recall cross-project lessons/ before substantive decisions). A project's own agent-instructions file (AGENTS.md; Claude Code's CLAUDE.md can import it with @AGENTS.md) = this doctrine + that project's specifics; start from templates/agent-instructions.md. The cross-project lessons-learned folder is lessons/ (see help/lessons.md).

Quick Start

/sdlc-studio help                    # Full command reference (help/help.md)
/sdlc-studio status                  # Check pipeline state and next steps
/sdlc-studio hint                    # Single actionable next step
/sdlc-studio review                  # Unified PRD/TRD/TSD/Persona review
/sdlc-studio reconcile               # Fix all status drift in one pass
/sdlc-studio prd generate            # Create PRD from codebase
/sdlc-studio epic                    # Generate Epics from PRD
/sdlc-studio story                   # Generate Stories from Epics
/sdlc-studio code plan               # Plan implementation for story
/sdlc-studio code implement          # Execute implementation plan
/sdlc-studio story implement         # Execute story workflow (all phases)
/sdlc-studio epic implement          # Execute epic workflow (all stories)
/sdlc-studio project implement       # Execute all epics in dependency order

For the full catalogue (bug, cr, rfc, persona, consult, chat, trd, test-*, repo map, sync, and every flag), run /sdlc-studio help or read help/help.md.

Deterministic Entry Points (run the script, do not hand-do it)

Ids, index rows, status cascades, and AC verdicts are tool-allocated - hand-authoring any of them is an error. For a mechanical task, reach for the script first (full catalogue: reference-scripts.md):

The interactive commands (/sdlc-studio bug create and friends) are wrappers over the same allocation - a headless or consuming-project agent calls the scripts directly.

Get Help for Any Type

/sdlc-studio {type} help             # Type-specific commands, prerequisites, output, examples

Examples: /sdlc-studio epic help, /sdlc-studio code help, /sdlc-studio bug help.

When to Use

Trigger phrases - any of these should reach this skill:

• "write a PRD", "product requirements", "TRD", "technical requirements", "TSD", "test strategy"
• "break this into epics", "write a story", "acceptance criteria", "groom the backlog"
• "file a bug", "raise a CR", "write an RFC", "triage the findings"
• "plan a sprint", "run a sprint", "close the sprint", "sprint status", "what's the next step"
• "review this unit", "adversarial review", "sign this off", "two-role review"
• "write a test spec", "test automation", "verify the acceptance criteria", "mutation check"
• "reconcile the indexes", "project status", "what's outstanding", "repo map"
• any /sdlc-studio command.

Instructions

When invoked with /sdlc-studio [type] [action]:

1. Parse Command: Extract type and action from arguments
2. Load Help File: Read help/{type}.md for command-specific guidance
3. Check Philosophy: If generate mode, load reference-philosophy.md#generate-mode FIRST
4. Follow Progressive Loading:

- Load reference files only for multi-step workflows - Section-read large references: for a reference over ~400 lines (epic, story, code, outputs, decisions), read its Reading Guide / Contents first, then load ONLY the named section (Grep the anchor, then an offset read) - never whole-file-read a large reference for a single-section task - Load templates only when creating artifacts - Load decision files when choosing approaches (TDD, Ready status)

1. Execute Workflow: Follow step-by-step procedure in reference file
2. Update Status: Modify artifact status markers per reference-outputs.md
3. Validate: Check Ready criteria in reference-decisions.md before proceeding

Note: Version checks run on hint and status commands only (see those help files).

See "Progressive Loading Guide" below for detailed file loading patterns.

Progressive Loading Guide

Claude loads files progressively based on task needs. Where a cell names a section anchor, load that section only - and for any reference over ~400 lines, honour its Reading Guide instead of a whole-file read:

Template structure:

Module loading flags:

Reference file mapping:

Reference files follow the pattern reference-{domain}.md. When executing a workflow, load the reference file matching the artifact type being created or modified. Cross-domain files (reference-decisions.md, reference-outputs.md, reference-philosophy.md) load as needed for validation, status updates, and approach decisions. The full index is in help/references.md.

Type Reference

Full Reference

The catalogues that used to live inline are now loaded on demand to keep this router lean:

Error Handling

Missing prerequisites: Prompts to run earlier pipeline step (e.g., no PRD → prd, no epics → epic, no stories → story, no plans → code plan). Existing files: Warns and asks to continue unless --force. No type: Asks user which type. ID collision: Auto-increments. Open questions: Reports and pauses. Unknown language: Asks user to specify framework.

See Also

• help/help.md - the full command catalogue
• help/references.md - every reference file, generated from the filesystem
• reference-scripts.md - the script catalogue; read it before hand-doing anything mechanical
• reference-scripts-surface.md - every verb the scripts expose, generated from their parsers
• reference-doctrine.md - the operating doctrine a consuming project inherits
• reference-sprint.md - the sprint loop, with a Reading Guide for partial reads