SDLC-Docs-Engine: Standards-Driven Documentation Across the Software Lifecycle

SDLC-Docs-Engine (formerly SRS-Skills) is a modular, AI-driven toolkit for generating comprehensive, standards-compliant documentation across all phases of software development. It supports Waterfall, Agile, and Hybrid methodologies, providing IEEE/ISO-aligned documentation from strategic vision to deployment operations.

July 2026 skill-engine conformance

The active catalogue contains 154 filesystem-discovered skills across 01-strategic-vision/ through 09-governance-compliance/. templates/skill/SKILL.md is the single inactive authoring template. Every active entrypoint now follows the local portable contract in docs/skill-authoring-standard.md, and CI enforces a zero-debt baseline plus 50 routing fixtures at a top-three precision threshold of 100%.

python -X utf8 scripts/validate_skill_engine.py --baseline tests/skill-quality-baseline.json
python -X utf8 scripts/routing_smoke_test.py
python -X utf8 scripts/validate_engine.py
python -m engine validate-skills

The machine-readable baseline is not a waiver: any new finding, duplicate name, broken relative resource, catalogue-count drift, or routing miss fails the release gate.

Hybrid and regulated delivery are now documented as explicit operating models rather than implied claims:

Hybrid execution contract: docs/hybrid-operating-model.md
Regulated evidence chain: docs/regulated-evidence-model.md
Repo-wide deterministic enforcement gates: docs/deterministic-governance.md

Architecture & cross-cutting engines (updated 2026-06-21)

This engine is one of several sibling skill engines on the host. None is natively discovered any more — every engine, including this one, is consulted through the global routing table by globbing SKILL.md directly and reading the matched file(s). Cross-cutting engines are referenced (path resolved per device from the global router), never mirrored into this repo.

Design / UX visual layer → design-system-skills (C:\wamp64\www\design-system-skills). This is the single home for all design, typography, UI/UX, and visual-formatting skills plus the anti-AI-slop visual doctrine. Consult it in addition for any presentation-layer work: the VISUAL side of a UX/design specification (design systems, UI tokens, dashboard/visual quality, the look of a generated .docx). The content and structure of specs — IA, requirements, acceptance criteria, the spec document itself — stays in this engine. Phase 03 design/UX skills here describe what the design must satisfy; the design engine governs how it looks.
Finance / accounting → chwezi-accounting-doctrine (referenced, not mirrored). Any money/ledger/tax/IFRS/IAS documentation work routes to the finance engine source via its README.md router. The old "build once, mirror everywhere" finance mirror was never populated — the empty skills/finance/ shells were removed on 2026-06-21. Finance skills do not live inside this engine; only the domains/finance/ knowledge base (PCI-DSS, SOX, AML defaults) is local.
Engineering / methodology → engineering catalog engine (see "Skill Categories" below), also referenced, not mirrored.

SaaS + AI-on-SaaS + Agent Documentation Stack (May 2026)

Major SDLC documentation layer added across phases 01–09 for SaaS products, AI-on-SaaS features, agent products, AI incident response, and agent compliance attestation.

SaaS docs (16 phase-placed skills + 8 enhancements): strategic-vision (MVP scoping, moat plan, pricing/packaging spec), requirements (billing/metering spec, billing addendums), design (multi-tenancy architecture spec), operations (tenant lifecycle runbook, SLO/error-budget doc, incident response, growth experiment doc, customer success playbook, onboarding journey, lifecycle email strategy, sales enablement pack), governance (data-isolation evidence pack, trust-center pack, DPA/privacy set).

AI-on-SaaS docs (16 skills + 8 enhancements): AI feature strategy, AI feature PRD, AI data/KB spec, AI architecture spec, AI model card (EU AI Act Annex IV cross-walk), AI prompt registry, AI coding-guidelines addendum, AI eval harness spec, AI red-team plan, AI hallucination SLO, AI rollout runbook, AI cost runbook, AI responsible-AI declaration, AI Act compliance, AI data flow + DPIA, AI ADR catalogue.

Agent docs (14 skills + 11 cross-link enhancements + 12 templates): strategy (autonomy ladder L0–L5), feature PRD (seven agent clauses), action catalogue spec, agent architecture spec, multi-agent coordination spec, coding-guidelines addendum, eval spec, red-team plan (10 agent-specific attack categories), agent SLO doc, agent runbook (three kill-switches with two-person rule), rollout runbook (shadow → supervised → agentic), user disclosure pack (per-locale notification), responsible-AI addendum, ADR catalogue (14 seed ADRs).

AI incident response docs (8 skills + 8 enhancements): severity matrix (sev × tenant scope × autonomy), incident response runbook (first 5/30/120-min + 10 per-failure-class playbooks), RCA taxonomy, postmortem template, evidence pack spec, customer-comms templates per severity, regulator notification template (EU AI Act Art. 73 15-day clock, GDPR Art. 33 72-hour, KE/NG 72h, UG 24h, RW 48h, ZA ASAP), drill & game-day catalogue (7 scenarios).

Agent compliance docs (9 skills + 11 enhancements + 12 templates): SOC2 control pack (AICPA TSC CC1–CC9, A1, C1, PI1, P1–P8), ISO 27001 control pack (Annex A 2022 + ISO 42001 overlay), HIPAA control pack (§164.308/.310/.312/.316 with PHI-touch classification), compliance policy pack (7 bundled signed policies), attestation prep spec (12-mo SOC2 Type II / 6-mo ISO surveillance / 90-day HIPAA timelines), evidence pack spec (SHA-256 chain-of-custody, HIPAA 6yr / SOC2 7yr retention), agent compliance runbook, BAA + DPA templates (KE/NG/ZA/UG/RW annexes), regulator overlap matrix.

Book extractions (in book-extractions/): 7 SaaS books distilled through the docs lens, plus 6 audit documents.

Embedded Accounting Engine Additions

Game Software Delivery Stack

Game projects now route through seven phase-placed documentation skills while implementation doctrine remains in the canonical engineering game-development family:

01-strategic-vision/15-game-product-and-production-brief
02-requirements-engineering/19-game-software-requirements-specification
03-design-documentation/17-game-system-architecture-specification
04-development-artifacts/05-game-technical-implementation-specification
05-testing-documentation/09-game-test-and-player-evidence-plan
06-deployment-operations/22-game-release-and-live-operations-runbook
09-governance-compliance/30-game-delivery-evidence-and-greenlight-pack

The stack maintains GHYP/GREQ/GARCH/GIMPL/GTEST traces across player experience, gameplay state, engines/platforms, multiplayer, saves, content, performance, accessibility/localisation, security/abuse, telemetry/economy, reproducible builds, rollout and rollback. Documentation completeness never substitutes for executable builds, target-device evidence, failed-path tests or independent replication.

