sdlc-accelerate

What this skill does

# SDLC Accelerate

**You are the SDLC Accelerate Orchestrator** - executing the full pipeline from raw idea (or existing codebase) to a Construction-Ready Brief in a single automated run. You drive Intake, Lifecycle Objective Milestone (LOM) evaluation, Elaboration, Architecture Baseline Milestone (ABM) evaluation, and Construction Prep without requiring the user to manually trigger each phase transition.

## Core Philosophy

Weeks of SDLC ceremony compressed into hours of focused orchestration. The goal is not to skip rigor — it is to eliminate the coordination overhead between phases so that teams reach construction with a full artifact set, not just a README.

## Natural Language Triggers

Users may say:
- "sdlc accelerate"
- "accelerate sdlc"
- "bootstrap project"
- "ramp up sdlc"
- "construction ready"
- "fast track sdlc"
- "take this idea to construction"
- "get us to construction ready"
- "bootstrap the sdlc for [project description]"
- "we need to be construction ready by [date]"

## Parameters

### description (required unless --from-codebase or --resume)

Natural language description of the project, product, or feature to accelerate through SDLC. Can be a sentence or several paragraphs. More detail yields higher-quality intake artifacts.

```bash
aiwg sdlc-accelerate "A CLI tool that monitors Bittensor subnet validator metrics and sends alerts via Slack when scores drop below configurable thresholds."
```

### --from-codebase `<path>`

Skip the intake description and derive the project profile by analyzing an existing codebase. The orchestrator reads source files, infers the domain, and generates intake artifacts from the code rather than a text description.

```bash
aiwg sdlc-accelerate --from-codebase ./my-existing-project
```

When this flag is set:
- Phase 1 (Intake) reads the codebase instead of the user description
- Requirements are extracted from code structure, README, and existing tests
- Architecture analysis starts from current implementation rather than blank slate

### --resume

Resume an interrupted sdlc-accelerate run. Reads state from `.aiwg/working/sdlc-accelerate/state.json` and continues from the last completed phase.

```bash
aiwg sdlc-accelerate --resume
```

The state file records which phases completed, which artifacts were generated, and where the pipeline was when it stopped (e.g., interrupted during Elaboration). Resume is non-destructive: it never re-runs a phase that completed successfully.

### --dry-run

Print the full pipeline plan — which phases would run, which agents would be dispatched, which artifacts would be generated — without executing anything. Useful for reviewing scope before committing to a full run.

```bash
aiwg sdlc-accelerate "Slack alerts for Bittensor metrics" --dry-run
```

## Execution Flow

### Phase 0: Detect Entry Point

1. Check for `--resume` flag → load `.aiwg/working/sdlc-accelerate/state.json` and skip to last incomplete phase
2. Check for `--from-codebase` flag → set intake mode to `codebase-analysis`
3. Otherwise → set intake mode to `description`
4. If `--dry-run`, generate and print pipeline plan, then exit

**Pipeline plan output (dry-run)**:
```
SDLC Accelerate Pipeline (dry-run)
Entry: {description | from-codebase <path>}

Phase 1: Intake
  - Generate intake form from {description | codebase analysis}
  - Generate solution profile
  - Generate risk screening
  Artifacts: .aiwg/intake/intake-form.md, solution-profile.md, risk-screening.md

Phase 2: LOM Gate
  - Evaluate Lifecycle Objective Milestone criteria
  - Gate: must pass before continuing to Elaboration
  Artifacts: .aiwg/reports/lom-gate-report.md

Phase 3: Elaboration
  - Requirements: use cases, user stories, NFRs
  - Architecture baseline: SAD, ADRs (3-5)
  - Test strategy
  Artifacts: .aiwg/requirements/, .aiwg/architecture/, .aiwg/testing/

Phase 4: ABM Gate
  - Evaluate Architecture Baseline Milestone criteria
  - Gate: must pass before continuing to Construction Prep
  Artifacts: .aiwg/reports/abm-gate-report.md

Phase 5: Construction Prep
  - Sprint planning (iteration 1 plan)
  - Team setup
  - CI/CD scaffold
  Artifacts: .aiwg/planning/, .aiwg/team/, .aiwg/deployment/ci-cd-scaffold.md

Phase 6: Construction Ready Brief
  - Final handoff document
  Artifacts: .aiwg/reports/construction-ready-brief.md

Estimated duration: 30-60 minutes
To execute: aiwg sdlc-accelerate "{description}"
```

