
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.
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.
| Discipline | Catches | Misses (caught by next discipline) |
|---|---|---|
| Sprint contracts | Scope drift, missing acceptance criteria, ambiguous “done” | Failure modes not enumerated in the template — caught by postmortems |
| Postmortems | Structural causes of failures, gaps in contract templates | Action items that don’t ship — caught by gates / mechanical layer |
| Pre-flight gates | Missing checks at runtime, bypassed disciplines | Gate 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.
Contracts without postmortems
Postmortems without gates
Gates without context
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.
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.
Three operator turns, three agent turns. Result: one immediate gate ship + one systemic fix to the postmortem template + one contract template strengthening.
- 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?
- 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.
- 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.
- 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.
- operator
Add the systemic fix first. Then the immediate gate.
- 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.
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.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.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.
- 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.
- 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.
- 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.
- 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.
- 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.













