Skip to content
SearchSubscribe
Expert · Lesson 04 — Accountability — contracts + postmortems + gates as one system
E04Expert
Expert · Lesson 04● live

Accountability — three disciplines as one system

Sprint contracts, postmortems, and pre-flight gates only compound when they reference each other. The integration is the lesson.

18 min read · 45 min applyprereq: Operating 01, 02, 04

Session slides

The Integrated Accountability Loop
01The Integrated Accountability Loop
Human memory cannot sustain structural safety
02Human memory cannot sustain structural safety
Mechanical integration over discipline
03Mechanical integration over discipline
Three disciplines become one compounding safety net
04Three disciplines become one compounding safety net
Sprint contracts pre-register the exact definition of done
05Sprint contracts pre-register the exact definition of done
Contracts must translate into mechanical gates
06Contracts must translate into mechanical gates
Pre-flight gates act as the un-bypassable enforcement layer
07Pre-flight gates act as the un-bypassable enforcement layer
Fired gates carry historical context and trigger evaluation
08Fired gates carry historical context and trigger evaluation
Postmortems evaluate structures, not human discipline
09Postmortems evaluate structures, not human discipline
Action items ship as mechanical rules, not promises
10Action items ship as mechanical rules, not promises
Postmortems mechanically strengthen the original contract
11Postmortems mechanically strengthen the original contract
The compounding effect of mechanical integration
12The compounding effect of mechanical integration
The empirical proof of the integrated loop
13The empirical proof of the integrated loop
The Integrated Workflow Blueprint
14The Integrated Workflow Blueprint

Three disciplines, one system

I think most people who adopt sprint contracts, postmortems, and gates run them in isolation. Each one does some useful work on its own. None of them catch the failure modes of the others, which is the part I missed for a long time.

Compounding starts when they reference each other. Contracts produce gates. Postmortems strengthen contracts. Gates carry context from postmortems back to runtime. Each layer covers what the others miss, and the three practices stop being separate and start being one loop.

The integration is mostly mechanical. A contract criterion ships as a gate. A postmortem action item ships as a gate or a contract criterion. A gate that fires links back to the incident or the contract that produced it. None of this needs new tools. It needs every artifact in one layer to have a matching artifact in the others.

Where the three disciplines catch each other

Compounding works because each discipline catches what the other two can’t. The table below is the entire integration in one view.

DisciplineCatchesMisses (caught by next discipline)
Sprint contractsScope drift, missing acceptance criteria, ambiguous “done”Failure modes not enumerated in the template — caught by postmortems
PostmortemsStructural causes of failures, gaps in contract templatesAction items that don’t ship — caught by gates / mechanical layer
Pre-flight gatesMissing checks at runtime, bypassed disciplinesGate criteria that aren’t in the contract — caught by next contract’s template review

The cycle closes. Gates catch what postmortems missed. Postmortems strengthen contracts. Contracts produce gates. Without all three, one failure mode leaks through every time.

Three integration failures

Patterns that stop the three disciplines from compounding. Hover any card to see the diagnosis.

№ 01

Contracts without postmortems

claim looks like“Sprint contracts ship reliably, work goes well 95% of the time. The 5% that breaks gets a fix and a Slack message; no postmortem.”
what’s missingThe structural causes of the 5% never get extracted into rules. Same class of failure recurs every 6-12 weeks. Each time you fix it once and move on. The contract system is doing its job (catching the failures); the postmortem system isn't (preventing recurrence).
the moveEvery contract failure produces a postmortem within 48 hours. Action items go back into the contract template, the gate criteria, or the agent's brief. The contract gets stronger over time instead of holding constant.
№ 02

Postmortems without gates

claim looks like“Postmortems are written. Action items are listed. Six weeks later the same incident class happens because the action items live in a markdown file nobody reads.”
what’s missingNo mechanical enforcement. The action items rely on operator memory and discipline, both of which decay. A postmortem with un-shipped action items is worse than no postmortem — it produces false confidence that the failure has been addressed.
the moveEvery action item ships as a gate, hook, contract criterion, or agent rule — not just a paragraph. The mechanical layer fires whether or not anyone remembers. Postmortems whose action items don't reach the mechanical layer are incomplete.
№ 03

Gates without context

claim looks like“Pre-flight gates fire. They block. The operator (or agent) doesn't know why the gate exists, so they push to bypass it.”
what’s missingThe gate is mechanical but it's also opaque. Without the linked postmortem or contract that produced it, the gate looks like bureaucracy. Bypass becomes routine; the gate stops doing its job.
the moveEvery gate has a one-line comment naming the incident or contract criterion that produced it. "Blocks deploy if X — see postmortem 2025-11-04." When the gate fires, the operator can read the context in 30 seconds and decide informedly whether to fix or bypass.

