skills/rpd-klein-calderwood/SKILL.md
Recognition-Primed Decision model explaining how experts rapidly match situations to learned patterns
npx skillsauth add curiositech/windags-skills rpd-klein-calderwoodInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
license: Apache-2.0
name: rpd-klein-calderwood
version: 1.0
source: "Investigations of Naturalistic Decision Making and the Recognition-Primed Decision Model (ARI Research Note 90-59)"
authors: Gary A. Klein, Roberta Calderwood
description: >
Empirically-grounded model of how experts actually decide under pressure.
Activates when designing decision agents, diagnosing decision failures,
building expertise systems, or structuring multi-agent coordination.
activation_triggers:
- expert decision making
- naturalistic decision making
- recognition-primed decision
- RPD model
- fireground command
- decision under time pressure
- situation assessment
- mental simulation
- option evaluation
- novice vs expert errors
- analytical decision methods
- agent orchestration design
- distributed decision making
Load this skill when you encounter:
Experts under pressure do not compare options. They recognize the situation as a familiar type, which immediately activates a standard response. The cognitive question is not "which option is best?" but "is this option workable?" — a far cheaper operation. Recognition is the primary cognitive act; selection is almost automatic downstream of it.
Implication: A system that forces option generation and comparison on a recognition-capable agent is not helping it decide — it is breaking its decision machinery.
Experts and novices perceive the same cues. The difference is the inferential depth drawn from those cues. Experts form:
Novices have shallow situation models. Their data intake is fine; their world model is thin. This is where the gap lives — not in reasoning power, but in situational knowledge.
When experts do evaluate an option consciously, they run a forward mental simulation — imagining how the option unfolds in the specific situation. They look for fatal flaws, not rankings. If no fatal flaw appears, the option is accepted. If a flaw appears, they modify the option or reject it and test the next candidate. This is progressive deepening: focused, sequential, leveraging domain knowledge about where failure lives. It is not exhaustive; it is targeted.
Prescriptive decision tools (decision matrices, multi-attribute utility, generate-and-compare protocols) impose exactly the cognitive overhead that expertise exists to bypass. Under time pressure, requiring analytical methods:
These tools have appropriate uses — with novices, with low time pressure, for post-decision audit. Not with experts acting.
Most expert experience has been abstracted into prototypes: individual cases merge into situation types. Analogical reasoning (this is like the incident in 2019...) re-emerges only for non-routine situations. When it does, analogue selection becomes the critical variable. The wrong comparison case drives a confident, well-executed, wrong response. Analogy is not a fallback — it is a distinct mode with a distinct failure signature.
| Situation | Guidance | |-----------|----------| | Agent operates under time pressure | Build recognition-first: situation classification precedes option generation | | Agent has rich domain training data | Store situation-type → response-schema mappings as primary knowledge asset | | Agent must evaluate options | Implement serial simulation (one option at a time, fatal-flaw scan) not scoring matrices | | Agent is performing well analytically but slowly | Don't add more analysis — add situation prototypes to compress the recognition step | | Agent is fast but confidently wrong | Audit the situation classification layer, not the reasoning layer |
1. Was the situation classified correctly?
→ If NO: situation misclassification failure (expert solved wrong problem well)
→ Intervention: expectancy monitoring, confirmation-disconfirmation probes
2. If classified correctly — was the response schema appropriate?
→ If NO: inappropriate analogue activation (wrong comparison case)
→ Intervention: analogue validation protocol, check what triggered the match
3. If schema appropriate — was the simulation adequate?
→ If NO: progressive deepening failure (fatal flaw passed undetected)
→ Intervention: failure-mode-focused simulation, adversarial probing of the option
Is the decision maker experienced in this domain?
NO → Analytical methods appropriate (novice has no prototypes to activate)
YES → Is there adequate time?
YES and LOW STAKES → Analytical methods can add value as audit
NO or HIGH STAKES → Recognition-first; analytical overlay degrades performance
| File | When to Load |
|------|--------------|
| references/recognition-primed-decision-core-model.md | Need the full RPD model architecture: the three variants (simple match, diagnosed match, creative), how recognition activates response, the empirical evidence base |
| references/situation-assessment-the-overlooked-half-of-decision-making.md | Need depth on how experts build situation models, what expectancies are, how cue clusters work, or why situation assessment is where expert/novice gaps live |
| references/serial-evaluation-vs-concurrent-comparison.md | Need to understand why experts don't compare options, or designing an evaluation process for agents, or critiquing generate-and-compare frameworks |
| references/progressive-deepening-mental-simulation-as-evaluation-tool.md | Need specifics on how forward simulation works, how fatal-flaw detection operates, or how to implement simulation-based option testing in an agent |
| references/analogical-reasoning-and-its-failure-modes.md | Diagnosing confident expert failure, designing analogue validation, or understanding when case-based reasoning helps vs. introduces error |
| references/why-analytical-decision-methods-fail-experts.md | Justifying or critiquing the use of analytical decision tools, designing decision aids for expert systems, or explaining why imposing structure can degrade performance |
| references/expertise-as-situational-knowledge-not-analytical-power.md | Designing training systems, building expertise models, or understanding what experience actually encodes vs. what novices lack |
| references/distributed-decision-making-and-coordination-without-central-control.md | Designing multi-agent systems, studying how coordination emerges from shared schemas, or building orchestration without centralized control |
| references/critical-decision-method-eliciting-knowledge-from-experts.md | Extracting tacit knowledge from domain experts, building knowledge bases from interview data, or understanding why self-report methods miss expert cognition |
| references/novice-vs-expert-error-patterns.md | Diagnosing failures, designing error-prevention interventions, or understanding why the same fix doesn't work for novices and experts |
Forcing experts to compare options explicitly. Comparison is not a universal cognitive upgrade. For experts under pressure, it is a regression to a slower, less calibrated process. Don't require it unless time and stakes allow.
Treating fast decision making as shallow decision making. Speed in experts reflects deep pattern recognition, not cognitive shortcuts. Fast + confident + wrong is a situation-classification problem, not a deliberation-depth problem.
Assuming more analysis = better decisions. The research directly contradicts this for experienced actors in time-pressured domains. Analysis without recognition produces slow, brittle decisions. Recognition without analysis produces fast, flexible ones — with specific, manageable failure modes.
Building agent coordination on action protocols rather than shared situation models. Agents who agree on what they're doing but disagree on what the situation is will coordinate locally and fail systemically. Schema alignment is load-bearing.
Treating analogical reasoning as safe because it's expert reasoning. Analogy is one of the primary mechanisms of confident expert error. An expert reasoning from the wrong case is more dangerous than a novice who knows they don't know — the expert's conviction is high and their execution is competent in the wrong direction.
Eliciting expert knowledge through self-report alone. Experts cannot reliably report their own decision processes. The cognitive operations that produce expert performance are largely tacit and inaccessible to introspection. Self-report produces rationalized reconstructions, not process descriptions.
Applying RPD as a justification for not designing decision support. RPD shows that certain types of support fail experts. It does not argue for removing all support. Expectancy monitoring, schema validation tools, and analogue checking are all RPD-consistent interventions.
How to tell if someone has truly internalized this work vs. skimmed a summary:
They talk about situation assessment, not option selection. Someone who absorbed the book leads with "what situation type is this?" before "what should we do?" Someone who read a summary leads with the RPD label and skips to the recognition-response shortcut.
They distinguish the three RPD variants. Casual familiarity produces "experts recognize patterns and act." Deep familiarity knows that simple recognition, diagnosed recognition, and creative evaluation are structurally distinct — with different failure modes and different support needs.
They understand that analogy is a failure mode, not just a technique. Summary readers treat analogical reasoning as an expert tool. Book readers know that Klein's team expected analogy to be central and found it was marginal — and that when it appears, it is where the most damaging errors enter.
They can describe what progressive deepening actually does. Not "experts imagine the option playing out" (summary) but "experts run a forward simulation looking for the first fatal flaw, then either modify or reject and proceed to the next option serially, drawing on domain knowledge to direct attention toward the most probable failure points" (internalized).
They resist the urge to prescribe analytical methods as a universal improvement. Someone who has internalized Klein asks "is this actor experienced?" and "what are the time and stakes constraints?" before recommending any decision structure. Someone who hasn't will add decision matrices reflexively.
They know that novice and expert errors require different fixes. Summary readers treat error reduction as uniform. Book readers know that novices err by failing to act on available cues (thin situation model) while experts err by acting on confidently misclassified situations — and that the intervention for one makes the other worse.
tools
Building resilient distributed systems with circuit breakers, retries with full-jitter exponential backoff, retry budgets (per-request 3-attempt + per-client 10% ratio per Google SRE), deadline propagation, and the cascading-failure math (4 layers × 3 retries = 64x amplification). Grounded in Resilience4j, Microsoft Cloud Patterns, AWS Architecture Blog (Marc Brooker), and Google SRE Book.
testing
Designing HTTP cache headers that work correctly across browsers, CDNs, and shared proxies — `Cache-Control` directives per RFC 9111, `stale-while-revalidate` and `stale-if-error` per RFC 5861, the Vary header for varying responses, and surrogate keys for tag-based purging. Grounded in IETF RFCs and Cloudflare/Fastly docs.
development
Use when designing or fixing a Content Security Policy on a real site, choosing between nonce-based and hash-based CSP, adding strict-dynamic, debugging "Refused to execute inline script" errors, deploying CSP in report-only mode first, configuring report-to / report-uri, or auditing an existing policy for unsafe-inline / unsafe-eval / wildcards. Triggers: "CSP blocks legitimate inline script", strict-dynamic, nonce-{RANDOM}, sha256-{HASH}, object-src none, base-uri none, frame-ancestors, Trusted Types, X-Content-Security-Policy obsolete, report-only vs enforced. NOT for general HTTP security headers (HSTS, COOP/COEP), Trusted Types deep dive, CORS configuration, or building a WAF.
tools
Choosing and operating an HTTP API versioning strategy that doesn't break clients — Stripe's date-based pinned versions, the Deprecation/Sunset header pair (RFC 9745 + RFC 8594), URI vs header vs media-type approaches, and the version-transformer pattern. Grounded in Stripe's published architecture and IETF RFCs.