Effective Sprint Retrospectives That Drive Real Improvement

// ❌ Typical retro output: vague and unactionable
interface BadRetroOutput {
  wentWell: string[];
  wentPoorly: string[];
  actionItems: string[];
}
 
const typicalRetro: BadRetroOutput = {
  wentWell: [
    "Good teamwork",
    "Delivered on time",
    "Communication was better",
  ],
  wentPoorly: [
    "Too many meetings",
    "Deploy process is slow",
    "Requirements keep changing",
  ],
  actionItems: [
    "Reduce meetings",          // Who? By when? How?
    "Improve deploy process",   // What specifically?
    "Better requirement docs",  // Whose responsibility?
  ],
};

// ✅ Structured retro output: specific and trackable
interface ActionItem {
  description: string;
  owner: string;
  dueDate: string;
  successCriteria: string;
  status: "not-started" | "in-progress" | "completed" | "dropped";
}
 
interface StructuredRetroOutput {
  theme: string;
  insights: {
    observation: string;
    impact: "high" | "medium" | "low";
    evidence: string;
  }[];
  actions: ActionItem[];
  previousActionsReview: {
    action: string;
    status: string;
    outcome: string;
  }[];
}
 
const effectiveRetro: StructuredRetroOutput = {
  theme: "Deploy pipeline reliability",
  insights: [
    {
      observation: "Deploy failures blocked 3 PRs for 2+ hours each this sprint",
      impact: "high",
      evidence: "CI logs show 7 failed deploys, 3 required manual intervention",
    },
  ],
  actions: [
    {
      description: "Add deploy smoke test that runs health check on staging",
      owner: "Sarah",
      dueDate: "2023-03-20",
      successCriteria: "Zero manual rollbacks needed in next sprint",
      status: "not-started",
    },
  ],
  previousActionsReview: [
    {
      action: "Add Slack alerts for failed CI runs",
      status: "completed",
      outcome: "Reduced response time from 45min to 5min average",
    },
  ],
};

interface RetroFormat {
  name: string;
  bestFor: string;
  duration: number; // minutes
  phases: {
    name: string;
    duration: number;
    instructions: string;
  }[];
}
 
const formats: RetroFormat[] = [
  {
    name: "Timeline Retro",
    bestFor: "Complex sprints with many events worth discussing",
    duration: 60,
    phases: [
      {
        name: "Build the timeline",
        duration: 10,
        instructions:
          "Everyone adds events to a shared timeline. " +
          "Include deploys, incidents, meetings, breakthroughs.",
      },
      {
        name: "Mark energy levels",
        duration: 5,
        instructions:
          "Each person draws their energy curve over the sprint. " +
          "Where were you energized? Drained?",
      },
      {
        name: "Identify patterns",
        duration: 15,
        instructions:
          "Group discussion: which events cluster together? " +
          "What caused the energy dips?",
      },
      {
        name: "Generate actions",
        duration: 15,
        instructions:
          "For the top 2 patterns, brainstorm specific fixes. " +
          "Dot vote to prioritize.",
      },
      {
        name: "Assign and commit",
        duration: 10,
        instructions:
          "Top-voted actions get owners, deadlines, and success criteria.",
      },
    ],
  },
  {
    name: "Four Ls",
    bestFor: "Teams new to retros or needing a broader perspective",
    duration: 45,
    phases: [
      {
        name: "Liked",
        duration: 5,
        instructions: "What did you enjoy or appreciate this sprint?",
      },
      {
        name: "Learned",
        duration: 5,
        instructions: "What new knowledge or skills did you gain?",
      },
      {
        name: "Lacked",
        duration: 5,
        instructions: "What was missing? Information, tools, support?",
      },
      {
        name: "Longed for",
        duration: 5,
        instructions: "What do you wish you had? What would make work better?",
      },
      {
        name: "Discuss and prioritize",
        duration: 15,
        instructions: "Group similar items, dot vote top issues, generate actions.",
      },
      {
        name: "Commit",
        duration: 10,
        instructions: "Assign owners and deadlines for top-voted actions.",
      },
    ],
  },
];

class RetroTracker {
  private actions: ActionItem[] = [];
  private history: StructuredRetroOutput[] = [];
 
  addRetro(retro: StructuredRetroOutput): void {
    this.history.push(retro);
    this.actions.push(...retro.actions);
  }
 
  getOpenActions(): ActionItem[] {
    return this.actions.filter(
      a => a.status === "not-started" || a.status === "in-progress"
    );
  }
 
