sdlc

Software Development Lifecycle

Orchestrates the full SDLC pipeline by invoking the appropriate sub-skills in sequence. Each phase accepts the previous phase's output as input. Pass an optional phase name to enter the pipeline at a specific stage.

When to Use /sdlc vs Individual Skills

• Use /sdlc (with an optional phase name) when you want the orchestrator to run multiple phases in sequence, handle review cycles, and manage backtracking automatically.
• Use individual skills directly (e.g., /create-pr, /review-implementation) when you need a single phase and want full control over inputs and outputs without the pipeline orchestration overhead.

Load Each Phase Skill (mandatory)

Before performing any work that belongs to a pipeline phase, load that phase's skill with the skill tool.

A skill's allowed-tools, workflow, attribution steps, and gates only apply once its content is in context. Never execute a phase's actions from memory or general knowledge. This is especially true for skills that commit, push, or open PRs (create-pr, fix-issue, publish-plan, merge-pr, deploy-pr, handle-pr-ci, handle-pr-reviewer-feedback): their commit and push rules are bypassed whenever they are not loaded.

This applies at every phase transition the orchestrator makes, on every entry point and fast path. If you reach a phase that needs committing, pushing, or a PR and its skill is not yet loaded, load it before doing anything else, then follow its workflow.

Pipeline Overview

Main flow — 8 SDLC stages (entry: issue → learnings)

  Stage 1 — Issue
  /create-issue           Create a structured GitHub issue
  /review-issue           Audit completeness, clarity, and AC quality
  /qualify-issue          Drive Q&A loop with reporter until issue is fully understood
          │
          ▼
  /triage-issues          Classify and label incoming issues
  /prioritize-issues      Rank the backlog by RICE score
          │
          ▼
  Stage 2 — Needs Validation
  /create-needs-assessment Evaluate whether the feature addresses a genuine need
  /review-needs-assessment Audit evidence rigor, stakeholder coverage, alternative paths, verdict soundness
                          (gate: stop if not needed, update issue with findings)
           │
           ▼
  Stage 3 — Requirements & Research
  /create-requirements    Draft functional + non-functional requirements
  /create-cli-design      Design the CLI surface (commands, options, exit codes, example sessions); delegated by /create-requirements when the feature has one
  /review-requirements    Audit for clarity, completeness, testability, conflicts (covers cli-design.md when present)
           │
           ▼
   /create-existing-solutions  Survey prior art (libraries, products, internal code) and recommend adopt vs. build
   /review-existing-solutions  Audit search coverage, evaluation rigor, recommendation soundness
            │
            ▼
   /create-codebase-analysis  Analyze existing internal code/architecture the feature will touch; assess changeability per component
   /review-codebase-analysis  Audit coverage, accuracy, changeability rigor, impact and migration
            │
            ▼
   /create-feasibility     Assess technical, financial, and operational viability
  /review-feasibility     Audit completeness, risk coverage, go/no-go soundness
                          (gate: stop if not feasible, update issue with findings)

  Stage 4 — Design
  /create-specifications  Define architecture, data models, API contracts
  /review-specifications  Audit for ambiguities, inconsistencies, gaps
          │
          ▼
  /create-lifecycle       Document resource states, transitions, invariants, retention (resource lifecycle features; skip if no lifecycle)
  /review-lifecycle       Audit completeness, consistency, spec alignment, transition correctness
          │
          ▼
  /create-mockups        Define UI wireframes, screens, states, and flows (UI features; skip if no UI surface)
  /review-mockups        Audit coverage, usability, accessibility, consistency, spec fidelity
          │
          ▼
  /create-telemetry       Define analytics events, success metrics, funnel, telemetry
  /review-telemetry       Audit completeness, measurability, actionability, consistency
          │
          ▼
  /create-observability   Define logging, metrics, tracing, alerts, SLOs
  /review-observability   Audit completeness, actionability, coverage, overlap
          │
          ▼
  /create-plan            Phases, milestones, dependencies, risk register
  /review-plan            Audit feasibility, coverage, timeline realism
  /publish-plan           Commit plan to branch, open draft PR, comment on issue
                          (gate: wait for author sign-off before continuing)
           │
           ▼
  /validate-assumptions          Design and run minimal code experiments to verify risky technical assumptions before implementation
  /review-assumption-validation  Audit completeness, experiment quality, result rigor, and proceed/backtrack soundness
                                 (gate: backtrack if critical assumptions invalidated)
           │
           ▼
  /create-tasks-decomposition   Break plan into XS–L tasks with critical path
  /review-tasks-decomposition   Audit granularity, completeness, dependencies

  Stage 5 & 6 — Development & Testing
  /create-tests           Test plan covering acceptance criteria + edge cases
  /review-tests           Audit coverage, correctness, maintainability
          │
          ▼
  /create-implementation  Implement following spec + plan, run tests
  /review-implementation  Audit correctness, quality, security, spec alignment
          │
          ▼
   /create-documentation   Divio-structured docs (tutorial/how-to/reference/explanation)
   /review-documentation   Audit completeness, accuracy, clarity, structure
           │
           ▼
   /validate-implementation Capture visual proof on the branch and get user sign-off before the PR (no-op for non-visual changes)
           │
           ▼
    /create-pr              Open a PR: description, AC coverage, issue link, reviewers (embeds pre-captured proof)
    /validate-pr            Needs alignment: is the PR the right product; are the criteria sound
    /verify-pr              Conformance: criteria-to-code traceability + runtime proof per criterion
   /review-pr              Comprehensive code review of the PR
  /handle-pr-ci           Diagnose failing CI checks, fix, push, confirm green (repeat until passing)
  /handle-pr-reviewer-feedback  Address reviewer comments, push, re-request review (repeat until approved)
  /merge-pr               Verify approvals + CI, merge, delete branch, confirm issue closed

  Stage 7 — Deployment
  /deploy-pr              Deploy merged changes to target environment, run smoke tests, verify rollback plan
          │
          ▼
  /create-learnings       Retrospective: what went well, root causes, actions
  /review-learnings       Audit actionability, specificity, completeness, balance

  Other flows

