Analyze escaped defects and test suite health through blameless postmortems. Covers bug pattern analysis, test suite health reviews, 5 Whys root cause analysis, process improvement cycles, and postmortem/retro meeting templates with action item tracking. Use when: "QA retro," "escaped bugs," "postmo

<objective Analyze escaped defects, test suite health, and quality process gaps through structured, blameless postmortems. Every postmortem produces 1 3 concrete, tracked action items not vague commitments to "be more careful." The goal is systemic improvement, not individual blame. </objective Quick Route You have... Go to Template One escaped bug to dissect Bug Pattern Analysis Escaped Bug Analysis ( references/templates.md ) 10+ escaped bugs, looking for themes Aggregating Patterns Over Time — A proactive quarterly check (no incident) Test Suite Health Review — A P0/P1 production incident Postmortem Template for Quality Incidents references/templates.md A recurring sprint/monthly review Retro Meeting Template references/templates.md Discovery Questions Check .agents/qa project context.md in the project root first — it carries quality goals, risk areas, and test suite details that anchor any postmortem. Use it and skip anything already answered there. Then clarify: 1. Do you have a regular retro cadence? Per sprint, monthly, or only after incidents? Regular cadence catches slow burn problems. Incident only cadence misses patterns until they explode. 2. What triggered this postmortem? A production incident? A pattern of escaped bugs? A feeling that the test suite is not catching enough? Test suite degradation? The trigger determines the focus. 3. What data is available? Bug tracker with severity and discovery phase? CI history with pass rates? Flaky test reports? Coverage trends? Without data, postmortems devolve into opinion sessions. 4. What happened with previous postmortem action items? Were they completed? Tracked? Forgotten? If past action items are abandoned, the team has learned that postmortems do not matter. Fix the follow through before running another postmortem. 5. Who should participate? Engineers who worked on the affected area. QA who tested (or did not test) it. Product owner if the impact was user facing. Engineering manager if systemic changes are needed. Keep the group to 4 8 people. 6. What are the current test suite health concerns? Rising flakiness? Slow execution? Coverage gaps in critical areas? Stale quarantine? Health reviews are proactive postmortems they prevent incidents instead of reacting to them. Core Principles 1. Blameless Means Systemic Blameless does not mean "no one is accountable." It means the analysis focuses on systems, processes, and tools rather than individual performance. "Why did the system allow this defect to escape?" is a blameless question. "Why did the developer not write a test?" is a blame question that stops the analysis too early. The developer did not write a test because: the test framework was hard to use, the PR checklist did not require it, there was no pairing to transfer knowledge, or time pressure made it feel optional. Those are systemic issues with systemic fixes. 2. Focus on Patterns, Not Incidents A single escaped bug is an anecdote. Three escaped bugs in the same feature area over two months is a pattern. Postmortems should aggregate incidents to find recurring themes: same root cause, same team, same test gap, same phase of the pipeline. Patterns are actionable. Individual incidents are just fire fighting. 3. Every Postmortem = 1 3 Concrete Action Items An action item is concrete when it has: a specific deliverable ("add integration tests for the coupon API"), an owner ("assigned to Alex"), a deadline ("by end of sprint 14"), and a verification method ("PR merged, tests passing in CI"). "Improve testing" is not an action item. "Write 5 integration tests for the payment service edge cases by March 30" is. 4. Track to Completion Action items that are not tracked are not completed. Use the team's existing work tracker (Jira, Linear, GitHub Issues). Tag them ( postmortem action or equivalent). Review completion status at the start of the next postmortem. If items are consistently abandoned, either the items are too large (break them down) or they are not prioritized (make them sprint commitments). 5. Measure Improvement With Two Metrics, Not One After implementing action items, measure whether the problem recurred. If the postmortem identified a gap in payment testing and the action was to add integration tests, track: did another payment bug escape? Without measurement, postmortems are rituals, not tools. Track two metrics together: Defect escape rate (did similar bugs reappear?) Action item closure rate (what fraction of action items shipped within their committed window?) A high closure rate with rising escape rate means the team is doing the work but doing the wrong work. A low closure rate means the postmortems are theater. Modern incident response platforms (incident.io, Rootly, FireHydrant) track action item follow through natively — owner, due date, completion status — so derive both numbers from what's already there before building a dashboard. 6. AI Drafts the Timeline; a Human Owns the Judgment If your team uses AI SRE tooling (Rootly AI SRE, incident.io's AI SRE / auto drafted post mortems), let it draft the incident timeline and propose candidate root causes from logs and traces. Then a named blameless RCA owner — distinct from the incident commander who managed the response — runs the 5 Whys, picks the real root cause, and writes the action items. AI is good at correlation across noisy data; it is bad at deciding what mattered. Treat AI output as a starting deck, not the conclusion. For cheap timeline drafting, Sonnet 4.6 is sufficient; reserve heavier models for ambiguous causation. Bug Pattern Analysis Categorizing Escaped Defects When a bug reaches production, classify it along three dimensions to identify prevention opportunities. The single bug worksheet (Escaped Bug Analysis) lives in references/templates.md . Dimension 1: Root Cause Category Category Description Example Logic error Business logic incorrect or incomplete Discount not applied for edge case currency Integration failure Two components do not communicate correctly API returns different format than frontend expects Data issue Unexpected data shape, null values, encoding User with emoji in name breaks CSV export Race condition Timing dependent behavior Two concurrent checkouts oversell last item Configuration Environment specific settings wrong Feature flag enabled in staging, disabled in prod Regression Previously working behavior broken Refactor removed null check, old bug returns Missing requirement Behavior not specified, gap in product spec No error handling for expired OAuth tokens Performance Functional but too slow under load Search timeout with 100K+ records Dimension 2: Which Test Level Should Have Caught It Level What it catches If it escaped this level Unit Logic errors, edge cases, boundary conditions Tests exist but missing edge case? Or no tests at all? Integration API contracts, data flow, service interactions Integration tests exist? Do they cover error responses? E2E User journey failures, UI state management Is this critical path covered? Was the specific scenario tested? Manual/Exploratory Visual issues, usability problems, unusual workflows Was exploratory testing performed? Was the area in scope? Monitoring Performance degradation, error rate spikes Are alerts configured? Are thresholds correct? Dimension 3: Prevention Opportunity Opportunity Action Example Add test Write a test at the appropriate level Add unit test for currency rounding edge case Improve existing test Existing test was too narrow Extend checkout E2E to include coupon + international currency Add quality gate CI check would have caught it Add schema validation for API responses in CI Improve requirements Spec was ambiguous or incomplete Add acceptance criteria for error states to story template Add monitoring Detect sooner even if not prevented Add alert for error rate 1% on payment endpoint Training/Process Knowledge gap or process gap Run a session on defensive coding for nullable fields Aggregating Patterns Over Time After analyzing 10+ escaped bugs, look for patterns: This aggregation reveals where investment has the highest return: fixing one systemic issue (integration tests for checkout) would have prevented 29% of all escaped bugs. Patterns that recur across multiple quarters belong in the test strategy doc, not just the next sprint's action items — promote them so the strategy reflects where defects actually escape. Test Suite Health Review A proactive postmortem for the test suite itself. Conduct quarterly or when symptoms appear. Flaky Test Trends Execution Time Trend Track current full suite duration, 3 month trend, and the 5 slowest tests. If duration is increasing, check for: tests that can move to nightly, sequential stages that can parallelize, slow test data setup (use API instead of UI), large test files that need splitting for better shard distribution. Coverage Gap Review Track overall coverage (lines/branches), critical paths with insufficient coverage (payments, auth, data export should be 90%+), recently changed code without test updates (cross reference git log since="30 days ago" with the coverage report), and features shipped without E2E coverage. Disabled/Skipped Test Inventory Audit all skipped/disabled tests by age and reason. Tests skipped < 1 week are likely in progress. Tests skipped 1 4 weeks need a ticket and timeline. Tests skipped 1 3 months are overdue fix or delete. Tests skipped 3 months should be deleted they will never be fixed. For each: fix and unskip, delete (obsolete), or move to quarantine with a ticket link. Process Improvement Cycles The Improvement Sprint Dedicate a fixed portion of each sprint (10 15% of capacity) to quality improvement, drawn from postmortem action items and health review findings. Structure: 5 Whys Root Cause Analysis The 5 Whys technique peels back surface symptoms to reveal systemic causes. The key discipline: keep asking "why" until you reach a process, system, or structural cause not an individual's action. Example: Payment bug escaped to production 5 Whys guidelines: Stop when you reach something the team can change (process, tool, structure). Asking "why is the budget limited?" goes too far. The chain may branch one symptom may have multiple contributing causes. Follow the most impactful branch. Verify each "why" with evidence, not assumption. "The developer did not write tests" is that true? Check the PR. Maybe tests existed but were insufficient. If you reach "human error" as a root cause, you have not gone far enough. Humans make errors. The system should make errors difficult or detectable. Proposing Solutions with Effort Estimates For each root cause, propose 1 3 solutions at different effort levels. Example for a recurring flaky test problem: Postmortem & Retro Templates Two heavy, copy paste formats live in references/templates.md : Postmortem Template for Quality Incidents — for P0/P1 production bugs, data loss, security issues, or outages from a code change. Summary, severity/impact, UTC timeline table, root cause, 5 Whys, what tests existed / were missing, detection, immediate/short term/long term action tables, lessons learned. Retro Meeting Template — for recurring sprint/monthly quality retros: a 7 section, 30 60 minute agenda (previous action item review → data review → went well → needs improvement → root cause discussion → new action items → close) plus facilitator notes. Both open by reviewing the previous retro's action items — that closed loop is the acco

quality-postmortem