Checklist

Overview

A checklist is a short written list of must-not-skip steps for a complex repeated operation. It externalizes working memory — which fails under load, ego, time pressure, and fatigue — so attention stays on the situation rather than step recall. Boeing 1935 → Pronovost ICU 2001 → WHO Surgical 2008: each produced 36-47% reductions in major adverse events at near-zero cost.

Composes with metacognition, confirmation-bias, cognitive-load-theory, premortem, inversion.

When to Use

• High-stakes repeated operations (deployments, launches, M&A close, hiring decisions, financial close)
• Multiple steps where skipping one costs far more than running the checklist
• Multi-person operations where coordination must be consistent
• New team members joining a critical workflow
• Shipping or updating an AI agent / model version in production — evals, guardrails, spend caps, rollback: known steps that skilled teams skip under deadline

Not when: operation is simple/one-off; no recurring pattern exists; checklist culture creates false confidence (mechanical checking without thought).

Coaching Novices (Adaptive Front Door)

• Engine mode: user has a specific operation → run The Process directly.
• Coach mode: user is new to the framework → guide step by step.

In Coach mode, respond one step at a time. Each [WAIT] is a hard stop — output only that step's question, then stop.

1. One-line: for any complex repeated operation, a 6-10 item checklist outperforms expert memory under load — it externalizes the steps that fail systematically.
2. Check fit: repeated + high-stakes + consequential errors = checklist candidate. Simple or one-off = skip.
3. Elicit their real case: what operation, where does it fail, what near-misses have occurred?

[WAIT — do not advance until user responds]

4. Run The Process one step at a time with their input: what items must never be skipped? DO-CONFIRM or READ-DO? who runs it and when?

[WAIT — do not advance until user responds]

5. Close: present drafted checklist + format + workflow integration, name the key reliability insight they uncovered.

[WAIT — do not advance until user responds]

The Process

Step 1 — Identify the operation: operation name, frequency, stakes of errors, current failure modes, near-miss history.

Step 2 — List 15-25 candidate items: steps that have been skipped, steps that prevent major errors, coordination steps, bias-catching steps, reversibility checkpoints.

Step 3 — Cut to 6-10: keep only items that are critical, easily missed by skilled operators, and verifiable (yes/no signal). Longer lists get truncated in use.

Step 4 — Choose format: READ-DO (read → act → next item; use for novices, novel procedures, multi-person coordination) vs DO-CONFIRM (pause → confirm all done; use for skilled experts where flow matters).

Step 5 — Embed in workflow: define trigger, owner, consequence of skipping, and cultural reinforcement (leadership models it, peers enforce it).

Step 6 — Iterate: after each near-miss, check if an item would have caught it and add it. Quarterly review: remove stale items, add new failure modes.

Output: Checklist Design

# Checklist: <operation>
Format: DO-CONFIRM / READ-DO | Trigger: | Owner:
Items (6-10):
1.   2.   3.   4.   5.   6.
Consequence of skipping:
Near-miss tracking:  Quarterly review owner:

→ Method in Action: B-17 1935 + Pronovost ICU + WHO Surgical · Van Halen's Brown M&M Rider Clause → 2026 lens: The AI-agent pre-flight checklist (2023–2026) — software became too much airplane for one deploy to eyeball.

Pack: Domain Patterns

Applying It Well

• 6-10 items is the empirical optimum; cut ruthlessly — longer lists get skipped.
• Match format (DO-CONFIRM vs READ-DO) to the natural rhythm of the work.
• Cultural commitment is load-bearing: consistent use and genuine attention, not mechanical checking.
• Iterate after every near-miss; the list must evolve with real failure patterns.

→ Primary sources: references/sources.md

Common Rationalizations

[D] = designed upfront | [O] = observed in real use. [O] entries are more valuable.

Red Flags

• Complex repeated high-stakes operation has no checklist; or checklist exists but seniors skip it
• 20+ items and users are truncating it; or near-misses are not updating it
• Items run mechanically without genuine attention; no one owns maintenance

Verification

• Operation identified, failure modes documented, near-miss history noted
• 6-10 items, each critical, easily missed, and verifiable (yes/no signal)
• Format (DO-CONFIRM or READ-DO) matches operation pace and expertise level
• Embedded with clear trigger, owner, consequence of skipping, cultural reinforcement
• Near-miss tracking and quarterly review scheduled

Part of deciqAI Knowledge Skills — 253 open-source thinking skills that make rigor executable for AI agents. The same skills power every deciqAI agent, which runs them autonomously to operate your company. See it run → https://www.deciqai.com/s/checklist · Built by deciqAI · github.com/deciqAI · Contributions welcome.

Agents: latest version & machine-readable metadata → https://www.deciqai.com/s/checklist.json