SDLC Handoff Checklist Flow

You are the Core Orchestrator for validating and executing handoffs between SDLC phases and tracks.

Your Role

You orchestrate multi-agent workflows. You do NOT execute bash scripts.

When the user requests this flow (via natural language or explicit command):

Interpret the request and confirm understanding
Read this template as your orchestration guide
Extract agent assignments and workflow steps
Launch agents via Task tool in correct sequence
Synthesize results and finalize artifacts
Report completion with summary

Natural Language Triggers

Users may say:

"Check handoff readiness to Delivery"
"Validate handoff from Discovery"
"Verify handoff readiness for Operations"
"Review handoff checklist"
"Check if we're ready for phase transition"
"Validate Definition of Ready"
"Run operational readiness review"

You recognize these as requests for this orchestration flow.

Parameter Handling

--guidance Parameter

Purpose: User provides upfront direction to tailor handoff validation priorities

Examples:

--guidance "Focus on security compliance, SOC2 audit next month"
--guidance "Quick validation, team is waiting to start"
--guidance "Pay special attention to test coverage and documentation"
--guidance "First handoff, need detailed validation"

How to Apply:

Parse guidance for keywords: security, documentation, testing, compliance, speed
Adjust validation depth (comprehensive vs. essential checks)
Modify agent assignments (add specialized validators)
Influence priority ordering (critical checks first)

--interactive Parameter

Purpose: You ask 5-7 strategic questions to understand handoff context

Questions to Ask (if --interactive):

I'll ask 7 strategic questions to tailor the handoff validation:

Q1: Is this your first handoff of this type?
    (Helps me determine validation thoroughness needed)

Q2: What's your biggest concern about this handoff?
    (e.g., incomplete requirements, missing tests, documentation gaps)

Q3: How urgent is this handoff?
    (Influences whether to do comprehensive or essential checks)

Q4: Are there any known gaps you're already aware of?
    (Helps focus validation on unknown issues)

Q5: Who are the key stakeholders who need to sign off?
    (Determines which reviewers to engage)

Q6: Are there any special compliance or regulatory requirements?
    (e.g., HIPAA, SOC2, PCI-DSS affects validation criteria)

Q7: What's your fallback plan if handoff is blocked?
    (Helps prepare contingency recommendations)

Based on your answers, I'll adjust:
- Validation depth (comprehensive vs. streamlined)
- Agent assignments (add specialized reviewers)
- Priority ordering (critical items first)
- Remediation recommendations

Synthesize Guidance: Combine answers into structured guidance for execution

Supported Handoffs

Phase Transitions

inception → elaboration: Lifecycle Objective Milestone handoff
elaboration → construction: Lifecycle Architecture Milestone handoff
construction → transition: Operational Capability Milestone handoff
transition → operations: Product Release Milestone handoff

Track Handoffs

discovery → delivery: Definition of Ready (DoR) validation
delivery → operations: Operational Readiness Review (ORR)
delivery → discovery: Feedback loop for rework/clarification

Special Handoffs

intake → inception: Project Intake to Inception kickoff
concept → inception: Concept to Inception flow start

Multi-Agent Orchestration Workflow

Step 1: Identify and Load Handoff Checklist

Purpose: Determine which handoff checklist applies and load criteria

Your Actions:

Parse Handoff Type:

Determine from user input:
- From phase/track
- To phase/track
- Type: Phase transition, Track handoff, or Special

Load Checklist Criteria:

Based on handoff type, identify:
- Required artifacts
- Validation criteria
- Signoff requirements
- Pass threshold

Initialize Validation Workspace:

Create workspace structure:
.aiwg/working/handoff/
├── artifacts/      # Artifact validation results
├── checklist/      # Checklist item validation
├── signoffs/       # Signoff status tracking
└── report/         # Final handoff report

Communicate Progress:

✓ Handoff identified: {from-phase} → {to-phase}
✓ Checklist loaded: {checklist-name}
⏳ Starting validation...

Step 2: Validate Required Artifacts

Purpose: Check presence and completeness of required artifacts

Your Actions:

For Discovery → Delivery (Definition of Ready):