  getCompletionRate(sprintsBack: number = 5): number {
    const recent = this.history.slice(-sprintsBack);
    const allActions = recent.flatMap(r => r.actions);
 
    if (allActions.length === 0) return 0;
 
    const completed = allActions.filter(
      a => a.status === "completed"
    ).length;
 
    return completed / allActions.length;
  }
 
  getRecurringThemes(): Map<string, number> {
    const themes = new Map<string, number>();
 
    for (const retro of this.history) {
      for (const insight of retro.insights) {
        const normalized = insight.observation
          .toLowerCase()
          .replace(/[^a-z\s]/g, "");
 
        // Simple keyword extraction
        const keywords = normalized
          .split(" ")
          .filter(w => w.length > 4);
 
        for (const keyword of keywords) {
          themes.set(keyword, (themes.get(keyword) ?? 0) + 1);
        }
      }
    }
 
    return new Map(
      [...themes.entries()]
        .filter(([, count]) => count >= 3)
        .sort((a, b) => b[1] - a[1])
    );
  }
 
  generateHealthReport(): {
    actionCompletionRate: number;
    openActionCount: number;
    overdueCount: number;
    recurringThemes: string[];
  } {
    const now = new Date();
    const open = this.getOpenActions();
    const overdue = open.filter(
      a => new Date(a.dueDate) < now
    );
    const themes = this.getRecurringThemes();
 
    return {
      actionCompletionRate: this.getCompletionRate(),
      openActionCount: open.length,
      overdueCount: overdue.length,
      recurringThemes: [...themes.keys()].slice(0, 5),
    };
  }
}

interface FacilitationTechnique {
  problem: string;
  technique: string;
  implementation: string;
}
 
const techniques: FacilitationTechnique[] = [
  {
    problem: "One person dominates discussion",
    technique: "Round-robin with time limit",
    implementation:
      "Each person speaks for exactly 2 minutes in rotation. " +
      "Use a visible timer. No interruptions allowed.",
  },
  {
    problem: "People hold back honest feedback",
    technique: "Anonymous digital input",
    implementation:
      "Use a tool like Miro or FunRetro for the divergent phase. " +
      "Everyone writes anonymously before group discussion.",
  },
  {
    problem: "Same issues every sprint, no progress",
    technique: "Five Whys on a recurring theme",
    implementation:
      "Pick the most recurring issue. Ask 'why' five times to find " +
      "the root cause. Often the surface complaint masks a deeper " +
      "systemic issue the team can actually fix.",
  },
  {
    problem: "Action items never get done",
    technique: "Action item budget",
    implementation:
      "Maximum 2 action items per retro. Must be completable within " +
      "one sprint. If previous actions aren't done, discuss why before " +
      "adding new ones.",
  },
  {
    problem: "Retros feel performative, not genuine",
    technique: "Rotate facilitator",
    implementation:
      "Different person facilitates each sprint. Provides fresh " +
      "perspective and distributes ownership of the process.",
  },
];

interface RetroImpactMetric {
  metric: string;
  beforeRetroAction: number;
  afterRetroAction: number;
  linkedAction: string;
  sprintsToImprove: number;
}
 
function assessRetroImpact(
  metrics: RetroImpactMetric[]
): {
  totalImprovements: number;
  avgTimeToImprove: number;
  biggestWin: RetroImpactMetric | null;
} {
  const improvements = metrics.filter(
    m => m.afterRetroAction > m.beforeRetroAction
  );
 
  const avgTime =
    improvements.length > 0
      ? improvements.reduce((s, m) => s + m.sprintsToImprove, 0) /
        improvements.length
      : 0;
 
  const biggestWin = improvements.reduce<RetroImpactMetric | null>(
    (best, current) => {
      const currentDelta =
        current.afterRetroAction - current.beforeRetroAction;
      const bestDelta = best
        ? best.afterRetroAction - best.beforeRetroAction
        : 0;
      return currentDelta > bestDelta ? current : best;
    },
    null
  );
 
  return {
    totalImprovements: improvements.length,
    avgTimeToImprove: Math.round(avgTime * 10) / 10,
    biggestWin,
  };
}
 
// Example usage
const impact = assessRetroImpact([
  {
    metric: "Deploy success rate",
    beforeRetroAction: 0.72,
    afterRetroAction: 0.95,
    linkedAction: "Added smoke tests to deploy pipeline",
    sprintsToImprove: 2,
  },
  {
    metric: "PR review turnaround (hours)",
    beforeRetroAction: 48,
    afterRetroAction: 12,
    linkedAction: "Added daily review slot from 10-11am",
    sprintsToImprove: 1,
  },
]);