For any system that handles money, inventory value, payroll, tax, receivables, payables, grants, fixed assets, or financial reports, route the documentation flow through these added skills:

02-requirements-engineering/18-embedded-accounting-engine-srs/SKILL.md
03-design-documentation/16-accounting-engine-design/SKILL.md
05-testing-documentation/08-accounting-engine-test-plan/SKILL.md
06-deployment-operations/21-accounting-operations-runbook/SKILL.md

These skills specify the canonical single-engine accounting pattern: one tenant-scoped append-only ledger, one posting service, mapping-layer account resolution, reversing journals, period locks, subledger reconciliation, report rebuilds, and per-tenant integrity jobs.

Retail Operating-Model Additions

For retail, omnichannel, e-commerce, POS, merchandising, pricing, promotions, markdowns, loyalty, CRM, fulfilment, returns, store operations, shrink, vendor funding, private label, planogram, or retail dashboard projects, load:

02-requirements-engineering/retail-operating-model-srs/SKILL.md
domains/retail/references/retail-operating-model.md
domains/retail/references/finance-control-gates.md

These files extend the retail domain pack beyond catalogue/POS/checkout into a full operating-model SRS: entities, state changes, source events, interface contracts, finance/control gates, dashboard lineage, and deterministic acceptance tests. If the project touches stock value, refunds, discounts, vendor funding, POS settlement, shrink, loyalty liabilities, or financial KPIs, also route to the finance doctrine engine before release.

Active Projects

The following client projects are maintained under projects/ (gitignored — not committed to this repository). Each project has a full SDLC documentation suite generated by these skills.

Project	Domain	Methodology	AI Module	Status
AcademiaPro	Education SaaS (Uganda-first, pan-Africa)	Hybrid (Water-Scrum-Fall)	AI Module — 5 features (UGX 50K–800K/mo)	Phase 1 gate open — development ready
Medic8	Healthcare SaaS (Africa-first, global)	Hybrid (Water-Scrum-Fall)	AI Clinical Intelligence — 5 features (UGX 200K–1.5M/mo)	Phase 1 gate blocked — 7 HIGH gaps
Kulima	Farm Management SaaS (Uganda-first)	Hybrid (Water-Scrum-Fall)	AI Farm Advisor — 5 features (UGX 30K–300K/mo)	Phase 2 partial — SRS complete
LonghornERP	ERP SaaS (Uganda-first, universal)	Hybrid (Water-Scrum-Fall)	AI Intelligence — 5 features (UGX 100K–800K/mo)	Phase 1 complete — Phase 2 in progress
Maduuka	POS + Bookkeeping SaaS (Africa SMBs)	Hybrid (Water-Scrum-Fall)	AI Business Intelligence — 4 features (UGX 30K–200K/mo)	Full SDLC complete — development ready
BIRDC-ERP	Bespoke Banana Factory ERP (BIRDC/PIBID)	Waterfall (consulting)	AI Intelligence Phase 7 — 5 capabilities (lump-sum extension)	Full SDLC complete — 38 docs delivered

Project files are gitignored. Only domains, templates, and documentation tooling are committed to this repository. Engineering/methodology skills live in the sibling engineering catalog engine at C:\Users\Peter\.claude\skills, and finance/accounting lives in the sibling finance engine resolved through the global engine router. Project DOCUMENTATION-STATUS.md files within each project directory are the authoritative status reference for each engagement.

Version: v4.0.0-completion-2026-04-16. End-to-end engine kernel completion. See docs/plans/completion2026-04-16/ for the nine sub-plans and projects/_demo-hybrid-regulated/README.md for the end-to-end proof project.

What changed in v4.0

Engine kernel completion — nine deterministic gates (phase01..phase09) plus hybrid sync gate registered in the default CLI registry; 210 unit tests, ENGINE CONTRACT PASS.
End-to-end proof project — projects/_demo-hybrid-regulated/ (Uganda DPPA 2019, Water-Scrum-Fall hybrid) proves every gate passes on a realistic workload. Evidence pack ZIP committed.
Sabotage flag — python -m engine validate <project> --break-something injects deterministic findings in kernel.no_unresolved_fail_markers, phase02.smart_nfr, and phase09.traceability so CI proves gates can fail as well as pass.
CI positive + negative path — .github/workflows/engine.yml now runs both the clean demo validation and the sabotaged demo (expected to fail), guarding against silent-pass regressions.
New registries — _registry/adr-catalog.yaml, change-impact.yaml, baselines.yaml, baseline-trace.yaml, sign-off-ledger.yaml, waivers.yaml are all schema-validated and enforced by phase09 checks.
Operator seeder — scripts/seed_demo_project.py is idempotent; re-running reproduces a PASSING demo workspace including engine sync and baseline snapshot.
Premium UI/UX specification layer — 03-design-documentation/05-ux-specification now validates as a portable phase skill and can invoke premium-ui-ux-design to make beauty, pleasantness, dashboard clarity, Android/iOS platform fit, accessibility, and commercial credibility testable UX requirements.

See docs/plans/completion2026-04-16/PROGRESS.md for the full execution ledger.

What's New in v3.6

Requirements Engineering Fundamentals Expanded - Added Business Analysis Planning, Business Process Modeling, Business Rules Analysis, Prototyping and Solution Discovery, and Solution Evaluation and Transition
Phase 03: Design Documentation - Added IoT System Design for connected-device and edge-enabled products
Phase 06: Deployment & Operations - Added Go-Live Readiness for structured launch governance and release decision support
Book-driven gap closure - Reduced major coverage gaps in BA planning, workflow modeling, rule analysis, connected-product design, and launch readiness without restructuring the repository
Engine contract hardening - Added repo-level validation, deterministic gate coverage for Phases 01-09, a Hybrid operating model, and a regulated evidence model

What's New in v3.3

Phase 04: Development Artifacts - 4 new skills: Technical Specification, Coding Guidelines (IEEE 730), Dev Environment Setup, Contribution Guide (IEEE 1074)
Phase 05: Testing Documentation - 3 new skills: Test Strategy, Test Plan, Test Report (IEEE 829)
Phase 06: Deployment & Operations - 4 new skills: Deployment Guide (IEEE 1062), Runbook (SRE), Monitoring Setup (ISO 25010), Infrastructure Docs (IEEE 1016)
Phase 07: Agile Artifacts - 4 new skills: Sprint Planning, Definition of Done, Definition of Ready, Retrospective Template (Scrum Guide)
Phase 08: End-User Documentation - 4 new skills: User Manual, Installation Guide, FAQ (ISO 26514), Release Notes (IEEE 830)
Phase 09: Governance & Compliance - 4 new skills: Traceability Matrix, Audit Report (IEEE 1012), Compliance Docs (GDPR/HIPAA/SOC2), Risk Assessment (ISO 31000)
100% phase coverage - All 10 SDLC phases fully implemented with 63 documentation skills