Setup (run once per project, no dependencies on other flows)

  /sync-sdlc                   Create or update .sdlc/ by reconciling codebase with existing artifacts
  /initialize-sdlc-directory   Bootstrap .sdlc/ structure and populate templates (called automatically by sync-sdlc)
  /update-sdlc-templates       Pull upstream template improvements, merge with user edits
  /configure-labels            Configure the standard label taxonomy in the GitHub repository

Project context (invoke when establishing or revising project-level context that features align to)

  /create-project        Interview the user to populate the core .sdlc/context/ files for a new or empty project
  /review-project        Audit the context files for completeness, consistency, clarity, actionability
  /identify-feature-opportunities  Generate and rank new feature opportunities from the software surface and signals (bottom-up discovery feeding roadmap)
  /create-goals          Define objectives, key results, and KPIs the project aligns to
  /review-goals          Audit measurability, ownership, alignment, focus
  /create-roadmap        Sequence initiatives across Now/Next/Later horizons, aligned to goals
  /review-roadmap        Audit alignment, sequencing, focus, horizon discipline, currency
  /create-service-levels  Define SLOs, SLIs, SLAs, and error budgets for the service
  /review-service-levels  Audit measurability, coverage, error-budget policy, alignment

  Greenfield continuation: once the roadmap is reviewed, enter the main flow at the
  requirements stage with the first Now initiative as the feature brief, skipping
  create-issue (the requirements skill creates a p-prefixed pending feature; promote
  it to an issue later via /create-placeholder-issue)

Bug fix fast path (entry: bugfix)

  /check-duplicates        Search for duplicate issues and existing fix PRs
  /reproduce-issue         Bug report: create worktree, reproduce, record "before" video, post results
  /fix-issue               Orchestrator: check-duplicates → reproduce-issue → create-implementation → validate-implementation → create-pr
                           (validate-implementation replays the reproduce-issue before-command on the fixed code
                            to capture a comparable after recording; create-pr embeds the pair)
                           (escalates to main flow at requirements if the fix is non-trivial)

Cross-cutting records (invoke at any point in any flow)

  /create-domain-model    Model an unfamiliar domain (entities, relationships, glossary, invariants) as a one-off
  /review-domain-model    Audit entity coverage, relationship correctness, vocabulary, invariants, boundaries
  /create-question        Record an open question with context, answerer, impact, needed-by date
  /review-question        Audit specificity, answerability, impact; record the resolution
  /create-assumption      Record an assumption with basis, risk, and validation plan
  /review-assumption      Audit specificity, basis quality, risk, validation adequacy
  /create-decision        Record an architectural/implementation decision with context
  /review-decision        Audit clarity, reasoning quality, consequence coverage
  /supersede-decision     Mark a decision as superseded by a newer one (old-decision new-decision)

Cross-cutting guard (runs automatically before every phase via the Linked-PR Guard)

  /check-linked-pr        Detect a PR someone else linked to the current issue; offer continue / stop / review

Maintenance (entry: maintenance — run periodically, independent of any feature)

  Coordinated audit
  /audit-sdlc                Run multiple audit skills and produce a unified findings report

  Individual audit skills (also available via /audit-sdlc)

  Diagnose — surface what is risky or actively unstable
  /audit-dependencies         Audit dependencies for CVEs, outdated versions, unmaintained packages, and license issues
  /audit-security             Scan code for hardcoded secrets, injection risks, missing auth checks, and insecure patterns
  /analyze-git-churn          Identify high-churn files and generate improvement suggestions

  Harden — reduce structural risk before changing code
  /find-complexity-hotspots   Find functions and modules with high cyclomatic complexity, excessive length, or deep nesting
  /find-type-gaps             Identify missing type annotations in Python, TypeScript, and JavaScript
  /find-coverage-gaps         Identify files with missing or insufficient test coverage, ranked by churn and complexity

  Clean — remove what no longer belongs
  /find-dead-code             Find unused functions, classes, variables, exports, feature flags, and config keys
  /find-code-duplication      Identify copy-pasted blocks and near-duplicate logic to extract into shared helpers

  Document — record what remains
  /find-documentation-gaps    Find public APIs, CLI commands, and config keys that lack documentation

  Observe — monitor production health and surface runtime issues
  /observe-production         Check SLOs/SLIs, review error rates, latency, and throughput for deployed features
  /audit-observability        Identify missing logging, metrics, tracing, and alerting for production services

Fast paths               Abbreviated sequences from the main flow for small,
                          well-understood changes (see "Fast Paths for Small Work")