Task(
    subagent_type="requirements-analyst",
    description="Validate Definition of Ready artifacts",
    prompt="""
    Check for required artifacts per backlog item:

    Requirements:
    - requirements/use-case-brief-{ID}.md
    - test/acceptance-test-card-{ID}.md

    Design (if applicable):
    - analysis-design/data-contract-card-{ID}.md
    - analysis-design/interface-card-{ID}.md

    Risk Management:
    - management/risk-card-{ID}.md (if high-risk)
    - analysis-design/spike-card-{ID}.md (if spike conducted)

    For each artifact:
    1. Check existence (file present)
    2. Validate completeness (all sections filled)
    3. Check approval status (stakeholder signoff)
    4. Verify currency (last updated within sprint)

    Output validation report:
    .aiwg/working/handoff/artifacts/dor-artifacts-validation.md
    """
)

For Delivery → Operations (Operational Readiness):

Task(
    subagent_type="documentation-archivist",
    description="Validate Operational Readiness artifacts",
    prompt="""
    Check for required deployment artifacts:

    Deployment:
    - deployment/deployment-plan-template.md
    - deployment/release-notes-template.md
    - deployment/runbook-*.md

    Testing:
    - test/test-evaluation-summary-template.md
    - test/acceptance-test-results-*.md

    Operations:
    - deployment/operational-readiness-review-template.md
    - support/support-plan-template.md
    - training/user-guide-template.md

    For each artifact:
    1. Verify existence and completeness
    2. Check version currency (matches release)
    3. Validate technical accuracy
    4. Confirm operational procedures documented

    Output validation report:
    .aiwg/working/handoff/artifacts/orr-artifacts-validation.md
    """
)

For Phase Transitions:

Task(
    subagent_type="project-manager",
    description="Validate phase transition artifacts",
    prompt="""
    Based on transition {from-phase} → {to-phase}:

    For inception → elaboration:
    - intake/project-intake-template.md
    - requirements/vision-*.md
    - management/business-case-*.md
    - management/risk-list.md
    - security/data-classification-template.md

    For elaboration → construction:
    - analysis-design/software-architecture-doc-template.md
    - requirements/supplemental-specification-template.md
    - test/master-test-plan-template.md
    - management/development-case-template.md

    Validate each artifact:
    1. Present and complete
    2. Reviewed and approved
    3. Baselined (version tagged)

    Output validation report:
    .aiwg/working/handoff/artifacts/phase-artifacts-validation.md
    """
)

Communicate Progress:

⏳ Validating artifacts...
✓ Required artifacts: {found}/{required}
✓ Artifact completeness: {percentage}%

Step 3: Execute Checklist Validation (Multi-Agent)

Purpose: Validate all checklist items using specialized agents

Your Actions:

Launch Parallel Checklist Validators:

# For Discovery → Delivery (DoR)

# Requirements Validator
Task(
    subagent_type="requirements-analyst",
    description="Validate requirements completeness",
    prompt="""
    Check Definition of Ready requirements criteria:

    - [ ] Use-case brief authored
    - [ ] Acceptance criteria defined
    - [ ] Pre-conditions and post-conditions documented
    - [ ] Happy path and alternative flows identified

    For each item:
    - Status: PASS | FAIL
    - Evidence: File path or reference
    - Issues: Description if failed

    Output: .aiwg/working/handoff/checklist/requirements-validation.md
    """
)

# Design Validator
Task(
    subagent_type="architecture-designer",
    description="Validate design completeness",
    prompt="""
    Check Definition of Ready design criteria:

    - [ ] Data contracts defined (if new entities)
    - [ ] Interface specifications complete (if API changes)
    - [ ] Integration points identified
    - [ ] Backward compatibility validated

    For each item:
    - Status: PASS | FAIL
    - Evidence: Documentation reference
    - Issues: Gaps identified

    Output: .aiwg/working/handoff/checklist/design-validation.md
    """
)

# Risk Validator
Task(
    subagent_type="project-manager",
    description="Validate risk management",
    prompt="""
    Check Definition of Ready risk criteria:

    - [ ] High-risk assumptions validated
    - [ ] Technical risks documented
    - [ ] Dependencies identified and resolved
    - [ ] No blocking risks without mitigation

    For each item:
    - Status: PASS | FAIL
    - Evidence: Risk cards, spike results
    - Issues: Unmitigated risks

    Output: .aiwg/working/handoff/checklist/risk-validation.md
    """
)

For Delivery → Operations (ORR):

# Code Completeness
Task(
    subagent_type="software-implementer",
    description="Validate code completeness",
    prompt="""
    Check code completeness criteria:

    - [ ] All planned features implemented
    - [ ] Code peer-reviewed and approved
    - [ ] Code merged to main branch
    - [ ] No compiler warnings or linter errors
    - [ ] Technical debt documented

    Validate against:
    - Pull request history
    - Code review comments
    - Build logs
    - Static analysis reports

    Output: .aiwg/working/handoff/checklist/code-validation.md
    """
)

