Darrenbenson Sdlc Studio Sdlc Studio

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.

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.

Quick Start

/sdlc-studio help                    # Show command reference
/sdlc-studio status                  # Check pipeline state and next steps
/sdlc-studio review                  # Unified PRD/TRD/TSD review
/sdlc-studio upgrade --dry-run       # Preview schema upgrade
/sdlc-studio prd generate            # Create PRD from codebase
/sdlc-studio trd generate            # Create TRD from codebase
/sdlc-studio epic                    # Generate Epics from PRD
/sdlc-studio story                   # Generate Stories from Epics
/sdlc-studio bug                     # Create or list bugs
/sdlc-studio code plan               # Plan implementation for story
/sdlc-studio code implement          # Execute implementation plan
/sdlc-studio code test               # Run tests with traceability
/sdlc-studio code verify             # Verify code against AC
/sdlc-studio code check              # Run linters and checks
/sdlc-studio tsd                      # Create test strategy document
/sdlc-studio test-spec               # Generate test specifications
/sdlc-studio test-automation         # Generate executable tests
/sdlc-studio story plan              # Create plan + test-spec, then review
/sdlc-studio story implement         # Execute story workflow (all phases)
/sdlc-studio epic plan               # Preview epic workflow (all stories)
/sdlc-studio epic implement          # Execute epic workflow (all stories)

Get Help for Any Type

/sdlc-studio {type} help             # Show help for specific type

Examples:

/sdlc-studio prd help                # PRD commands and options
/sdlc-studio epic help               # Epic generation help
/sdlc-studio bug help                # Bug tracking help
/sdlc-studio code help               # Code plan/test/verify/check help
/sdlc-studio test-spec help          # Test specification help
/sdlc-studio test-automation help    # Test automation help

Each help page shows:

• Available actions and what they do
• Prerequisites
• Output format and location
• Examples
• Next steps

When to Use

Use when asked about: PRD, TRD, epics, stories, personas, bugs, code planning, implementation, testing, test specs, test automation, project status, or 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
   • Load templates only when creating artifacts
   • Load decision files when choosing approaches (TDD, Ready status)
5. Execute Workflow: Follow step-by-step procedure in reference file
6. Update Status: Modify artifact status markers per reference-outputs.md
7. 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:

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.

Arguments

Type Reference

Command Reference

Pipeline Status

Four Pillars:

• 📋 Requirements (PRD Status) - PRD, Personas, Epics, Stories
• 💻 Code (TRD Status) - TRD, Lint, TODOs
• 🧪 Tests (TSD Status) - Coverage, E2E features
• 🔍 Reviews - Review currency, findings status

Requirements Pipeline

Persona Consultation & Chat

Technical Requirements

Bug Tracking

Development Pipeline

Testing Pipeline

Workflow Automation

State tracking: story implement creates sdlc-studio/workflows/WF{NNNN}.md to track progress across sessions. Auto-resumes from last phase if interrupted.

Workflows

For detailed step-by-step workflows, see reference files:

• reference-prd.md, reference-trd.md, reference-persona.md - PRD, TRD, Persona workflows
• reference-epic.md, reference-story.md, reference-bug.md - Epic, Story, Bug workflows
• reference-code.md - Code plan, implement, verify, check, test workflows
• reference-refactor.md - Code refactor, review workflows
• reference-tsd.md - TSD, status dashboard workflows
• reference-test-spec.md - Test specification workflows
• reference-test-automation.md - Test automation, test environment workflows

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.

Typical Workflow

Greenfield (Create Mode)

PRD → TRD → Personas → Epics → Stories
                                  │
                    ┌─────────────┴─────────────┐
                    │                           │
              TDD Path                    Test-After Path
              (test-first)                (code-first)
                    │                           │
              test-spec                    code plan
                    │                           │
              code plan                   code implement
                    │                           │
         code implement --tdd              test-spec
                    │                           │
              code verify                 test-automation
                    │                           │
              code test                     code verify
                                                │
                                            code test