What's New in v3.2

AI Economic Value Brief - strategic AI brief for AI apps, agents, analytics, automation, evaluation gates, and operating ownership
Phase 01: Strategic Vision - 3 new skills: Vision Statement (IEEE 29148), PRD (IEEE 29148/1233), Business Case (IEEE 1058)
Phase 02: Agile Track Complete - 3 new skills: Acceptance Criteria, Story Mapping, Backlog Prioritization (IEEE 29148)
Phase 03: Design Documentation - 4 new skills: HLD, LLD (IEEE 1016), API Specification (OpenAPI 3.0), Database Design (IEEE 1016)
Setup Scripts - PowerShell and Bash scripts for bootstrapping new SRS projects

What's New in v3.0

Multi-Methodology Support: Choose Waterfall (IEEE 830 SRS) or Agile (User Stories) pipelines
Expanded Scope: Beyond SRS—now supports PRDs, HLD/LLD, API docs, test plans, deployment guides, and more
Phase-Based Organization: 10 SDLC phases from strategic vision to governance/compliance
Methodology Detection: New Phase 00 helps select the right documentation approach
Backward Compatible: Existing Waterfall SRS pipeline preserved (moved to 02-requirements-engineering/waterfall/)

📚 Supported Documentation Types

Engine Assurance

Run python -X utf8 scripts/validate_engine.py to verify canonical pathing, deterministic gate coverage, Hybrid operating-model docs, and regulated evidence docs.
Root documentation uses the canonical workspace model under projects/<ProjectName>/....
Legacy ../project_context/ and ../output/ references remain valid only as execution aliases inside skill-local workflows.

Strategic & Vision Documents (Phase 01)

PRD (Product Requirements Document) - IEEE 29148
Vision Statements
Business Cases
Lean Canvas & Impact Mapping (NEW) - MVP/startup alternative to PRD (decision gate)
AI Economic Value Brief - AI business value, data readiness, evaluation, governance, and roadmap

Requirements Engineering (Phase 02)

RE Fundamentals (NEW):

Stakeholder Analysis - IEEE 29148, Power/Interest grids, RACI
Elicitation Toolkit - Interviews, JAD, Prototyping, Observation, Surveys
BRD Generation (optional) - Business Requirements Document
Requirements Analysis - Conflict detection, feasibility, prioritization
Conceptual Data Modeling - Entity-relationship from business language
Requirements Patterns - Decision tables, state transitions, CRUD matrices
Requirements Validation - Reviews, inspections, prototype testing
Business Analysis Planning (NEW) - Governance, stakeholder engagement, BA approach
Business Process Modeling (NEW) - Events, workflows, handoffs, decision points
Business Rules Analysis (NEW) - Rule catalogs, ownership, contradictions, fit criteria
Prototyping and Solution Discovery (NEW) - Candidate comparison, prototype strategy, decision support
Requirements Management - Baselining, change control, versioning
Traceability Engineering - Forward/backward trace links
Requirements Metrics - Universal quality gate (GREEN/YELLOW/RED)
Requirements Reuse (optional) - Product line requirements library
Solution Evaluation and Transition (NEW) - Readiness, adoption, organizational transition, outcome evaluation

Waterfall Track:

SRS (Software Requirements Specification) - IEEE 830-1998, IEEE 1233-1998
Use Cases - UML 2.5 standards
Formal Requirements - Stimulus/response patterns

Agile Track:

User Stories - INVEST criteria, IEEE 29148-2018
User Story Maps - Jeff Patton methodology
Product Backlog - Sprint-ready with story points

Design Documentation (Phase 03)

HLD (High-Level Design) - IEEE 1016-2009, scalability patterns (ByteByteGo)
LLD (Low-Level Design) - IEEE 1016-2009
API Specifications - OpenAPI 3.0, advanced API patterns (Geewax)
Database Design - ERDs, schema documentation
UX Specification (NEW) - Information architecture, wireframes, design systems, usability testing
Premium UI/UX Specification (NEW) - Premium visual quality, data/dashboard quality, platform-specific Android/iOS criteria, and premium gate scoring
Infrastructure Design (NEW) - Scalability, caching, reliability, monitoring (decision gate)
IoT System Design (NEW) - Device, edge, connectivity, fleet lifecycle, secure operations

Testing Documentation (Phase 05)

Test Strategy - IEEE 829
Test Plans & Test Cases
Test Reports - Defect tracking, coverage metrics

Deployment & Operations (Phase 06)

Deployment Guides - Step-by-step procedures
Runbooks - SRE best practices
Monitoring Documentation
Infrastructure as Code Docs
Go-Live Readiness (NEW) - Launch gates, blocker register, rollback, hypercare

Agile Artifacts (Phase 07)

Sprint Planning Documents
Definition of Done (DoD)
Definition of Ready (DoR)
Retrospective Reports
Burndown/Burnup Charts

End-User Documentation (Phase 08)

User Manuals - ISO 26514
Installation Guides
Troubleshooting FAQs
Release Notes

Governance & Compliance (Phase 09)

Requirements Traceability Matrix - IEEE 1012-2016
Audit Reports - IEEE 1012 V&V
Compliance Documentation - GDPR, HIPAA, SOC2
Risk Assessments
Architecture Decision Records - catalog + status lifecycle
Change Impact Analysis - mandatory for every baselined change
Baseline Delta - snapshot/diff of identifier hashes
Waiver Management - 90-day bounded exceptions
Sign-Off Ledger - role-based phase-gate approvals
Evidence Pack Builder - auditor-ready ZIP via python -m engine pack
Anti-AI-Slop Guardrail (28-anti-ai-slop) - real-time pre-ship gate on every generated artefact
AI-Slop Audit (29-ai-slop-audit) - graded A–F slop report; runs after each major iteration and on any analyse/review/audit request

Anti-AI-slop quality gate. Two cross-cutting Phase 09 skills keep generated output from reading as AI slop. 28-anti-ai-slop is a real-time guardrail applied continuously while authoring every SRS, spec, design doc, test doc, ADR, and code artefact. 29-ai-slop-audit is the detector: it runs after each major iteration and auto-runs on any analyse / review / audit / de-slop request, producing a graded A–F report. A grade F blocks progression until the blocking findings are fixed, and every blocking finding maps to the engine's V&V fail tags ([SMART-FAIL], [V&V-FAIL], [TRACE-GAP], [VERIFIABILITY-FAIL]). Verified anchors: Merriam-Webster 2025 Word of the Year and Kommers et al. (arXiv 2601.06060).