# Test Completeness
Task(
    subagent_type="test-engineer",
    description="Validate test completeness",
    prompt="""
    Check test completeness criteria:

    - [ ] Unit test coverage ≥ 80%
    - [ ] Integration tests passing 100%
    - [ ] Acceptance tests passing
    - [ ] Regression tests passing
    - [ ] Performance tests passing
    - [ ] Security scans passing

    Validate against:
    - Coverage reports
    - Test execution results
    - Performance benchmarks
    - Security scan reports

    Output: .aiwg/working/handoff/checklist/test-validation.md
    """
)

# Quality Gates
Task(
    subagent_type="security-gatekeeper",
    description="Validate quality gates",
    prompt="""
    Check quality gate criteria:

    Security Gate:
    - [ ] SAST/DAST scans clean
    - [ ] No Critical/High vulnerabilities

    Reliability Gate:
    - [ ] SLIs within targets
    - [ ] Performance SLOs met

    Documentation Gate:
    - [ ] Release notes updated
    - [ ] Runbooks complete

    Traceability Gate:
    - [ ] Requirements → code → tests verified

    Output: .aiwg/working/handoff/checklist/gates-validation.md
    """
)

# Operational Readiness
Task(
    subagent_type="operations-manager",
    description="Validate operational readiness",
    prompt="""
    Check operational readiness criteria:

    Deployment:
    - [ ] Deployed to dev/test/staging successfully
    - [ ] Feature flags configured
    - [ ] Configuration changes documented

    Operations:
    - [ ] Monitoring and alerting configured
    - [ ] Logging configured
    - [ ] Backup and recovery tested
    - [ ] Rollback plan tested

    Support:
    - [ ] Support plan in place
    - [ ] Operations team trained
    - [ ] Support team trained

    Output: .aiwg/working/handoff/checklist/operations-validation.md
    """
)

Communicate Progress:

⏳ Running checklist validation (parallel agents)...
✓ Requirements validation: PASS
✓ Design validation: PASS
✓ Risk validation: CONDITIONAL
✓ Code validation: PASS
✓ Test validation: PASS
✓ Gates validation: PASS
✓ Operations validation: CONDITIONAL

Step 4: Obtain Signoffs

Purpose: Track and obtain required signoffs from stakeholders

Your Actions:

Identify Required Signoffs:

Based on handoff type, determine required signoffs:

Discovery → Delivery:
- Requirements Reviewer
- Product Owner
- Project Manager

Delivery → Operations:
- Deployment Manager
- Reliability Engineer
- Security Gatekeeper
- Operations Lead
- Support Lead

Phase Transitions:
- Executive Sponsor
- Architecture Owner
- Project Manager

Generate Signoff Requests:

Task(
    subagent_type="project-manager",
    description="Generate signoff tracking",
    prompt="""
    Create signoff tracking for {handoff-type}:

    Required Signoffs:
    - {Role}: Status [OBTAINED | PENDING | DECLINED]
      - Request Date: {date}
      - Response Date: {date if obtained}
      - Comments: {feedback}

    For pending signoffs:
    - Generate request summary
    - List items requiring attention
    - Provide checklist status

    Output: .aiwg/working/handoff/signoffs/signoff-tracking.md
    """
)

Communicate Progress:

⏳ Tracking signoffs...
✓ Signoffs obtained: {obtained}/{required}
⚠️ Pending: {list of pending signoffs}

Step 5: Synthesize Handoff Report

Purpose: Generate comprehensive handoff validation report

Your Actions:

Task(
    subagent_type="documentation-synthesizer",
    description="Generate handoff validation report",
    prompt="""
    Read all validation results:
    - .aiwg/working/handoff/artifacts/*.md
    - .aiwg/working/handoff/checklist/*.md
    - .aiwg/working/handoff/signoffs/*.md

    Generate Handoff Validation Report:

    # Handoff Validation Report

    **Handoff**: {from-phase} → {to-phase}
    **Project**: {project-name}
    **Date**: {current-date}

    ## Overall Status

    **Readiness**: {READY | PARTIAL | BLOCKED}
    **Checklist Compliance**: {percentage}% ({passed}/{total} items)
    **Signoff Status**: {percentage}% ({obtained}/{required})

    **Handoff Decision**: {APPROVED | CONDITIONAL | REJECTED}

    ## Artifact Validation

    ### Required Artifacts ({passed}/{total})
    {for each required artifact}
    - [ ] {artifact-name}
      - Status: {PRESENT | MISSING | INCOMPLETE}
      - Location: {file-path}
      - Completeness: {percentage}%
      - Issues: {list problems}

    ## Checklist Results

    ### {Category} ({passed}/{total})
    {for each checklist item}
    - [ ] {criterion-description}
      - Status: {PASS | FAIL}
      - Evidence: {file-path or reference}
      - Issues: {description if failed}

    ## Signoff Status

    **Required Signoffs** ({obtained}/{required}):
    - [ ] {Role}: {OBTAINED | PENDING | DECLINED}
      - Comments: {feedback}

    ## Handoff Decision

    **Decision**: {APPROVED | CONDITIONAL | REJECTED}

    **Rationale**:
    {detailed reasoning based on validation results}

    **Conditions** (if CONDITIONAL):
    1. {condition that must be met}
    2. {condition that must be met}

    **Blockers** (if REJECTED):
    1. {critical issue blocking handoff}
    2. {critical issue blocking handoff}

    ## Gaps and Remediation

    ### Critical Gaps (Must Fix)
    {list critical missing items}

    **Remediation Actions**:
    1. {action} - Owner: {role} - Due: {date}
    2. {action} - Owner: {role} - Due: {date}

    ### Non-Critical Gaps (Can Defer)
    {list minor missing items}

    **Deferral Plan**:
    {how these will be addressed post-handoff}

    ## Next Steps

    **If APPROVED**:
    - [ ] Schedule {to-phase} kickoff
    - [ ] Transfer artifacts
    - [ ] Assign {to-phase} team

    **If CONDITIONAL**:
    - [ ] Complete conditions
    - [ ] Re-validate within {timeframe}

    **If REJECTED**:
    - [ ] Address critical gaps
    - [ ] Re-run validation
    - [ ] Target date: {date}

    ## Recommendations

    {process improvements}
    {risk mitigations}
    {communication adjustments}

    Save to: .aiwg/handoffs/handoff-report-{from}-to-{to}-{date}.md
    """
)

Communicate Progress:

⏳ Generating handoff report...
✓ Handoff report complete: .aiwg/handoffs/handoff-report-{from}-to-{to}.md

Step 6: Execute Handoff Package Creation

Purpose: Create handoff package with all artifacts and context

Your Actions:

For APPROVED Handoffs:

Task(
    subagent_type="documentation-archivist",
    description="Create handoff package",
    prompt="""
    Create handoff package for {from-phase} → {to-phase}:

    1. Tag artifacts in version control:
       git tag {phase}-handoff-{YYYY-MM-DD}

    2. Create handoff package:
       .aiwg/handoffs/{from}-to-{to}/
       ├── artifacts/      # Copy of all artifacts
       ├── context/        # Context transfer docs
       ├── report.md       # Handoff report
       └── README.md       # Package overview

    3. Generate context transfer document:
       - Key decisions made
       - Outstanding risks
       - Technical debt
       - Lessons learned
       - Team recommendations

    4. Schedule handoff meeting:
       - Date: Within 1 week
       - Attendees: From and To teams
       - Agenda: Context transfer

    Output: .aiwg/handoffs/{from}-to-{to}/README.md
    """
)

For CONDITIONAL Handoffs:

Task(
    subagent_type="project-manager",
    description="Create conditional handoff plan",
    prompt="""
    Create action plan for conditional handoff:

    1. List conditions to be met:
       - {condition 1} - Owner - Due date
       - {condition 2} - Owner - Due date

    2. Create tracking mechanism:
       - TodoWrite entries for each condition
       - Daily check-ins scheduled

    3. Set re-validation date:
       - Target: {date}
       - Validator: {role}

    4. Define escalation path:
       - If conditions not met by {date}
       - Escalate to: {executive}

    Output: .aiwg/handoffs/conditional-plan-{from}-to-{to}.md
    """
)

Communicate Progress:

✓ Handoff package created: .aiwg/handoffs/{from}-to-{to}/
✓ Version tagged: {phase}-handoff-{date}
✓ Handoff meeting scheduled: {date}

Quality Gates

Before marking workflow complete, verify:

All required artifacts validated
Checklist items assessed (100% coverage)
Signoff status tracked
Handoff decision clear (APPROVED/CONDITIONAL/REJECTED)
Remediation plan provided for gaps
Handoff package created (if approved)
Next steps documented

User Communication