Per-story choice: You choose TDD or Test-After for each story, not globally. Both paths produce the same artifacts, just in different order.

Automated Workflow (Recommended)

For streamlined development, use workflow automation:

PRD → TRD → Personas → Epics → Stories
                                  │
                          story plan --story US0001
                                  │
                          story implement --story US0001
                                  │
                          (all 7 phases run automatically)

Or at the epic level:

PRD → TRD → Personas → Epics → Stories
                                  │
                          epic plan --epic EP0001
                                  │
                          epic implement --epic EP0001
                                  │
                          (all stories processed in dependency order)

Or with autonomous execution for maximum throughput:

PRD → TRD → Personas → Epics → Stories
                                  │
                       epic plan --epic EP0001 --agentic
                                  │
                    (analyses dependencies → assigns concurrent waves)
                                  │
                       epic implement --epic EP0001 --agentic
                                  │
                    Wave 1: [US0001, US0003] concurrent
                    Wave 2: [US0002, US0004] concurrent
                    Wave 3: [US0005] sequential (hub file conflict)

--agentic analyses the dependency graph and hub file overlap to identify stories that can safely execute concurrently. Falls back to sequential for any stories with shared file conflicts.

Workflow phases per story:

1. Plan (code plan)
2. Test Spec (test-spec)
3. Tests (test-automation)
4. Implement (code implement)
5. Test (code test)
6. Verify (code verify)
7. Check (code check)
8. Review (status review)

Brownfield (Specification Extraction)

prd generate → trd generate → persona generate → epic → story generate → test-spec → test-automation → code test (VALIDATE)

Critical: The code test step validates specs against reality. Not optional.

Development Cycle

code plan → code implement → code test → code verify → code check

Status: Draft/Ready → Planned → In Progress → Review → Done

Daily Usage

/sdlc-studio status          # Visual dashboard - what needs attention?
/sdlc-studio status --brief  # Quick: Requirements 85% | Code 90% | Tests 94%
/sdlc-studio hint            # Single next step
/sdlc-studio code plan       # Plan next story
/sdlc-studio code implement  # Execute plan

See Also

Philosophy: reference-philosophy.md - Read this first. Explains Create vs Generate modes and why generate mode produces migration blueprints, not documentation.

Decisions: reference-decisions.md - Decision impact matrix, TDD decision tree, Ready status criteria, cross-stage validation checkpoints.

Configuration: reference-config.md - Project configuration options for coverage targets, story quality gates, and thresholds.

Help: help/help.md (main), help/{type}.md (type-specific), help/upgrade.md (schema upgrade)

References: reference-prd.md, reference-trd.md, reference-persona.md, reference-persona-generate.md, reference-consult.md, reference-chat.md, reference-workflow-personas.md (Requirements), reference-epic.md, reference-story.md, reference-bug.md (Specifications), reference-architecture.md (Architecture), reference-code.md (Code, Test), reference-refactor.md (Refactoring, Review), reference-review.md (Unified document review), reference-tsd.md, reference-test-spec.md, reference-test-automation.md (Test artifacts), reference-test-best-practices.md (Test pitfalls), reference-test-e2e-guidelines.md (E2E patterns), reference-upgrade.md (Schema migration)

Templates (v2 modular structure):

• Core: templates/core/*.md (prd, trd, tsd, epic, story, plan, test-spec, bug)
• Personas: templates/personas/ (persona-template, archetypes by category)
• Indexes: templates/indexes/*.md (epic, story, plan, bug, test-spec, review)
• Modules: templates/modules/trd/*.md (c4-diagrams, container-design, adr), templates/modules/tsd/*.md (contract-tests, performance-tests, security-tests), templates/modules/epic/*.md (engineering-view, product-view, test-view)
• Config: templates/config-defaults.yaml, templates/config.yaml, templates/version.yaml
• Automation: templates/automation/*.template (pytest, jest, vitest, go, xunit, junit)

Converted and distributed by TomeVault — claim your Tome and manage your conversions.