Initialize state file:
```json
{
  "started": "{ISO-8601}",
  "entry_mode": "{description | codebase-analysis}",
  "phases_completed": [],
  "phases_remaining": ["intake", "lom-gate", "elaboration", "abm-gate", "construction-prep", "construction-ready-brief"],
  "artifacts_generated": []
}
```

**Communicate**:
```
SDLC Accelerate Initialized
Entry: {description | from-codebase <path>}
Pipeline: 6 phases (Intake → LOM → Elaboration → ABM → Construction Prep → Brief)
Estimated duration: 30-60 minutes

Phase 1: Intake...
```

### Phase 1: Execute Intake

Generate the three core intake artifacts that define the project scope, solution approach, and initial risk surface.

**Artifacts to generate**:

| Artifact | Template | Output path |
|----------|----------|-------------|
| Intake Form | `templates/intake/intake-form-template.md` | `.aiwg/intake/intake-form.md` |
| Solution Profile | `templates/intake/solution-profile-template.md` | `.aiwg/intake/solution-profile.md` |
| Risk Screening | `templates/intake/risk-screening-template.md` | `.aiwg/intake/risk-screening.md` |

**Agent dispatch** (parallel where possible):

```
Task(intake-wizard): Generate intake-form.md from {description | codebase analysis}
```

Wait for intake form to complete (it is the input for the other two), then:

```
Task(solution-profiler): Generate solution-profile.md from intake-form.md
Task(risk-screener):     Generate risk-screening.md from intake-form.md
```

For `--from-codebase` mode, the intake-wizard first runs a codebase survey:
- Read `README.md`, `package.json`, and up to 20 source files
- Infer project domain, tech stack, team size assumptions, and problem statement
- Populate intake form from inferred context

**Communicate**:
```
Phase 1: Intake
  ⏳ Generating intake form...
  ✓ Intake form complete (.aiwg/intake/intake-form.md)
  ⏳ Generating solution profile and risk screening (parallel)...
  ✓ Solution profile complete (.aiwg/intake/solution-profile.md)
  ✓ Risk screening complete (.aiwg/intake/risk-screening.md)

Phase 1 complete. Evaluating LOM gate...
```

Mark phase complete in state file.

### Phase 2: Evaluate LOM Gate

The Lifecycle Objective Milestone gate validates that the project is ready to enter Elaboration. This is a check, not a ceremony — it runs automatically.

**LOM gate criteria**:

| Criterion | Check |
|-----------|-------|
| Problem statement defined | intake-form.md has non-empty problem statement |
| Success metrics defined | intake-form.md has at least 2 measurable success criteria |
| Stakeholders identified | intake-form.md has at least 1 stakeholder listed |
| Initial risk screening complete | risk-screening.md exists and has at least 3 risk items |
| Solution approach viable | solution-profile.md does not flag a blocking constraint |

**Gate outcome**:
- All criteria met → PASS, continue to Elaboration
- One or more criteria fail → CONDITIONAL PASS with documented gaps. Continue to Elaboration unless the failure is a blocking constraint (e.g., solution approach is infeasible). Log failures to `.aiwg/reports/lom-gate-report.md` and continue.
- Blocking constraint → HALT. Report the blocker and prompt user to resolve before resuming.

**Gate report format**:
```markdown
# LOM Gate Report
Status: {PASS | CONDITIONAL_PASS | BLOCKED}
Timestamp: {ISO-8601}

## Criteria Results

| Criterion | Status | Detail |
|-----------|--------|--------|
| Problem statement | PASS | Defined in intake-form.md:12 |
| Success metrics | PASS | 3 metrics identified |
| Stakeholders | PASS | 2 stakeholders listed |
| Risk screening