🛠 Supported Standards

IEEE Std 830-1998: Software Requirements Specifications
IEEE Std 1233-1998: System Requirements Development
IEEE Std 610.12-1990: Software Engineering Terminology
IEEE Std 1012-2016: Verification and Validation
IEEE Std 1016-2009: Software Design Descriptions
IEEE Std 29148-2018: Requirements Engineering
IEEE Std 829: Software Test Documentation
ASTM E1340-96: Rapid Prototyping of Computerized Systems
ISO/IEC 15504: Process Assessment Framework
ISO/IEC 25010: Software Product Quality Model
ISO 26514: User Documentation
OpenAPI 3.0: API Documentation

🚀 Integration & Workflow

This repository is architected as a "Stateless Documentation Engine." It provides the logic and templates, while your parent project provides the context.

Junior operator quick path: if you just need to stand up a workspace from a shipped example and validate it, the five-command path lives in SETUP_GUIDE.md. It uses python -m engine doctor, python -m engine new-project, and python -m engine validate -- no manual scaffolding required.

Starting a New Client Project

Tell Claude: "start a new project"

Claude will:

Invoke superpowers:brainstorming to explore requirements and design
Ask 4 quick questions (project name, description, methodology, client contact)
Deduce the domain automatically from your description
Scaffold projects/<ProjectName>/ with all 9 phase directories
Pre-populate _context/ with your answers
Inject domain-default requirements tagged [DOMAIN-DEFAULT]

Then fill in remaining _context/ files and say: "generate PRD for <ProjectName>" or "generate SRS for <ProjectName>"

To export a finished document to Word: "build the SRS" → outputs SRS_Draft.docx in the phase directory

Installation

Clone this engine beside your project or copy it into your standard tools workspace:

git clone https://github.com/peterbamuhigire/srs-skills.git
cd skills
git checkout main

Quick Start

Step 1: Select Your Methodology

Run the methodology detection skill:

Run skill: 00-meta-initialization (engineering catalog engine)

This will:

Detect your project type (Waterfall, Agile, Hybrid)
Create projects/<ProjectName>/_context/methodology.md
Generate a documentation roadmap
Activate appropriate pipelines

Step 2: Choose Your Documentation Path

For Waterfall Projects (Traditional SDLC):

flowchart LR
    V[01 Strategic<br/>Vision] --> SRS[02 Waterfall<br/>SRS Pipeline]
    SRS --> D[03 Design<br/>Documentation]
    D --> T[05 Testing<br/>Documentation]
    T --> G[09 Governance<br/>& Compliance]

    style SRS fill:#e1f5ff

Start with: 02-requirements-engineering/waterfall/01-initialize-srs

For Agile Projects (Scrum/Kanban):

flowchart LR
    V[01 Strategic<br/>Vision] --> US[02 Agile<br/>User Stories]
    US --> SP[07 Sprint<br/>Planning]
    SP --> I[Implementation]
    I --> R[Retrospective]

    style US fill:#fff4e1

Start with: 02-requirements-engineering/agile/01-user-story-generation

Step 3: Execute Your Documentation Pipeline

Each phase builds on the previous:

Initialize context (seed projects/<ProjectName>/_context/ with vision, features, tech stack)
Run sequential skills in your chosen pipeline
Generate outputs inside projects/<ProjectName>/... under the active phase/document workspace
Validate with auditing skills (Phase 09)

🗂 Repository Structure

sdlc-docs-engine/
├── docs/                            # Repository documentation
├── domains/                         # Domain knowledge bases (tracked)
│   ├── INDEX.md
│   ├── healthcare/                  # HIPAA, HL7/FHIR, NFR defaults
│   ├── finance/                     # PCI-DSS, SOX, AML
│   ├── education/                   # FERPA, COPPA
│   ├── retail/                      # PCI-DSS, GDPR
│   ├── logistics/                   # DOT, ISO 28000
│   └── government/                  # FISMA, FedRAMP
├── projects/                        # [UNTRACKED] Per-client project workspaces
│   └── <ProjectName>/
│       ├── _context/                # Project inputs (vision, features, tech stack)
│       └── 01-09 <phases>/          # Generated section files + .docx output
├── scripts/
│   └── build-doc.sh                 # Pandoc: stitch .md sections → .docx
├── templates/
│   └── reference.docx               # [LOCAL ONLY] Word style template
├── 01-strategic-vision/             # PRD, vision statements, business cases, lean canvas
├── 02-requirements-engineering/
│   ├── fundamentals/               # NEW: Methodology-agnostic RE lifecycle (11 skills)
│   │   ├── before/                  # Stakeholder analysis, elicitation, BRD
│   │   ├── during/                  # Analysis, data modeling, patterns, validation
│   │   └── after/                   # Management, traceability, metrics, reuse
│   ├── waterfall/                   # IEEE 830 SRS pipeline (8 phases)
│   │   ├── 01-initialize-srs/
│   │   ├── 02-context-engineering/
│   │   ├── 03-descriptive-modeling/
│   │   ├── 04-interface-specification/
│   │   ├── 05-feature-decomposition/
│   │   ├── 06-logic-modeling/
│   │   ├── 07-attribute-mapping/
│   │   ├── 08-semantic-auditing/
│   │   └── 09-use-case-modeling/    # NEW: UML use cases, activity diagrams
│   └── agile/                       # User stories, story mapping, backlog
│       ├── 01-user-story-generation/
│       ├── 02-acceptance-criteria/
│       ├── 03-story-mapping/
│       └── 04-backlog-prioritization/
├── 03-design-documentation/         # HLD, LLD, API specs, database, UX spec, infrastructure
├── 04-development-artifacts/        # Technical specs, code documentation
├── 05-testing-documentation/        # Test strategy, plans, cases, reports
├── 06-deployment-operations/        # Deployment guides, runbooks, IaC docs
├── 07-agile-artifacts/              # Sprint planning, DoD, DoR, retrospectives
├── 08-end-user-documentation/       # User manuals, installation guides, FAQs
└── 09-governance-compliance/        # Traceability, audits, compliance docs

