Postmortem logo

Postmortem

Community
boshu2
postmortem

Explain why a change, incident or session went as it did, separating proven causes from coincidence. Use when: a postmortem or retro is selected by name.

Overview

Publisherboshu2
Repositoryagentops
Skill namepostmortem
Stars
450
Forks
42
Bundled files
3
LicenseApache-2.0
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by boshu2 on GitHub. Read the source before you install it.

Installation

Install the Postmortem AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/boshu2/agentops/tree/main/plugin/skills/postmortem
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/boshu2/agentops.git /tmp/agentops
mkdir -p .claude/skills
cp -r /tmp/agentops/plugin/skills/postmortem .claude/skills/postmortem
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Postmortem in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Postmortem on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Postmortem is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Postmortem

Answer an explicit retrospective causal question about a completed or stopped goal, session or change using its actual intent, outcome and judgment evidence. For an explicitly requested interim analysis, pin the cutoff and pending checks; its conclusions describe that interval and do not establish a final outcome. Neighbours: how a plan not yet run could fail is Premortem; whether a finished change meets acceptance is Validate.

First check: correlation or cause?

Treat every causal statement as a hypothesis, including the one the caller arrives with. Promoting a claim from correlation to cause requires all three:

  • a stated mechanism: the specific path by which the condition produced the outcome, in terms a reader could check against the subject;
  • discriminating evidence: an observation that the mechanism predicts and at least one plausible alternative does not;
  • a counterfactual test: what should have differed if the claim were false, with cited evidence showing it did differ.

Post-hoc fix attribution, "we changed X and the failure stopped, therefore X was the cause", satisfies none of these alone. The symptom may be intermittent, or the recovery and the change may share an unobserved cause. Keep such claims as correlations, name the alternatives still standing, and suggest the discriminating experiment. A recommendation built on an unproven cause is framed as that experiment, not as a supported change. Every supported causal claim needs all three elements with citations; anything less stays a correlation or an unknown.

Prompt

text
Postmortem last Thursday's release: the deploy needed four attempts and two
rollbacks before it stuck. Using the deploy log, the CI runs and the incident
channel notes, which failures were avoidable and what caused each one?
Answer inline.

Critical Constraints

  • Postmortem is retrospective causal analysis, not the general learning umbrella or a code-acceptance gate: acceptance proof and causal inference are different judgments, so a request for code and a postmortem does not make the postmortem an input to code judgment. Wait for a known outcome unless interim analysis was requested, and keep the overall request incomplete until the requested analysis exists.
  • Existing verdicts and native judgments remain unchanged. It does not re-run acceptance validation or fabricate missing proof to enable a retrospective. An existing verdict.v2 is optional evidence; its absence does not exclude a stopped or unvalidated subject.
  • Because the caller owns subsequent action, do not rewrite proof, operate tracker state, change the remaining plan, reopen work or promote a rule.
  • Empty or inconclusive analysis is valid; recommend no change when warranted. Manufacture neither certainty nor a lesson.

Workflow

  1. Pin the question, accepted intent, subject identity, actual outcome and available judgment with exact ids (commits, checks, messages, an existing verdict); keep missing evidence explicit.
  2. Rebuild only the timeline the claims depend on, keeping delivered behavior, failed or stopped work and process output distinct. For a correction or stop, locate the first observable departure from the accepted behavior and the instruction, tool result or missing input immediately before it. Compare a successful case under similar conditions when available; otherwise name that missing comparison. A pause required by the caller is expected behavior. Hidden author reasoning is not fact; missing judgment is not a PASS or a FAIL.
  3. Put each causal claim through the first check above. Distinguish necessary validation and compatibility work from avoidable rework; repeated review alone proves no waste. If the inputs include an earlier postmortem of the same subject, account for its recommendations before issuing new ones: applied, partly applied, not applied, or unknown, with evidence from the supplied work since then. Preserve whether a change was authorized, held or never approved; missing evidence of application is not failed adoption. Report recurrence of the targeted failure only when observed. For repeated unapplied advice, name known obstacles or an unresolved question instead of simply repeating it. Nonapplication alone proves neither cause, blame nor that the advice helps.
  4. For time or token claims, state source, interval, units, included and excluded actors, and uncertainty. Separate elapsed time, overlapping work and accounting scopes; never equate totals with waste, savings or money without supporting evidence.
  5. Optionally seek independent support or challenge for contested causal claims within caller authority. Return the output below and stop; suggestions do not authorize implementation.

Output Specification

  • Default to concise inline Markdown, no mandatory report or worksheet:

    text
    Question: <the causal question>
    Inputs: <intent, outcome and evidence, with exact ids>; missing: <gaps>
    Timeline: <only the events the claims depend on>
    Claims:
    - <claim>: supported | correlation | rejected | unknown
      mechanism / discriminating evidence / counterfactual: <each, cited, or "none">
      alternatives still standing: <rivals the evidence cannot rule out>
    Unknowns: <what would settle them>
    Changes (at most three, or "no change"): <change> - <its limit, or the experiment that tests it>
  • Aim each change at what the next run will meet, usually the instruction, tool result or missing input found in step 2, not at re-fixing code that is already repaired. The kind of avoidable miss picks the lever:

    • Mechanical slip (wrong path, skipped command, forbidden call): a lint rule, test or hook. Read the repository's check commands, hooks and CI first; an existing check that did not run or could not fail is the change, not a duplicate. When no seam in the code can hold such a check, name Architecture as the follow-up, with that defect as its named pain.
    • Judgment miss: one proposed standard or instruction line; writing it is separately authorized Memory work.
    • Fact found slowly: one pointer where the search began. Fact out of reach: a way to expose it next time, such as a captured log; changing access needs caller authority.
  • Only when requested, save YYYY-MM-DD-postmortem-<topic>.md in caller-selected protected external non-Git storage. Missing routing does not authorize a repository fallback; preserve existing requested evidence under owner policy.

  • The caller owns bookkeeping, planning and delivery. Optional Memory owns any separately authorized curation, support and destination-disclosure review; retrospective evidence cannot promote itself.

Quality Checklist

  • The causal question and actual inputs are pinned; gaps are explicit.
  • Supported and rejected claims cite discriminating evidence.
  • Alternatives, counterfactuals, and unknowns remain visible.
  • At most three changes, each aimed at what the next run meets, bounded or framed as an experiment.
  • The report stops short of proof, planning, tracker, and delivery authority.

Behavior examples are in postmortem.feature.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Postmortem AI skill do?

Explain why a change, incident or session went as it did, separating proven causes from coincidence. Use when: a postmortem or retro is selected by name.

Why use Postmortem on TypingMind?

Because you install it once and use it with any model. Postmortem is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Postmortem in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/boshu2/agentops/tree/main/plugin/skills/postmortem. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Postmortem?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Postmortem?

As many as you like. As long as a model supports skills, you can use Postmortem with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Postmortem AI skill free?

Yes. It is published on GitHub by boshu2 under the Apache-2.0 license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