flow-retrospective-cycle

What this skill does

<!-- AIWG-SKILL-CALLOUT -->
> **Skill access pattern (post-kernel-pivot, 2026.5+)**
>
> Skill names referenced in this document are AIWG skills, **not slash commands**. Most are not kernel-listed and cannot be invoked as `/skill-name` by the platform. Reach them via:
>
> ```bash
> aiwg discover "<capability>"
> aiwg show skill <name>
> ```
>
> Only kernel-listed skills (`aiwg-doctor`, `aiwg-refresh`, `aiwg-status`, `aiwg-help`, `use`, `steward`) are directly invokable as slash commands. See [skill-discovery rule](../../../addons/aiwg-utils/rules/skill-discovery.md).


# Retrospective Cycle Flow

**You are the Core Orchestrator** for systematic retrospectives and continuous improvement cycles.

## 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):

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

## Retrospective Overview

**Purpose**: Facilitate structured team retrospectives to identify improvements, track action items, and measure effectiveness.

**Key Outputs**:
- Retrospective summary with insights
- Prioritized action items with owners
- Pattern analysis across retrospectives
- Improvement effectiveness metrics

**Success Criteria**:
- All team members participate
- At least 3 improvement opportunities identified
- 2-3 action items created with clear ownership
- Previous action items reviewed and updated
- Patterns documented across multiple retrospectives

**Expected Duration**: 2-3 hours (meeting), 30-45 minutes orchestration

## Natural Language Triggers

Users may say:
- "Run retrospective"
- "Hold retro"
- "Let's do a retrospective"
- "Retrospective for iteration {N}"
- "Sprint retrospective"
- "Team retrospective"
- "Post-incident review"
- "Lessons learned session"
- "What went well, what could improve"

You recognize these as requests for this orchestration flow.

## Parameter Handling

### Retrospective Types

- **iteration**: End-of-iteration retrospective (1-2 weeks)
- **release**: End-of-release retrospective (major milestone)
- **phase**: End-of-phase retrospective (Inception, Elaboration, Construction, Transition)
- **incident**: Post-incident retrospective (production issues)
- **project**: End-of-project retrospective (full lifecycle review)

### --guidance Parameter

**Purpose**: User provides upfront direction to tailor retrospective focus

**Examples**:
```
--guidance "Focus on team morale and burnout issues"
--guidance "Deep dive on quality problems, high defect rate"
--guidance "Address communication gaps between teams"
--guidance "Review deployment failures and infrastructure issues"
```

**How to Apply**:
- Parse guidance for keywords: morale, quality, communication, technical, process
- Select appropriate retrospective format (Mad/Sad/Glad for morale, Timeline for incidents)
- Adjust facilitation questions and focus areas
- Influence action item priorities

### --interactive Parameter

**Purpose**: You ask 6 strategic questions to understand retrospective context

**Questions to Ask** (if --interactive):

```
I'll ask 6 strategic questions to tailor the retrospective to your needs:

Q1: What are your main concerns or pain points from this iteration/phase?
    (Helps focus discussion on most impactful areas)

Q2: How would you rate team morale (1-10) and why?
    (Determines if we need morale-focused format like Mad/Sad/Glad)

Q3: Were there any major incidents or failures to discuss?
    (Indicates need for Timeline retrospective or root cause analysis)

Q4: What's your team's retrospective maturity?
    (New to retros, experienced, struggling with follow-through)

Q5: How many previous action items are still open?
    (Indicates potential action item overload or execution issues)

Q6: What specific outcomes do you want from this retrospective?
    (Clear goals help focus facilitation and ensure value)

Based on your answers, I'll:
- Select optimal retrospective format
- Focus on highest-impact areas
- Adjust facilitation approach
- Prioritize action item categories
```

**Synthesize Guidance**: Combine answers into structured guidance for execution

## Retrospective Formats

### Start/Stop/Continue
**Best for**: General purpose retrospectives, teams new to retros
- What should we START doing?
- What should we STOP doing?
- What should we CONTINUE doing?

### 4Ls (Liked, Learned, Lacked, Longed For)
**Best for**: Learning-focused retrospectives, new technology adoption
- What did we LIKE about this iteration?
- What did we LEARN?
- What did we LACK (missing resources, skills, information)?
- What did we LONG FOR (wish we had)?

### Mad/Sad/Glad
**Best for**: Addressing team morale and emotional health
- What made us MAD (frustrations)?
- What made us SAD (disappointments)?
- What made us GLAD (celebrations)?

### Timeline Retrospective
**Best for**: Complex iterations, incident retrospectives
- Create timeline of key events
- Mark emotional highs and lows
- Identify turning points
- Discuss root causes

### Sailboat Retrospective
**Best for**: Identifying impediments and accelerators
- Wind (what's helping us move forward?)
- Anchor (what's holding us back?)
- Rocks (risks ahead)
- Island (our goal)

## Multi-Agent Orchestration Workflow

### Step 1: Pre-Retrospective Preparation

**Purpose**: Gather data and prepare for effective retrospective session

**Your Actions**:

1. **Collect Metrics and Context**:
   ```
   Read existing artifacts:
   - .aiwg/planning/iteration-plans/*.md (recent iterations)
   - .aiwg/quality/code-reviews/*.md (quality trends)
   - .aiwg/testing/test-results/*.md (defect trends)
   - .aiwg/reports/previous-retrospectives/*.md (past retros)
   ```

2. **Launch Pre-Retro Analysis** (parallel agents):
   ```
   # Agent 1: Metrics Analyst
   Task(
       subagent_type="scrum-master",
       description="Collect iteration metrics for retrospective",
       prompt="""
       Gather metrics for retrospective preparation:

       Iteration Performance:
       - Velocity: Story points planned vs. completed
       - Cycle time: Average time from start to done
       - Defect escape rate: Bugs found in production
       - Deployment frequency: Number of deployments

       Quality Metrics:
       - Test coverage: Current percentage and trend
       - Code review cycle time: PR open to merge
       - Technical debt: Time spent on refactoring

       Team Health:
       - Unplanned work: Percentage of iteration
       - Meeting effectiveness: Time in meetings
       - On-call incidents: Number and severity

       Previous Actions:
       - Review .aiwg/reports/retrospectives/action-items.md
       - Status of previous action items (completed, in progress, blocked)

       Create metrics summary:
       Save to: .aiwg/working/retrospective/metrics-summary.md
       """
   )

   # Agent 2: Feedback Collector
   Task(
       subagent_type="agile-coach",
       description="Design pre-retrospective survey",
       prompt="""
       Create anonymous feedback survey for team members:

       Survey Questions:
       1. Rate this iteration (1-10) and why?
       2. What was your biggest win this iteration?
       3. What was your biggest challenge?
       4. What one thing would improve our team's effectiveness?
       5. Any topics you want discussed in the retrospective?

       Format Selection:
       Based on context, recommend retrospective format:
       - If morale issues → Mad/Sad/Glad
       - If incident occurred → Timeline
       - If general iteration → Start/Stop/Continue
       - If learning focus → 4Ls

       Create survey template:
       Save to: .aiwg/working/retrospective/pre-retro-survey.md
       """
   )

   # Agent 3: Patte