Lesson Learned

Lesson Learned is an AI skill that facilitates structured post-project and post-incident reflection to capture actionable insights from team experiences. It covers incident retrospective formats, knowledge documentation templates, pattern recognition across projects, recommendation prioritization, and building organizational learning systems that prevent repeated mistakes.

What Is This?

Overview

Lesson Learned provides frameworks for extracting valuable insights after projects complete or incidents occur. It handles conducting blameless retrospectives that focus on systemic causes, documenting findings in searchable knowledge bases, identifying recurring patterns across retrospectives, prioritizing recommendations by impact and effort, tracking whether past lessons are being applied, and creating templates that standardize how teams capture learnings.

Who Should Use This

This skill serves incident commanders writing post-mortems after production outages, project managers conducting end of project reviews, engineering managers building learning cultures, and team leads facilitating sprint retrospectives.

Why Use It?

Problems It Solves

Teams repeat the same mistakes because insights from past experiences are never documented or are buried in forgotten documents. Post-mortems that assign blame discourage honest reporting. Without structured formats, retrospectives meander without producing actionable recommendations.

Core Highlights

Blameless retrospective templates encourage honest disclosure by focusing on systems rather than individuals. Standardized documentation makes past lessons searchable and discoverable. Pattern analysis across retrospectives reveals systemic issues that single reviews miss. Action item tracking ensures recommendations translate into process changes.

How to Use It?

Basic Usage

## Post-Incident Review Template

### Incident Summary
- **Date**: 2024-11-15
- **Duration**: 2 hours 34 minutes
- **Severity**: P1 (customer facing outage)
- **Services affected**: Payment processing, order checkout

### Timeline
| Time  | Event                                      |
|-------|-------------------------------------------|
| 14:02 | Monitoring alert: payment error rate > 5%  |
| 14:08 | On-call engineer acknowledges alert         |
| 14:15 | Root cause identified: expired TLS cert     |
| 14:22 | Certificate renewal initiated               |
| 14:45 | New certificate deployed to staging         |
| 15:10 | Production deployment complete              |
| 16:36 | Error rates return to baseline              |

### Contributing Factors (not root causes)
1. Certificate expiry monitoring only checked 7 days ahead
2. Renewal runbook was last updated 18 months ago
3. Staging deployment required manual approval

### Action Items
| Action                        | Owner  | Priority | Due    |
|-------------------------------|--------|----------|--------|
| Extend cert monitoring to 30d | DevOps | High     | Nov 22 |
| Automate cert renewal         | DevOps | High     | Dec 06 |
| Update deployment runbook     | SRE    | Medium   | Nov 29 |

Real-World Examples

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class ActionItem:
    description: str
    owner: str
    priority: str
    due_date: str
    status: str = "open"

@dataclass
class LessonRecord:
    title: str
    date: datetime
    category: str
    context: str
    findings: list = field(default_factory=list)
    actions: list = field(default_factory=list)
    tags: list = field(default_factory=list)

class LessonRepository:
    def __init__(self):
        self.records = []

    def add_record(self, record):
        self.records.append(record)

    def find_patterns(self, min_occurrences=2):
        tag_counts = {}
        for record in self.records:
            for tag in record.tags:
                if tag not in tag_counts:
                    tag_counts[tag] = []
                tag_counts[tag].append(record.title)
        return {
            tag: titles for tag, titles in tag_counts.items()
            if len(titles) >= min_occurrences
        }

    def overdue_actions(self):
        today = datetime.now()
        overdue = []
        for record in self.records:
            for action in record.actions:
                if (action.status == "open" and
                        datetime.strptime(action.due_date,
                        "%Y-%m-%d") < today):
                    overdue.append(action)
        return overdue

Advanced Tips

Schedule a follow up review thirty days after a retrospective to verify action items have been completed. Tag lessons with consistent categories so patterns emerge across dozens of records. Invite participants from adjacent teams, as outside perspectives often identify blind spots.

When to Use It?

Use Cases

Use Lesson Learned when conducting post-mortems after production incidents, when closing out projects to capture what worked, when onboarding new team members who need context on past decisions, or when preparing improvement initiatives based on recurring issues.

Related Topics

Blameless post-mortem culture, incident management frameworks, knowledge management systems, and continuous improvement methodologies all support structured lesson capture.

Important Notes

Requirements

A dedicated time slot for the retrospective with all relevant participants. A facilitator who keeps discussion focused and blameless. A documentation system where lessons are stored and searchable.

Usage Recommendations

Do: focus on systemic contributing factors rather than individual mistakes when analyzing incidents. Assign every action item a specific owner and due date. Review past lessons before starting new projects to apply previously captured insights.

Don't: skip retrospectives when things go well, as successful projects also contain valuable insights. Allow retrospectives to become complaint sessions without producing action items. Archive lessons in locations that team members cannot easily access.

Limitations

Retrospective quality depends on facilitator skill and participant willingness to share honestly. Lessons documented in text form may lose nuance and context present during the discussion. Organizations with blame cultures will struggle to adopt blameless formats without broader cultural changes.