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

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

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:

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)

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: Pattern Analyzer
Task(
    subagent_type="retrospective-analyzer",
    description="Identify patterns from previous retrospectives",
    prompt="""
    Read previous retrospectives: .aiwg/reports/retrospectives/*.md

    Identify patterns:
    - Recurring issues (appearing in 3+ retrospectives)
    - Chronic incomplete actions (never resolved)
    - Improvement trends (what's getting better/worse)
    - Team dynamics patterns

    Categorize patterns:
    - Process issues
    - Technical challenges
    - Communication gaps
    - Tool/infrastructure problems
    - Team health concerns

    Create pattern analysis:
    Save to: .aiwg/working/retrospective/pattern-analysis.md
    """
)

Prepare Retrospective Agenda:

Task(
    subagent_type="scrum-master",
    description="Create retrospective agenda",
    prompt="""
    Read preparation artifacts:
    - .aiwg/working/retrospective/metrics-summary.md
    - .aiwg/working/retrospective/pre-retro-survey.md
    - .aiwg/working/retrospective/pattern-analysis.md

    Create structured agenda:

    1. Set the Stage (10 min)
       - Welcome and safety check
       - Review working agreements
       - Share agenda and format

    2. Gather Data (20 min)
       - Review metrics summary
       - Share survey highlights
       - Timeline reconstruction (if applicable)

    3. Generate Insights (30 min)
       - {Selected format activities}
       - Pattern discussion
       - Root cause analysis for key issues

    4. Decide What to Do (20 min)
       - Dot voting on improvements
       - Convert top items to actions
       - Assign owners and dates

    5. Close (10 min)
       - Appreciation round
       - Commitment check
       - Next steps

    Total Duration: 90 minutes

    Save to: .aiwg/working/retrospective/agenda.md
    """
)

Communicate Progress:

✓ Pre-retrospective preparation complete
  ✓ Metrics collected (velocity, quality, team health)
  ✓ Survey template created
  ✓ Patterns analyzed from 5 previous retrospectives
  ✓ Agenda prepared (90-minute session)

Step 2: Facilitate Retrospective Session

Purpose: Guide structured retrospective using selected format

Your Actions:

Set the Stage:

Task(
    subagent_type="scrum-master",
    description="Initialize retrospective session",
    prompt="""
    Create retrospective session opening:

    Safety Check:
    - Psychological safety reminder (no blame culture)
    - Vegas rule (what's said here, stays here)
    - Focus on systems, not people

    Working Agreements:
    - One conversation at a time
    - All ideas are valid
    - Time-boxed discussions
    - Action items must have owners

    Format Introduction:
    - Explain selected format: {format}
    - Set expectations for participation
    - Review timeline (90 minutes)

    Create session initialization:
    Save to: .aiwg/working/retrospective/session-opening.md
    """
)

Facilitate Format-Specific Activities (based on selected format):

# Example: Start/Stop/Continue Format
Task(
    subagent_type="agile-coach",
    description="Facilitate Start/Stop/Continue retrospective",
    prompt="""
    Read metrics and patterns:
    - .aiwg/working/retrospective/metrics-summary.md
    - .aiwg/working/retrospective/pattern-analysis.md

    Facilitate discussion:

    START (What should we start doing?):
    - New practices to adopt
    - Tools or processes to try
    - Experiments to run

    STOP (What should we stop doing?):
    - Wasteful activities
    - Ineffective meetings
    - Outdated processes

    CONTINUE (What should we continue doing?):
    - Successful practices
    - Effective collaborations
    - Working processes

    For each category:
    - Brainstorm items (5-10 per category)
    - Group similar items
    - Discuss themes

    Create categorized lists:
    Save to: .aiwg/working/retrospective/start-stop-continue.md
    """
)

Generate Insights and Root Causes:

Task(
    subagent_type="retrospective-analyzer",
    description="Analyze feedback and identify root causes",
    prompt="""
    Read retrospective feedback:
    - .aiwg/working/retrospective/{format-output}.md

    Generate insights:

    1. Identify Top Issues (3-5):
       - Most mentioned problems
       - Highest impact on team
       - Easiest to address

    2. Root Cause Analysis (5 Whys):
       For each top issue:
       - Why did this happen? (surface cause)
       - Why did that occur? (deeper)
       - Continue until root cause found

    3. Pattern Recognition:
       - Link to historical patterns
       - Identify systemic issues
       - Highlight chronic problems

    4. Improvement Hypotheses:
       - If we do X, we expect Y
       - Measurable outcomes
       - Success criteria

    Create insights document:
    Save to: .aiwg/working/retrospective/insights-and-root-causes.md
    """
)

Communicate Progress:

✓ Retrospective session facilitated
  ✓ Safety check and working agreements established
  ✓ {Format} activities completed
  ✓ 15+ improvement ideas generated
  ✓ Root causes identified for top 3 issues

Step 3: Create and Prioritize Action Items

Purpose: Convert insights into specific, actionable improvements

Your Actions:

Prioritize Improvements:

Task(
    subagent_type="scrum-master",
    description="Prioritize retrospective improvements",
    prompt="""
    Read insights: .aiwg/working/retrospective/insights-and-root-causes.md

    Prioritization using dot voting simulation:

    Criteria for prioritization:
    - Impact: How much will this help? (High/Medium/Low)
    - Effort: How hard is it to implement? (High/Medium/Low)
    - Team control: Can we do this ourselves? (Yes/Partial/No)

    Create prioritization matrix:
    - Quick wins (High impact, Low effort)
    - Strategic improvements (High impact, High effort)
    - Fill-ins (Low impact, Low effort)
    - Avoid (Low impact, High effort)

    Select top 2-3 improvements:
    - At least 1 quick win
    - No more than 1 high-effort item
    - Must be within team's control

    Document prioritization:
    Save to: .aiwg/working/retrospective/prioritized-improvements.md
    """
)

Create SMART Action Items:

Task(
    subagent_type="project-manager",
    description="Convert improvements to SMART action items",
    prompt="""
    Read prioritized improvements: .aiwg/working/retrospective/prioritized-improvements.md

    For each improvement (2-3 total), create SMART action item:

    Template:
    - Title: Clear, action-oriented title
    - Specific: What exactly will be done?
    - Measurable: How will we know it's complete?
    - Achievable: Is this realistic in 1-2 iterations?
    - Relevant: How does this address the root cause?
    - Time-bound: Due date (typically next retro)
    - Owner: Who is responsible? (specific person)
    - Success Criteria: Observable outcome

    Example:
    Title: Implement PR review SLA
    Specific: Add automated reminder for PRs open >24 hours
    Measurable: 90% of PRs reviewed within 24 hours
    Achievable: Yes, GitHub Actions supports this
    Relevant: Addresses slow feedback cycle pain point
    Time-bound: Implemented by next iteration (2 weeks)
    Owner: DevOps Lead (John Smith)
    Success: Average PR review time <24 hours for 2 weeks

    Create action items document:
    Save to: .aiwg/working/retrospective/action-items.md
    """
)

Link to Work Management:

Task(
    subagent_type="scrum-master",
    description="Create work items for action items",
    prompt="""
    Read action items: .aiwg/working/retrospective/action-items.md

    For each action item, create:

    1. Work Package Card:
       Use template: $AIWG_ROOT/.../work-package-card-template.md
       - Type: Improvement
       - Priority: High (retro action)
       - Iteration: Next iteration
       - Acceptance criteria from success criteria

    2. Add to Backlog:
       - Reserve capacity (10-20% of iteration)
       - Link to retrospective
       - Tag as "retro-action"

    3. Tracking Entry:
       Update: .aiwg/reports/retrospectives/action-tracker.md
       - Action ID (RETRO-{date}-{number})
       - Status: NOT_STARTED
       - Due date
       - Owner

    Create work packages:
    Save to: .aiwg/planning/work-packages/retro-actions-{date}.md
    """
)