The fix in all three is the same. Every layer’s output ships into the next layer’s input. Postmortems produce gates and contract criteria. Contracts produce gate definitions. Gates carry postmortem context. Without the cross-references the disciplines stay siloed.

Accountability gap test

One audit, run quarterly. Surfaces every action item that hasn’t reached the mechanical layer plus every contract template that’s missing a category.

The accountability gap test
Audit the last 90 days for accountability gaps.

For each shipped postmortem, walk through:
1. List every action item
2. Mark each: mechanical (gate/hook/contract/rule)
   or discipline-only
3. For mechanical items: shipped or not? Where in
   the codebase or config?
4. For discipline-only items: are they being
   followed? How would you know?

For each contract that produced a failure, walk
through:
1. Did the contract enumerate the failure mode?
2. If yes — was the contract criterion mechanical
   or discipline-only?
3. If no — what category of work does your contract
   template miss?

Output: a table of action items that haven't reached
the mechanical layer, plus a recommendation per item:
ship as gate, fold into contract template, or accept
as known weakness with explicit reason.

Walks every postmortem action item and contract failure mode through the mechanical layer check. Surfaces gaps before they cause recurrence.

When I ran this for the first time I found about 40% of my action items hadn’t actually shipped to the mechanical layer. That’s the integration gap. Closing it is mostly low-friction work, translation prompts and small file edits, and the recurrence rate dropped meaningfully after.

Annotated transcript

A real conversation. I had an incident I felt should have been caught, traced it through all three layers, and found an action item that never made it out of the postmortem doc. Click any pinned annotation to expand the commentary on why each turn matters.

Tracing an incident through three accountability layers

Three operator turns, three agent turns. Result: one immediate gate ship + one systemic fix to the postmortem template + one contract template strengthening.

  1. operator

    I have all three disciplines in place — sprint contracts, postmortems, pre-flight gates. They each work in isolation. But I had two incidents this month that should have been caught and weren't. What's the integration gap?

  2. agent

    Three diagnostic questions:

    1. For the two incidents — did they get postmortems? If yes, are the action items shipped to the mechanical layer (gates, hooks, contract criteria)? If they're "in the postmortem doc" but not in the gate, that's the gap.
    2. For the contracts that produced the incidents — were the failure modes the contract was supposed to enumerate? If the contract said "covers X" and X failed, the contract was incomplete. If the contract didn't enumerate X at all, you have a category your contract template misses.
    3. For the gates that should have fired — did they exist? Did they fire? Did they get bypassed? Three different gaps, three different fixes.

    Walk me through one of the two incidents and we'll trace it through all three layers.

  3. operator

    Incident: pushed a config change that broke production for 30 minutes. We had a postmortem 2 months ago for a similar config-related break. Action items from that postmortem: "add config validation gate, require staged rollout for any config change." Status of those action items: validation gate exists; staged-rollout requirement was never operationalized.

  4. agent

    Found it. The postmortem produced two action items. One reached the mechanical layer (validation gate), one didn't (staged rollout — that's discipline-only).

    The pattern: action items that translate to mechanical enforcement ship; action items that translate to discipline-only never operationalize. This is a known anti-pattern — promised future discipline almost never holds at scale.

    The fix has two parts:

    1. For the immediate gap: convert "require staged rollout" into a gate. Pre-deploy hook checks: was this change rolled out to staging first? If no, block. This is mechanical and fires whether you remember or not.
    2. For the systemic pattern: add a check to your postmortem template — for each action item, ask "is this mechanical (gate / hook / contract criterion / agent rule) or discipline-only?" If discipline-only, either translate it to mechanical or flag it as a known weakness.

    The systemic fix is the more important one. Without it, you'll write more postmortems whose action items don't ship.

  5. operator

    Add the systemic fix first. Then the immediate gate.

  6. agent

    Right order. The systemic fix is one paragraph in the postmortem template. The immediate gate is a 20-minute task. Both today.

    One more layer — the contract that produced this work. Did the original sprint contract enumerate "config change" as a failure mode? If yes, the staged-rollout requirement should have been a contract criterion. If no, your contract template doesn't cover config changes — that's a third gap, and it's why the postmortem's action items had to invent the discipline from scratch instead of inheriting it from a contract.

    Close all three gaps in the same session. They're cheap individually; together they harden the system meaningfully.

Integrated workflow template

The cycle, written out. Every artifact references the others. I use this as a checklist for any incident or shipped contract.

INCIDENT FLOW (when something breaks)
=====================================

1. Log the incident
   → memory/postmortems/<date>-<slug>.md