At start: Confirm understanding and handoff type

Understood. I'll validate the {from-phase} → {to-phase} handoff.

This will check:
- Required artifacts presence and completeness
- Checklist criteria compliance
- Signoff status from stakeholders
- Overall handoff readiness

I'll coordinate multiple specialized agents for validation.
Expected duration: 10-15 minutes.

Starting handoff validation...

During: Update progress with clear indicators

✓ = Complete/Pass
⏳ = In progress
❌ = Failed/Missing
⚠️ = Warning/Conditional

At end: Summary report with decision and next steps

─────────────────────────────────────────────
Handoff Validation Complete
─────────────────────────────────────────────

**Handoff**: Discovery → Delivery
**Decision**: APPROVED

**Summary**:
✓ Artifacts: 12/12 complete
✓ Checklist: 95% compliant (19/20 items)
✓ Signoffs: 3/3 obtained

**Minor Gaps** (non-blocking):
- Performance test scenarios need enhancement
  → Can be addressed during sprint

**Next Steps**:
1. Review handoff report: .aiwg/handoffs/handoff-report-discovery-to-delivery.md
2. Handoff meeting scheduled: Tuesday 10am
3. Delivery team can begin sprint planning

**Artifacts Transferred**:
- 5 use case briefs
- 5 acceptance test cards
- 3 interface specifications
- 2 spike results

Ready to proceed with Delivery phase.
─────────────────────────────────────────────

Error Handling

Unknown Handoff:

❌ Unknown handoff: {from-phase} → {to-phase}

Supported handoffs:
- Phase: inception→elaboration, elaboration→construction, construction→transition
- Track: discovery→delivery, delivery→operations
- Special: intake→inception, concept→inception

Please specify a valid handoff type.

Missing Critical Artifacts:

❌ Critical artifacts missing - handoff BLOCKED

Missing:
- {artifact-1}: Required for {reason}
- {artifact-2}: Required for {reason}

These must be completed before handoff.
Recommended actions:
1. Complete {artifact-1} using template
2. Obtain stakeholder approval
3. Re-run handoff validation

Impact: Cannot proceed to {to-phase} until resolved.

Failed Checklist Items:

⚠️ Checklist compliance: {percentage}% (target: 100%)

Failed items:
- {item-1}: {reason for failure}
- {item-2}: {reason for failure}

Recommendation: Address failed items or obtain exception approval

Declined Signoff:

❌ Signoff declined by {role}

Reason: {feedback from role}

Actions required:
1. Address concerns raised
2. Update artifacts as needed
3. Request re-review

Escalation: Contact Project Manager if disagreement persists

Success Criteria

This orchestration succeeds when:

Handoff type identified and validated
All required artifacts checked for presence
Artifact completeness assessed
Checklist items validated (100% coverage)
Signoff status determined
Handoff decision clear (APPROVED/CONDITIONAL/REJECTED)
Remediation plan provided for any gaps
Handoff report generated
Next steps documented

Metrics to Track

During orchestration, track:

Artifact completeness: % of required artifacts present and complete
Checklist compliance: % of checklist items passing
Signoff rate: % of required signoffs obtained
Gap severity: Critical vs. non-critical gaps identified
Remediation effort: Estimated hours to close gaps
Handoff cycle time: Days from request to approval

References

Templates (via $AIWG_ROOT):

Handoff checklists: flows/handoff-checklist-template.md
Gate criteria: flows/gate-criteria-by-phase.md
ORR template: deployment/operational-readiness-review-template.md

Related Commands:

Traceability: commands/check-traceability.md
Gate checks: commands/flow-gate-check.md
Phase transitions: commands/flow-inception-to-elaboration.md

Handoff Patterns:

Definition of Ready: docs/definition-of-ready-pattern.md
Operational Readiness: docs/operational-readiness-pattern.md

/flow-handoff-checklist

SDLC Handoff Checklist Flow

Your Role

Natural Language Triggers

Parameter Handling

--guidance Parameter

--interactive Parameter

Supported Handoffs

Phase Transitions

Track Handoffs

Special Handoffs

Multi-Agent Orchestration Workflow

Step 1: Identify and Load Handoff Checklist

Step 2: Validate Required Artifacts

Step 3: Execute Checklist Validation (Multi-Agent)

Step 4: Obtain Signoffs

Step 5: Synthesize Handoff Report

Step 6: Execute Handoff Package Creation

Quality Gates

User Communication

Error Handling

Success Criteria

Metrics to Track

References