# Engineering/methodology skills live in the SIBLING engineering catalog engine at
#   C:\Users\Peter\.claude\skills  (15 category subdirectories; see "Skill Categories" below)
#       skills/ai/<skill-name>/SKILL.md
#       skills/android/<skill-name>/SKILL.md
#       skills/architecture/<skill-name>/SKILL.md
#       skills/backend-databases/<skill-name>/SKILL.md
#       skills/devops-cloud/<skill-name>/SKILL.md
#       skills/finance-accounting/<skill-name>/SKILL.md
#       skills/frontend-ux/<skill-name>/SKILL.md
#       skills/gis/<skill-name>/SKILL.md
#       skills/ios/<skill-name>/SKILL.md
#       skills/languages/<skill-name>/SKILL.md
#       skills/mobile-cross/<skill-name>/SKILL.md
#       skills/product-business/<skill-name>/SKILL.md
#       skills/saas/<skill-name>/SKILL.md
#       skills/sdlc-meta/<skill-name>/SKILL.md
#       skills/security/<skill-name>/SKILL.md
# Finance/accounting lives in the SIBLING finance engine at
#   C:\wamp64\www\chwezi-accounting-doctrine  (consult its README.md router)

Skill Categories

The portable skill catalog lives in the sibling engineering catalog engine at C:\Users\Peter\.claude\skills, grouped into 15 categories. Reference any individual skill as skills/<category>/<skill-name>/SKILL.md in the engineering catalog engine (C:\Users\Peter\.claude\skills).

ai — LLM integration, agent runtime, RAG, prompt engineering, AI app architecture, evaluation/observability, AI economics, safety, security, UX, openai-agents-sdk.
android — Android development, UI/UX, data persistence, TDD.
architecture — API design-first, REST/GraphQL patterns, microservices architecture/communication/orchestration, distributed systems, contract validation, system architecture design.
backend-databases — MySQL and PostgreSQL engineering/admin/operations/performance, database design, internals, reliability, vector databases.
devops-cloud — CI/CD, Docker, Kubernetes (fundamentals/platform/production/SaaS), IaC, cloud architecture, deployment/release, observability, reliability engineering.
finance-accounting — Accounting engine, finance controller, chart of accounts, payroll (Uganda), inventory costing/management, demand forecasting, fixed assets/depreciation, multicurrency/FX.
frontend-ux — React, Next.js, Tailwind, design audit/principles, premium/practical UI, enterprise UX process, motion/interaction/form/data-viz, healthcare/POS UI, frontend performance, UX content strategy.
gis — GIS mapping, maps integration, PostGIS backend, platform engineering, enterprise GIS domain.
ios — iOS development/architecture/data/UI/AI-ML/monetization/platform/quality/security; macOS AppKit/sandbox/system-integrations; Swift concurrency; Xcode Cloud/TestFlight/Instruments.
languages — JavaScript modern/patterns, TypeScript (mastery/effective/full-stack), Node.js, Python (modern/data/ML/SaaS), PHP modern/security, language standards.
mobile-cross — KMP development, PWA offline-first, mobile platform operations, mobile reports.
product-business — Product strategy/vision/discovery, PLG, premium positioning/execution, software business models/pricing, growth telemetry, experiment engineering, customer service, content/proposal writing, Excel, professional Word output.
saas — SaaS architecture strategy, modular/multi-tenant, control plane, admin/backoffice, lifecycle email, entitlements/plan gating, rate limiting/quotas, SSO/SCIM, tenant onboarding/portability/erasure, deployment models, business metrics, SaaS ERP/accounting, subscription billing, Stripe payments.
sdlc-meta — World-class engineering, engineering management/strategy, advanced testing strategy, E2E testing, AI-assisted development, git collaboration workflow, plan implementation, project requirements, SDLC (planning/design/documentation/testing/user-deploy), doc-architect, capability matrix, continuous improvement, custom sub-agents, skill-writing, skill safety audit, skill composition standards.
security — Code safety scanner, DPIA generator, dual-auth RBAC, Linux security hardening, network security, Uganda DPPA compliance, web app security audit.

Pathing Model

The canonical runtime model is the project workspace under projects/<ProjectName>/.

Context source of truth: projects/<ProjectName>/_context/
Generated markdown and phase artifacts: projects/<ProjectName>/<phase>/...
Final .docx outputs: projects/<ProjectName>/<phase>/
Portable skill entrypoints: skills/<skill-name>/SKILL.md
Repository root: project documentation plus docs/, skills/, and projects/ where relevant, alongside operational folders such as engine/, templates/, and scripts/

Many existing skill-local files still use ../project_context/ and ../output/. Those are compatibility aliases used inside skill execution contexts. They are not a second architecture. Root documentation follows the canonical workspace model described in docs/pathing-model.md.

📋 Documentation Pipelines

Waterfall SRS Pipeline (Phase 02)

Best for: Regulated industries, fixed-scope projects, safety-critical systems

Generates: Complete IEEE 830-compliant SRS with 8 sections

Phases:

Initialize context templates
Generate Section 1.0 (Introduction)
Generate Section 2.0 (Overall Description)
Generate Section 3.1 (External Interfaces)
Generate Section 3.2 (Functional Requirements)
Generate Section 3.2.x (Logic & Algorithms)
Generate Sections 3.3-3.6 (Non-Functional Requirements)
Validate & generate Traceability Matrix

Output: canonical project artifacts under projects/<ProjectName>/02-requirements-engineering/... and projects/<ProjectName>/09-governance-compliance/...

👉 Start Waterfall SRS Pipeline

Agile User Story Pipeline (Phase 02)

Best for: Startups, MVPs, iterative projects, Scrum/Kanban teams

Generates: INVEST-compliant user stories with acceptance criteria

Phases:

Generate user stories from features
Refine acceptance criteria (Given-When-Then)
Create story map visualization
Prioritize backlog (MoSCoW/WSJF)

Output: canonical project artifacts under projects/<ProjectName>/02-requirements-engineering/...

👉 Start Agile User Story Pipeline

🤖 AI-Assisted Development Skills (New in v3.1)

Purpose: Skills that make Claude Code better at helping you develop software by enforcing patterns, preventing errors, and optimizing workflows.

Core AI Development Skills

1. ai-assisted-development - Multi-Agent Orchestration

Use when: Coordinating multiple AI agents (Planning, Coding, Testing, Review)

Provides:

5 orchestration strategies (Sequential, Parallel, Conditional, Looping, Retry)
3 AI-specific patterns (Agent Handoff, Fan-Out/Fan-In, Human-in-the-Loop)
Real-world examples from MADUUKA and BRIGHTSOMA projects
30-75% faster development through parallelization

👉 Learn AI Agent Orchestration

2. ai-error-prevention - Trust But Verify Workflow

Use when: Working with Claude to generate code (always!)

Provides:

7 prevention strategies to catch Claude's mistakes early
Common failure modes: Hallucination, Incomplete Solutions, Misunderstanding, Lazy Solutions
App-specific checklists (MADUUKA, MEDIC8, BRIGHTSOMA, DDA, CROWNPOINT)
Saves 50-75% of wasted tokens through early error detection

👉 Learn Error Prevention

3. orchestration-best-practices - The 10 Commandments

Use when: Generating multi-step workflows or complex processes

Provides:

The 10 orchestration rules (steps, dependencies, validation, error handling)
Complete code examples (good vs bad patterns)
Verification checklist
Anti-patterns guide

👉 Learn Orchestration Rules

4. ai-error-handling - 5-Layer Validation Stack

Use when: Validating AI-generated code before production

Provides:

5 validation layers: Syntax, Requirements, Testing, Security, Documentation
Quality scoring system (0-100, threshold >= 80)
Validation loop with max 3 iterations
Automated recovery strategies

👉 Learn Validation Stack

Reference Guides

prompting-patterns-reference.md

10 essential patterns for better AI instructions

Reduces clarification questions by 50%
Improves first-time-right code by 60%
Patterns: Clear Task+Context+Constraints, Chain-of-Thought, Few-Shot Learning, etc.

orchestration-patterns-reference.md

Comprehensive guide for coordinating multiple agents/tasks

5 orchestration types with examples
4 core patterns (Map-Reduce, Pipeline, Fan-Out/Fan-In, Circuit Breaker)
Decision trees and performance analysis

encoding-patterns-into-skills.md

How to create skills that automatically enforce patterns

Formula: Rules + Examples + Checklists + Decision Trees
Pattern encoding templates
Skill iteration strategies

How AI Skills Work Together

REQUEST PREPARATION (ai-error-prevention)
├─ Use prompting patterns (prompting-patterns-reference)
├─ Break into small steps
└─ Clear task + context + constraints

CLAUDE GENERATES CODE

IMMEDIATE VERIFICATION (ai-error-prevention)
├─ Verification-First strategy
├─ Test-Driven Validation
└─ Specification Matching

STRUCTURE CHECK (orchestration-best-practices)
├─ Steps clearly defined?
├─ Dependencies identified?
└─ Error handling present?

VALIDATION (ai-error-handling)
├─ 5-layer validation stack
└─ Quality threshold check (>= 80/100)

ACCEPTANCE OR ITERATION
└─ All checks passed? → USE CODE ✓

Result: Production-ready code, 50-75% fewer wasted tokens, higher quality output

✅ Methodology Selection Guide

When to Use Waterfall SRS Pipeline

✅ YES for:

Regulated industries (FDA, FAA, DOD, medical devices)
Fixed-scope, fixed-price contracts
Safety-critical systems (aerospace, automotive)
Projects requiring IEEE 830/1233 compliance
Formal verification & validation (IEEE 1012)

❌ NO for:

Agile/Scrum projects with evolving requirements
MVPs with high uncertainty
Startups needing rapid iteration

When to Use Agile User Story Pipeline

✅ YES for:

Scrum, Kanban, XP projects
Startups with evolving requirements
MVPs and rapid prototypes
Continuous stakeholder collaboration
Projects with flexible scope

❌ NO for:

Regulated industries requiring comprehensive SRS
Fixed-scope contracts with formal signoffs
Safety-critical systems

Hybrid Approach

You can mix methodologies:

Example 1: Use Waterfall SRS for backend (regulated) + Agile User Stories for frontend (rapid iteration)

Example 2: Use Waterfall for core platform + Agile for new feature experiments

Use the formal operating contract in docs/hybrid-operating-model.md so baselined requirements, Agile execution, and change control stay linked.

🔁 Iterative Development & Re-running Phases

Idempotency Rule: Most skills are designed to be re-runnable.

When Context Changes

Changed File	Re-run Phases	Reason
`vision.md`	02 (Context/Stories), 09 (Audit)	Vision affects all downstream docs
`features.md`	02 (Requirements), 03 (Design)	New features → new requirements
`tech_stack.md`	03 (Design), 04 (Interfaces)	Tech stack changes affect architecture
`business_rules.md`	06 (Logic Modeling)	Business rules map to algorithms
`quality_standards.md`	07 (NFRs), 05 (Testing)	Quality targets define test criteria

Maintenance Mode

When re-running skills on existing documentation:

Phase 01 has --maintenance flag to add missing templates without overwriting
Phases 02-08 will prompt before overwriting: [APPEND], [PATCH], or [OVERWRITE]
Always re-run Phase 09 (Audit) after any changes to validate consistency

🧠 Design Philosophy

Project-Workspace Targeting: Skills execute within this repository and target the active project workspace under projects/<ProjectName>/
Standards-Driven Prompts: Every skill maps to specific IEEE/ISO clauses
Engineering over Authorship: Requirements use stimulus-response patterns and logic modeling for verifiability
Methodology-Agnostic Core: Choose Waterfall, Agile, or Hybrid based on project needs
Repository Portability: The engine is stateless; project-specific data stays in gitignored project workspaces unless explicitly promoted to examples or documentation
Token Efficiency: 500-line hard limit on all .md files ensures AI comprehension and cost efficiency

📖 Supporting Documentation

CLAUDE.md: AI assistant SOP with V&V procedures, skill usage guidelines
DEPENDENCIES.md: Runtime requirements (Python 3.10+, libraries, environment variables)
docs/CHANGELOG.md: Version history, standards updates, migration notes
skill_overview.md: Input-to-output registry for each skill
PROJECT_BRIEF.md: Quick overview for new users
ARCHITECTURE.md: Technical architecture and design decisions
docs/deterministic-governance.md: Clause-level gate checklist that extends the ISO/IEEE 29119 deterministic model to other phases.

🎯 Example Workflows

Workflow 1: Waterfall Medical Device SRS

# Step 1: Initialize
Run skill: 02-requirements-engineering/waterfall/01-initialize-srs

# Step 2: Populate context files (manually)
Edit `projects/<ProjectName>/_context/vision.md`
Edit `projects/<ProjectName>/_context/features.md`
Edit `projects/<ProjectName>/_context/tech_stack.md`
Edit `projects/<ProjectName>/_context/business_rules.md`
Edit `projects/<ProjectName>/_context/quality_standards.md`
Edit `projects/<ProjectName>/_context/glossary.md`

# Step 3: Generate SRS sections sequentially
Run skill: 02-requirements-engineering/waterfall/02-context-engineering
Run skill: 02-requirements-engineering/waterfall/03-descriptive-modeling
Run skill: 02-requirements-engineering/waterfall/04-interface-specification
Run skill: 02-requirements-engineering/waterfall/05-feature-decomposition
Run skill: 02-requirements-engineering/waterfall/06-logic-modeling
Run skill: 02-requirements-engineering/waterfall/07-attribute-mapping
Run skill: 02-requirements-engineering/waterfall/08-semantic-auditing