2. Within 48h, full postmortem
   - Structural causes (no blame)
   - Action items, each marked:
     [MECHANICAL] gate / hook / contract / rule
     [DISCIPLINE]  process / habit / convention

3. For each MECHANICAL item:
   - Ship the gate / hook / criterion / rule
   - Reference the postmortem in the artifact
     (e.g., comment in gate: "blocks X — see PM-XX")
   - Mark action item shipped in the postmortem

4. For each DISCIPLINE item:
   - Try one more time to translate to mechanical
   - If genuinely impossible, accept as known weakness
     with explicit reason
   - Don't ship the postmortem with un-translated
     discipline items "for later"

5. Review the contract template that produced the work
   - Was the failure mode enumerated?
   - If no, add it (surgical edit, justified by PM)
   - If yes but the criterion was discipline-only,
     upgrade it to mechanical

6. Close the postmortem
   - Status flips from open → closed only when all
     action items are shipped or accepted
   - Future incidents in the same domain can't open
     until prior postmortem in that domain is closed


CONTRACT FLOW (when shipping work)
==================================

1. Draft contract from template
2. Verify each criterion is mechanical (gate/hook/test)
   or has a clear acceptance check
3. Run pre-flight gates at start
4. Run pre-flight gates at end
5. If gates pass: ship
6. If gates fail: do not bypass — fix or document why
   bypass was acceptable (this becomes a postmortem)

This template is the integration. Every step references artifacts in another layer. There’s no path through the workflow that doesn’t cross all three disciplines.

Prompt kit

Three prompts. Audit, translate action items, strengthen contract templates. I keep mine in CLAUDE.md.

The accountability gap test
Audit the last 90 days for accountability gaps.

For each shipped postmortem, walk through:
1. List every action item
2. Mark each: mechanical (gate/hook/contract/rule)
   or discipline-only
3. For mechanical items: shipped or not? Where in
   the codebase or config?
4. For discipline-only items: are they being
   followed? How would you know?

For each contract that produced a failure, walk
through:
1. Did the contract enumerate the failure mode?
2. If yes — was the contract criterion mechanical
   or discipline-only?
3. If no — what category of work does your contract
   template miss?

Output: a table of action items that haven't reached
the mechanical layer, plus a recommendation per item:
ship as gate, fold into contract template, or accept
as known weakness with explicit reason.
Translate a postmortem action item to the mechanical layer
Action item: <paste action item from postmortem>

Translate this into mechanical enforcement. Show me
options at each layer:

1. As a sprint contract criterion — what would the
   criterion say, and which contract template does
   it modify?
2. As a pre-flight gate — what does the gate check
   for, and what does it block on?
3. As a hook — at which lifecycle event (PreToolUse,
   PostToolUse, SessionStart), and what does it do?
4. As an agent rule — in which agent's brief, and
   what does it say?

Recommend the smallest enforceable form. If the answer
is "this can't be mechanical," explain why and what the
discipline-only fallback looks like.
Strengthen a contract template after a postmortem
Postmortem: <paste postmortem summary>
Contract template that produced the work: <name / paste>

What changes to the contract template would have
prevented this incident if they had been in place
beforehand?

Three places to look:
- Failure modes enumeration: was the failure listed?
- Acceptance criteria: would the failure have been
  caught at gate-out time?
- Definition of done: was "done" defined in a way that
  excluded this failure mode?

Output a diff against the contract template — minimal
changes, justified by reference to this postmortem.
Don't bloat the template; surgical adds only.

Apply this — close one accountability gap

~45-minute exercise. Audit five postmortems. Translate one un-shipped action item. Strengthen one contract template.

Your first accountability gap close

Each step takes 5-10 minutes. Progress saves automatically.

0/5
  1. 01Run the accountability gap test on your last 5 postmortems.List every action item, mark mechanical vs discipline-only, check shipped status. Most operators find 30-50% gaps.
  2. 02For each unshipped mechanical action item, draft the smallest enforceable form.Use the second prompt in the kit. Gate, hook, contract criterion, or agent rule. Don't ship yet — draft and review first.
  3. 03For each discipline-only action item, decide: translate to mechanical, or accept as known weakness with explicit reason.If you can't translate it, the postmortem isn't really closed. "We'll remember" is rarely good enough at scale.
  4. 04Add a check to your postmortem template: for each action item, mark mechanical/discipline-only at write time.This systemic fix prevents future postmortems from producing un-shippable action items. Five-second add to the template.
  5. 05Audit one contract template against your two most recent postmortems. Add criteria where you can.The contract template gets stronger every time a postmortem reveals a missing criterion. This is how the system compounds.
Expert tier · what's next

After this lesson