# Sdlc Workflow

> Defines the complete C# SDLC workflow process including phase ordering, decision points, loop conditions, and artifact locations. Use when orchestrating feature development, understanding the workflow sequence, or determining which phase comes next.

- Skill: `jburlison/sdlc-workflow` (Agent Skill)
- Install (CLI): `npx skillmds@latest add jburlison/sdlc-workflow`
- Raw SKILL.md: https://api.skillmd.com/api/skills/jburlison/sdlc-workflow/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Productivity
- Author: JBurlison (https://skillmd.com/u/jburlison)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/jburlison/sdlc-workflow

---


# C# SDLC Workflow

## Artifact Location

All artifacts are stored in `.memory_bank/features/<feature-name>/` with this structure:

```
<feature-name>/
├── spec.md                          # Feature specification
├── findings.md                      # Due diligence findings
├── plan.md                          # Overall implementation plan
├── phases/
│   ├── phase-1-<name>.md            # Individual phase details
│   ├── phase-2-<name>.md
│   └── ...
├── test-results/
│   ├── phase-1-test-results.md
│   └── ...
├── code-reviews/
│   ├── phase-1-review-1.md          # Increments on re-review
│   ├── phase-1-review-2.md
│   └── ...
├── phase-reviews/
│   ├── phase-1-completion.md
│   └── ...
└── final-review.md
```

## Workflow Sequence

### Phase 1: Spec Writing
- **Agent:** `spec-writer`
- **Input:** User's feature request/description
- **Output:** `.memory_bank/features/<feature-name>/spec.md`
- **Next:** Due Diligence

### Phase 2: Due Diligence
- **Agent:** `due-diligence`
- **Input:** `spec.md` + codebase analysis
- **Output:** Updated `spec.md` + `findings.md`
- **Next:** Planning

### Phase 3: Planning
- **Agent:** `planner`
- **Input:** `spec.md` + `findings.md`
- **Output:** `plan.md` + `phases/phase-N-<name>.md` for each phase
- **Next:** Phase Implementation Loop

### Phase 4-7: Per-Phase Implementation Loop

For each phase defined in the plan, execute this loop:

```
┌─────────────────────────────────────────────┐
│           PHASE LOOP (per phase)            │
│                                             │
│  4a. Implementer                            │
│   ↓                                         │
│  4b. SQA (write & run tests)               │
│   ├─ PASS → continue                       │
│   └─ FAIL → return to 4a (test fixes)      │
│   ↓                                         │
│  4c. Code Reviewer                          │
│   ├─ APPROVED → continue                   │
│   └─ CHANGES NEEDED → return to 4a (fixes) │
│   ↓                                         │
│  4d. Spec & Phase Reviewer                  │
│   ├─ COMPLETE → next phase                 │
│   └─ INCOMPLETE → return to 4a (gaps)      │
│                                             │
└─────────────────────────────────────────────┘
```

#### 4a. Implementation
- **Agent:** `implementer`
- **Input:** Phase document + (optional: test fixes / code review fixes / gap fixes)
- **Output:** Implemented code, updated phase checklist
- **Context:** Can receive fix requests from SQA, Code Reviewer, or Phase Reviewer

#### 4b. SQA
- **Agent:** `sqa`
- **Input:** `spec.md` + phase document + implemented code
- **Output:** Tests written, `test-results/phase-N-test-results.md`
- **Loop condition:** If tests fail → return to Implementer with test failure details
- **Next on pass:** Code Review

#### 4c. Code Review
- **Agent:** `code-reviewer`
- **Input:** Phase document + implemented code + test results
- **Output:** `code-reviews/phase-N-review-M.md` (M increments per review round)
- **Loop condition:** If changes needed → return to Implementer with review findings. All findings must be addressed before next review iteration.
- **Next on approval:** Spec & Phase Review

#### 4d. Spec & Phase Review
- **Agent:** `spec-phase-reviewer`
- **Input:** `spec.md` + phase document + code + test results + code review
- **Output:** `phase-reviews/phase-N-completion.md`
- **Loop condition:** If gaps found → return to Implementer with gap details. All gaps must be addressed before next review iteration.
- **Next on complete:** Next phase (or Final Review if last phase)

### Phase 8: Final Spec Review
- **Agent:** `final-spec-reviewer`
- **Input:** `spec.md` + all phase documents + all artifacts
- **Output:** `final-review.md`
- **Result:** Feature complete or list of remaining gaps

## Orchestrator Decision Rules

1. **Never skip phases** — every phase must complete before moving to the next
2. **Track loop iterations** — if any inner loop exceeds 10 iterations, surface to user for guidance
3. **Phase checklist must be 100%** before phase review
4. **Always pass context** — each sub-agent invocation must include relevant prior artifacts
5. **Feature folder must exist** before any agent writes to it
6. **Read artifacts between steps** — after each sub-agent completes, read its output files before invoking the next sub-agent