# Output: generated SRS artifacts in `projects/<ProjectName>/02-requirements-engineering/...`

Workflow 2: Agile E-commerce Startup

# Step 1: Create PRD and vision
Run skill: 01-strategic-vision/01-prd-generation

# Step 2: Generate user stories
Run skill: 02-requirements-engineering/agile/01-user-story-generation

# Step 3: Create story map
Run skill: 02-requirements-engineering/agile/03-story-mapping

# Step 4: Sprint planning
Run skill: 07-agile-artifacts/01-sprint-planning

# Output: generated Agile artifacts in `projects/<ProjectName>/02-requirements-engineering/...` and `projects/<ProjectName>/07-agile-artifacts/...`

Workflow 3: Hybrid SaaS Platform

# Backend (Regulated, needs formal SRS)
Run skill: 02-requirements-engineering/waterfall/ (full pipeline)

# Frontend (Agile, rapid iteration)
Run skill: 02-requirements-engineering/agile/01-user-story-generation

# Shared Design Documentation
Run skill: 03-design-documentation/01-high-level-design

# Output: SRS for backend, User Stories for frontend, Unified HLD

🔧 Domain-Specific Skills

The skills/ directory contains 25+ reusable domain patterns that integrate with documentation phases:

Architecture Skills

multi-tenant-saas-architecture: Backend isolation, tenant management
modular-saas-architecture: Microservices patterns

Database Skills

mysql-best-practices: MANDATORY for all database work - Schema design, migrations, multi-tenant isolation

Security Skills

dual-auth-rbac: Session + JWT authentication, role-based access control
vibe-security-skill: MANDATORY for web apps - OWASP Top 10, secure coding

UI/UX Skills

webapp-gui-design: Web app UI patterns, responsive design
pos-sales-ui-design: Point-of-sale UI standards

Process Skills

feature-planning: Complete feature planning from spec to implementation
doc-architect: Generate Triple-Layer AGENTS.md documentation

Technology Skills

gis-mapping: OpenStreetMap integration, geofencing
report-print-pdf: PDF generation, auto-print workflows
api-error-handling: Standardized error responses

Usage: Load domain skills alongside phase skills for specialized guidance.

Example:

# Use multi-tenant skill with HLD generation
Run skill: 03-design-documentation/01-high-level-design
+ Reference: skills/multi-tenant-saas-architecture/

🚨 Critical Rules

Database Work (MANDATORY)

All database-related work MUST use skills/mysql-best-practices/

This includes:

Database migrations (tables, columns, indexes)
Schema design and modifications
Stored procedures, triggers, views
Query optimization
Multi-tenant isolation patterns

Failure to follow the migration checklist causes production failures.

Documentation Standards (MANDATORY)

All .md files MUST follow strict formatting:

500-line hard limit - No exceptions
Two-tier structure - High-level TOC + Deep dive docs
Smart subdirectory grouping - Logical organization

See skills/doc-standards.md for complete requirements.

Security Baseline (MANDATORY for Web Apps)

All web application work MUST apply skills/vibe-security-skill/

Security principles are non-negotiable:

Input validation and sanitization
Authentication and authorization
OWASP Top 10 protection
Secure data handling

📊 Verification & Validation (V&V)

IEEE 1012 Evaluation Framework

Every generated document undergoes V&V:

Correctness: Confirms alignment with stakeholder intent
Consistency: Ensures uniform terminology and logic
Completeness: Verifies all edge cases are covered
Verifiability: Confirms deterministic test criteria exist

Audit Execution (Phase 09)

Phase 09 skills perform:

Traceability Verification: Every requirement links to business goals
Logic Scrutiny: Validates all formulas and algorithms
Conflict Resolution: Identifies contradictions between sections
Standards Compliance: Checks IEEE/ISO conformance

Output: Audit_Report.md, Traceability_Matrix.md

🔄 Migration from v2.x

Existing users: The original 8-phase SRS pipeline has been moved to 02-requirements-engineering/waterfall/.

Update Your Workflows

# Old path (deprecated)
01-initialize-srs/

# New path
02-requirements-engineering/waterfall/01-initialize-srs/

Backward Compatibility

Legacy entry points still work but will show deprecation notices:

# 01-initialize-srs (DEPRECATED)
Use: 02-requirements-engineering/waterfall/01-initialize-srs

See docs/MIGRATION_V2_TO_V3.md for complete migration guide.

📈 Roadmap

v3.6.0 (Current - 2026-04-13)

Requirements fundamentals expanded with 5 new skills covering BA planning, process modeling, business rules, prototyping, and transition
Phase 03 extended with IoT System Design
Phase 06 extended with Go-Live Readiness
Added book-driven gap-closure analysis in docs/2026-04-13-book-driven-gap-closure.md
Expanded SDLC-engine coverage across all 10 phases without restructuring the repository

v3.5.0 (2026-03-08)

Design Documentation Enhancement: 5 new skills + 9 reference files + 5 existing skill enhancements
Phase 03: UX Specification (IA, wireframes, design systems), Infrastructure Design (scalability, caching, reliability)
Phase 02: Use Case Modeling (UML use cases, activity diagrams) for waterfall pipeline
Phase 01: Lean Canvas & Impact Mapping (MVP/startup alternative to PRD)
New cross-cutting skill: Cognitive UX Framework (Six Minds, cognitive walkthroughs)
Enhanced HLD with scalability patterns (ByteByteGo), API Spec with advanced patterns (Geewax)
Sources: ByteByteGo, Dennis/Wixom/Tegarden, Whalen, Effective Product Designer, Geewax, BA Methodology Book
63 total documentation generation skills across 10 SDLC phases

v3.4.0 (2026-03-07)

Requirements Engineering Fundamentals: 11 new methodology-agnostic RE skills
Before/During/After lifecycle wrapping both Waterfall and Agile pipelines
Stakeholder Analysis, Elicitation Toolkit, BRD Generation, Requirements Analysis, Conceptual Data Modeling, Requirements Patterns, Validation, Management, Traceability Engineering, Metrics & Quality Gates, Requirements Reuse
Sources: Laplante, Wiegers & Beatty, Leffingwell, Business Requirements & Data Architecture
57 total documentation generation skills across 10 SDLC phases

v3.3.0 (2026-03-01)

Phase 04-09: 23 new documentation skills completing 100% phase coverage
Development Artifacts, Testing, Deployment, Agile, End-User, Governance phases
46 total documentation generation skills across 10 SDLC phases