Communicate Progress:

✓ Action items created and assigned
  ✓ 3 improvements prioritized (2 quick wins, 1 strategic)
  ✓ SMART action items defined with owners
  ✓ Work packages created in backlog
  ✓ Tracking system updated

Step 4: Document Retrospective Summary

Purpose: Create comprehensive record of retrospective outcomes

Your Actions:

Generate Retrospective Report:

Task(
    subagent_type="scrum-master",
    description="Create retrospective summary report",
    prompt="""
    Read all retrospective artifacts:
    - .aiwg/working/retrospective/metrics-summary.md
    - .aiwg/working/retrospective/{format-output}.md
    - .aiwg/working/retrospective/insights-and-root-causes.md
    - .aiwg/working/retrospective/action-items.md
    - .aiwg/reports/retrospectives/action-tracker.md (previous actions)

    Create comprehensive report:

    # {Retrospective Type} Retrospective - {Iteration/Phase}

    **Date**: {current-date}
    **Participants**: {count} team members
    **Format**: {format used}
    **Facilitator**: Scrum Master

    ## Metrics Summary
    - Velocity: {points} (trend: {up/down/stable})
    - Cycle Time: {days} (trend: {up/down/stable})
    - Defect Rate: {percentage}%
    - Team Satisfaction: {score}/10

    ## Previous Action Items Review
    - Total: {count}
    - Completed: {count} ({percentage}%)
    - In Progress: {count}
    - Blocked: {count}

    ## What Went Well
    {List positive items with specific examples}

    ## What Could Improve
    {List improvement areas with specific examples}

    ## Root Cause Analysis

    Top Issue #1: {issue}
    Root Cause: {5 whys result}

    Top Issue #2: {issue}
    Root Cause: {5 whys result}

    ## Action Items

    1. {Action title}
       - Owner: {name}
       - Due: {date}
       - Success Criteria: {measurable outcome}

    2. {Action title}
       - Owner: {name}
       - Due: {date}
       - Success Criteria: {measurable outcome}

    3. {Action title}
       - Owner: {name}
       - Due: {date}
       - Success Criteria: {measurable outcome}

    ## Patterns and Trends
    {Patterns identified across retrospectives}

    ## Team Appreciation
    {Shout-outs and recognition}

    ## Next Retrospective
    - Date: {scheduled date}
    - Format: {proposed format}
    - Focus Areas: {topics to explore}

    Save to: .aiwg/reports/retrospectives/retro-{date}.md
    """
)

Update Action Item Tracker:

Task(
    subagent_type="project-manager",
    description="Update master action item tracker",
    prompt="""
    Read current tracker: .aiwg/reports/retrospectives/action-tracker.md
    Read new actions: .aiwg/working/retrospective/action-items.md

    Update tracker with:

    1. New Actions:
       - Add new action items with IDs
       - Status: NOT_STARTED
       - Source: Retro-{date}

    2. Previous Actions:
       - Update status (COMPLETED, IN_PROGRESS, BLOCKED, CANCELLED)
       - Add completion evidence if done
       - Document blockers if stuck

    3. Metrics:
       - Total actions to date
       - Completion rate (rolling 90 days)
       - Average time to completion
       - Chronic issues (3+ retros)

    Save updated tracker to: .aiwg/reports/retrospectives/action-tracker.md
    """
)

Archive Working Files:

# You do this directly
mkdir -p .aiwg/archive/retrospectives/{date}
mv .aiwg/working/retrospective/* .aiwg/archive/retrospectives/{date}/

Create audit trail:
.aiwg/archive/retrospectives/{date}/audit-trail.md

Communicate Progress:

✓ Retrospective documentation complete
  ✓ Comprehensive report generated
  ✓ Action tracker updated (lifetime: 47 actions, 72% completion rate)
  ✓ Working files archived

Step 5: Track and Measure Effectiveness

Purpose: Monitor action item progress and measure improvement impact

Your Actions:

Setup Progress Tracking:

Task(
    subagent_type="scrum-master",
    description="Create action item progress tracking",
    prompt="""
    Read action items: .aiwg/reports/retrospectives/action-tracker.md

    Create tracking mechanisms:

    1. Weekly Check-in Template:
       - Action item status review
       - Blocker identification
       - Progress percentage
       - Help needed flag

    2. Reminder Schedule:
       - Day 3: Initial progress check
       - Day 7: Mid-point review
       - Day 10: Final push reminder
       - Day 14: Due date

    3. Escalation Path:
       - If blocked >3 days: Team lead
       - If blocked >7 days: Manager
       - If chronic (3+ retros): Executive

    Create tracking template:
    Save to: .aiwg/reports/retrospectives/progress-tracking-template.md
    """
)

Define Success Metrics:

Task(
    subagent_type="retrospective-analyzer",
    description="Define improvement effectiveness metrics",
    prompt="""
    Read action items: .aiwg/working/retrospective/action-items.md

    For each action item, define:

    1. Baseline Metric:
       - Current state measurement
       - Data source
       - Collection method

    2. Target Metric:
       - Expected improvement
       - Success threshold
       - Measurement timeline

    3. Validation Method:
       - How to measure (automated, manual)
       - When to measure (daily, weekly)
       - Who validates (owner, team)

    Example:
    Action: Implement PR review SLA
    Baseline: Average PR review time = 48 hours
    Target: Average PR review time < 24 hours
    Validation: GitHub API daily report for 2 weeks

    Create metrics definition:
    Save to: .aiwg/reports/retrospectives/effectiveness-metrics.md
    """
)

Generate Follow-up Tasks:

Task(
    subagent_type="project-manager",
    description="Create follow-up tasks",
    prompt="""
    Create TodoWrite items for retrospective follow-up:

    Immediate (Due in 3 days):
    - [ ] Share retrospective summary with team
    - [ ] Add action items to sprint backlog
    - [ ] Schedule action item kick-off meeting

    Weekly (Recurring):
    - [ ] Review action item progress in standup
    - [ ] Update action tracker status
    - [ ] Identify and escalate blockers

    Before Next Retro:
    - [ ] Measure improvement effectiveness
    - [ ] Collect evidence of completion
    - [ ] Prepare action item status report

    Use TodoWrite tool to create tasks with due dates
    """
)

Communicate Progress:

✓ Effectiveness tracking established
  ✓ Progress tracking template created
  ✓ Success metrics defined for all actions
  ✓ Follow-up tasks scheduled

Success Criteria

This orchestration succeeds when:

Common Anti-Patterns and Remediation

Low Participation

Detection: <50% team attendance or engagement Remediation:

Use anonymous surveys for input
Rotate retrospective times
Try different formats to re-engage
Consider shorter, more frequent retros

Action Items Not Completed

Detection: <50% completion rate Remediation:

Reduce to 1-2 action items maximum
Ensure items are within team control
Reserve explicit capacity in iteration
Escalate systemic blockers

Same Issues Recurring

Detection: Issue appears in 3+ consecutive retrospectives Remediation:

Escalate to leadership as systemic issue
Conduct focused problem-solving session
Consider bringing in external facilitator
Document as organizational impediment

Superficial Analysis

Detection: Actions address symptoms, not root causes Remediation:

Use 5 Whys or fishbone diagrams
Extend time for insight generation
Bring in subject matter experts
Conduct separate deep-dive sessions

Quality Gates

Before marking workflow complete, verify:

All artifacts saved to appropriate .aiwg/ directories
Previous retrospectives reviewed for patterns
Action items are SMART and assigned
Tracking mechanisms established
Summary report comprehensive and actionable

User Communication

At start: Confirm understanding and outline process

Understood. I'll orchestrate a {type} retrospective cycle.

This will:
- Collect metrics and prepare agenda
- Facilitate {format} retrospective format
- Identify root causes and patterns
- Create 2-3 SMART action items
- Setup tracking and effectiveness measures

Expected duration: 30-45 minutes orchestration

Starting retrospective cycle...

During: Update progress with clear status indicators

✓ = Complete
⏳ = In progress
📊 = Metrics collected
🎯 = Action items created

At end: Summary with key outcomes and next steps

═══════════════════════════════════════════════
Retrospective Cycle Complete
═══════════════════════════════════════════════

**Type**: {Iteration} Retrospective
**Format Used**: Start/Stop/Continue
**Participation**: 8/10 team members

**Key Metrics**:
- Velocity: 42 points (↑ from 38)
- Cycle Time: 3.2 days (↓ from 4.1)
- Team Satisfaction: 7.5/10 (↑ from 6.8)

**Previous Actions**: 3 total
- Completed: 2 (67%)
- In Progress: 1 (33%)

**New Action Items**: 3 created
1. Implement PR review SLA automation
   Owner: DevOps Lead | Due: 2 weeks

2. Establish coding standards document
   Owner: Tech Lead | Due: 3 weeks

3. Add integration test coverage
   Owner: QA Lead | Due: Next iteration

**Patterns Identified**:
- Code review delays (4 retros)
- Test coverage gaps (3 retros)
- Documentation debt (5 retros)

**Artifacts Created**:
- Retrospective Report: .aiwg/reports/retrospectives/retro-{date}.md
- Action Tracker: .aiwg/reports/retrospectives/action-tracker.md
- Work Packages: .aiwg/planning/work-packages/retro-actions-{date}.md

**Next Steps**:
1. Share summary with team
2. Add actions to sprint backlog
3. Weekly progress reviews
4. Next retro: {date} (2 weeks)

═══════════════════════════════════════════════

Error Handling

If Low Participation:

⚠️ Low participation detected: {count}/{total} team members

Adjusting approach:
- Collecting asynchronous feedback
- Extending input window to 24 hours
- Using anonymous survey format

Consider scheduling follow-up session for full team input.

If Chronic Issues Detected:

⚠️ Chronic issue detected: {issue} (appeared in 5 consecutive retros)

This requires escalation:
- Issue documented as organizational impediment
- Escalation report prepared for leadership
- Root cause analysis indicates systemic blocker

Recommendation: Schedule focused problem-solving session with stakeholders

If Action Overload:

⚠️ High number of incomplete actions: {count} open items

Recommendation:
- Close stale items (>60 days old)
- Limit new actions to 1-2 maximum
- Focus on highest impact items only
- Consider action item amnesty

Adjusting to create only 2 new actions (down from 3)

References

Templates (via $AIWG_ROOT):

Retrospective: templates/management/retrospective-template.md
Action Tracker: templates/management/action-item-tracker.md
Work Package: templates/management/work-package-card-template.md
Lessons Learned: templates/management/lessons-learned-card.md

Retrospective Formats:

Agile Retrospectives by Derby & Larsen
Retromat.org format library

Related Flows:

/flow-iteration-planning - Plan iterations with retro actions
/flow-gate-check - Include retro completion in gates
/flow-change-control - Process improvements may need CCB

Metrics Tracking:

metrics/team-health-metrics.md
metrics/process-efficiency-metrics.md

/flow-retrospective-cycle

Retrospective Cycle Flow

Your Role

Retrospective Overview

Natural Language Triggers

Parameter Handling

Retrospective Types

--guidance Parameter

--interactive Parameter

Retrospective Formats

Start/Stop/Continue

4Ls (Liked, Learned, Lacked, Longed For)

Mad/Sad/Glad

Timeline Retrospective

Sailboat Retrospective

Multi-Agent Orchestration Workflow

Step 1: Pre-Retrospective Preparation

Step 2: Facilitate Retrospective Session

Step 3: Create and Prioritize Action Items

Step 4: Document Retrospective Summary

Step 5: Track and Measure Effectiveness

Success Criteria

Common Anti-Patterns and Remediation

Low Participation

Action Items Not Completed

Same Issues Recurring

Superficial Analysis

Quality Gates

User Communication

Error Handling

References