v3.2.0 (2026-02-28)

Phase 01: Strategic Vision skills (Vision Statement, PRD, Business Case)
Phase 02: Agile track completion (Acceptance Criteria, Story Mapping, Backlog Prioritization)
Phase 03: Design Documentation skills (HLD, LLD, API Specification, Database Design)
Setup scripts for new project bootstrapping (PowerShell + Bash)

v3.1.0 (2026-02-07)

AI-Assisted Development Skills (4 skills + 3 reference guides)
Token efficiency improvements (50-75% savings)

v3.0.0 (2026-02-06)

Multi-methodology support (Waterfall + Agile)
Reorganized phase structure (00-09)
Agile user story generation skill

v4.0.0 (Planned - Q3 2026)

⏳ Automated doc generation from code (API docs, schema docs)
⏳ Integration with CI/CD pipelines
⏳ Multi-language support (docs in Spanish, French, etc.)

🤝 Contributing

We welcome contributions! To add or improve skills:

Review existing skills for format and structure
Follow the sdlc-meta/skill-writing/ meta-skill guidelines in the engineering catalog engine (C:\Users\Peter\.claude\skills)
Ensure 500-line limit and two-tier documentation structure
Add examples and anti-patterns
Update README.md and PROJECT_BRIEF.md
Submit PR with clear description

See skills/claude-guides/skill-creation-workflow.md for detailed workflow.

📄 License

This project is licensed under the MIT License. See LICENSE.txt for details.

💬 Support

Issues: https://github.com/peterbamuhigire/srs-skills/issues
Discussions: https://github.com/peterbamuhigire/srs-skills/discussions
Documentation: See CLAUDE.md for AI assistant guidance

🙏 Acknowledgments

This project builds on industry standards:

IEEE Computer Society for SRS and V&V standards
Agile Alliance for user story best practices
Bill Wake for INVEST criteria
Jeff Patton for story mapping methodology
ISO/IEC for quality and process standards

Built with precision. Powered by standards. Designed for portability.

Maintained by: Peter Bamuhigire Version: 3.6.0 Last Updated: 2026-04-13

Quick Reference

Task	Command	Output
Waterfall SRS	`02-requirements-engineering/waterfall/01-initialize-srs`	IEEE 830 SRS
Agile User Stories	`02-requirements-engineering/agile/01-user-story-generation`	User story backlog
Methodology Selection	`00-meta-initialization` (engineering catalog engine)	Documentation roadmap
Design Docs	`03-design-documentation/01-high-level-design`	HLD, architecture diagrams
Traceability	`09-governance-compliance/01-traceability-matrix`	RTM, audit report

Name		Name	Last commit message	Last commit date
.claude		.claude
.github		.github
01-strategic-vision		01-strategic-vision
02-requirements-engineering		02-requirements-engineering
03-design-documentation		03-design-documentation
04-development-artifacts		04-development-artifacts
05-testing-documentation		05-testing-documentation
06-deployment-operations		06-deployment-operations
07-agile-artifacts		07-agile-artifacts
08-end-user-documentation		08-end-user-documentation
09-governance-compliance		09-governance-compliance
book-extractions		book-extractions
docs		docs
domains		domains
engine		engine
scripts		scripts
templates		templates
tests		tests
.gitignore		.gitignore
.pre-commit-config.yaml		.pre-commit-config.yaml
AGENTS.md		AGENTS.md
ARCHITECTURE.md		ARCHITECTURE.md
CLAUDE.md		CLAUDE.md
CONTRIBUTING.md		CONTRIBUTING.md
DEPENDENCIES.md		DEPENDENCIES.md
PROJECT_BRIEF.md		PROJECT_BRIEF.md
README.md		README.md
SETUP_GUIDE.md		SETUP_GUIDE.md
TECH_STACK.md		TECH_STACK.md
pyproject.toml		pyproject.toml
skill_overview.md		skill_overview.md

Latest commit

History

Folders and files

Repository files navigation

SDLC-Docs-Engine: Standards-Driven Documentation Across the Software Lifecycle

July 2026 skill-engine conformance

Architecture & cross-cutting engines (updated 2026-06-21)

SaaS + AI-on-SaaS + Agent Documentation Stack (May 2026)

Embedded Accounting Engine Additions

Game Software Delivery Stack

Retail Operating-Model Additions

Active Projects

What changed in v4.0

What's New in v3.6

What's New in v3.3

What's New in v3.2

What's New in v3.0

📚 Supported Documentation Types

Engine Assurance

Strategic & Vision Documents (Phase 01)

Requirements Engineering (Phase 02)

RE Fundamentals (NEW):

Waterfall Track:

Agile Track:

Design Documentation (Phase 03)

Testing Documentation (Phase 05)

Deployment & Operations (Phase 06)

Agile Artifacts (Phase 07)

End-User Documentation (Phase 08)

Governance & Compliance (Phase 09)

🛠 Supported Standards

🚀 Integration & Workflow

Starting a New Client Project

Installation

Quick Start

Step 1: Select Your Methodology

Step 2: Choose Your Documentation Path

Step 3: Execute Your Documentation Pipeline

🗂 Repository Structure

Skill Categories

Pathing Model

📋 Documentation Pipelines

Waterfall SRS Pipeline (Phase 02)

Agile User Story Pipeline (Phase 02)

🤖 AI-Assisted Development Skills (New in v3.1)

Core AI Development Skills

1. ai-assisted-development - Multi-Agent Orchestration

2. ai-error-prevention - Trust But Verify Workflow

3. orchestration-best-practices - The 10 Commandments

4. ai-error-handling - 5-Layer Validation Stack

Reference Guides

prompting-patterns-reference.md

orchestration-patterns-reference.md

encoding-patterns-into-skills.md

How AI Skills Work Together

✅ Methodology Selection Guide

When to Use Waterfall SRS Pipeline

When to Use Agile User Story Pipeline

Hybrid Approach

🔁 Iterative Development & Re-running Phases

When Context Changes

Maintenance Mode

🧠 Design Philosophy

📖 Supporting Documentation

🎯 Example Workflows

Workflow 1: Waterfall Medical Device SRS

Workflow 2: Agile E-commerce Startup

Workflow 3: Hybrid SaaS Platform

🔧 Domain-Specific Skills

Architecture Skills

Database Skills

Security Skills

UI/UX Skills

Process Skills

Technology Skills

🚨 Critical Rules

Database Work (MANDATORY)

Documentation Standards (MANDATORY)

Security Baseline (MANDATORY for Web Apps)

📊 Verification & Validation (V&V)