# mental-models

Adopt this skill: https://proskills.md/skills/other/cyperx84-claude-skills-mental-models-skills-mental-models

Page: https://proskills.md/skills/other/cyperx84-claude-skills-mental-models-skills-mental-models
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/mental-models/SKILL.md
size: 6066
sha: ec37d060a025891f7871124654bdc02cb1a7e4b1
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/SKILL.md

````text
---
name: mental-models
description: Apply mental models — your own, or 21 sourced ones — to any problem. Use when user requests decision analysis, says "help me think", "apply mental model", mentions model names (inversion, bottlenecks, second-order thinking), or needs structured thinking frameworks.
---

# Mental Models

Apply cognitive frameworks from several disciplines — systems, economics, psychology,
mathematics, strategy — to analyse problems, make decisions, and think more clearly.

Everything this skill needs is a file. No install, no dependencies, no tooling — you read
markdown.

## When to Activate

- User names a specific model ("apply inversion", "use bottlenecks")
- User asks "help me think through X" or "what model fits X"
- User requests decision analysis, trade-off evaluation, or structured reasoning
- User describes a complex/ambiguous problem and wants a framework

## Step 1 — Load the index

Read [`models/index.md`](./models/index.md). It lists every bundled model with a one-line
description. It is short; load it in full.

Then check for the user's own models. The bundled set is a starting point, not a fixed list:

| Path | Holds |
|---|---|
| `.mental-models/` (relative to the working directory) | this project's or team's models, committed with the code |
| `~/.claude/mental-models/` | the user's personal models, available everywhere |

**Always run both globs before selecting. Do not assume they are empty** — one tool call
settles it, and a model the user wrote for exactly this situation is the most valuable thing
you can find. This matters most when the problem is urgent: urgency is precisely when a
team's own hard-won model is worth more than a general one, and precisely when you are
tempted to skip the check.

If either has files, read each one's YAML frontmatter (`title`, `description`, `tags`) to
learn what is there. A directory may have its own `index.md`; read that instead if present.
If both are empty, carry on with the bundled models.

**A user model always wins a name collision with a bundled one.** If someone wrote their own
`inversion.md`, they meant it — use theirs, and don't mention the built-in unless asked.

Treat user models as first-class. A model a team wrote about their own domain usually beats
a general one at that domain.

## Step 2 — YOU select the models

Read the user's problem and pick **2–4 models from different areas**. Selection is a
reasoning task and you are better at it than any keyword matcher: cross-area coverage is the
entire point of a *latticework* — a single-area pick means blind spots go unchecked.

**Discovery heuristics** to bias your reading of the index:

- **Risk / uncertainty / reversibility** → inversion, margin of safety, randomness
- **Stuck / can't see options** → first-principles thinking, second-order thinking, framing
- **Conflict / negotiation / competition** → bias from incentives, asymmetric warfare, trade-offs
- **Complex system / unintended effects** → feedback loops, emergence, bottlenecks, leverage
- **Performance / optimization** → bottlenecks, leverage, activation energy
- **People / team / behaviour** → bias from incentives, social proof, confirmation bias
- **Evaluating evidence or results** → sampling, regression to the mean, randomness
- **Change that won't start, or won't stop** → activation energy, inertia

## Step 3 — Retrieve each pick

Read the file directly. Bundled models are flat files named by slug:

```
models/<slug>.md
```

e.g. `models/inversion.md`. The index gives you the exact filename — use it rather than
guessing. User models are at the path you found them.

## Step 4 — Apply

Each model file has YAML frontmatter and four parts:

- the **description prose** — what the idea is and where it comes from, with `[^footnotes]`
  pointing at entries in the frontmatter's `sources`
- **When to Avoid** — read this *before* concluding, and surface it if it applies. It is what
  separates a mental model from a slogan.
- **Thinking Steps** — walk these against the user's actual facts. Follow them; don't
  paraphrase the framework away.
- **Coaching Questions** — ask these to deepen the analysis where useful.

Show where the chosen models agree, and where they disagree.

## Step 5 — Report

- Name which models you used and why you picked them
- Where models disagreed, say so explicitly rather than silently picking a winner
- End with 3–5 concrete, actionable next steps
- Name any "when to avoid" conditions that apply to this case
- If a source matters to the point you are making, cite it — the `sources` block has the link

## Core Guidelines

1. **2–4 models per analysis, from different areas** — coverage over quantity
2. **Follow the Thinking Steps verbatim** — don't paraphrase the framework away
3. **Always check When to Avoid** — warn the user if the model misfits
4. **Latticework**: show how chosen models connect and where they disagree
5. **Be actionable**: end with concrete next steps, not theory
6. **Name biases honestly**: if the user seems caught in one, surface it

## The format

`models/` is an [Open Knowledge Format](https://github.com/GoogleCloudPlatform/open-knowledge-format)
bundle: a directory of markdown files, each with YAML frontmatter carrying at minimum a
`type`. That means any OKF bundle can be dropped into `.mental-models/` and read the same way,
and this bundle can be consumed by any OKF-aware agent.

Obsidian vaults work too — treat `[[wikilink]]` as a link to `wikilink.md`.

To write your own, copy [`TEMPLATE.md`](./TEMPLATE.md).

## Files in This Skill

- `SKILL.md` — this entry point
- `TEMPLATE.md` — the format; copy it to write your own model
- `models/` — the bundled OKF bundle: `index.md` plus one file per model

Outside this skill, and never overwritten by an update:

- `.mental-models/*.md` — the working directory's own models
- `~/.claude/mental-models/*.md` — the user's personal models

Source: <https://github.com/cyperx84/claude-skills-mental-models>
````

## File: skills/mental-models/models/activation-energy.md
size: 3621
sha: 1df7a02863bb18f078eff50748ae2c10b1c1a249
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/activation-energy.md

```text
---
type: mental-model
title: Activation Energy
description: Change needs an upfront input larger than its running cost, so the barrier to starting is the thing to attack.
tags:
- science
- change
- habits
- adoption
status: stable
sources:
- id: arrhenius
  resource: https://en.wikipedia.org/wiki/Activation_energy
  title: Activation energy — the minimum energy required to initiate a reaction
  author: Svante Arrhenius
- id: catalysis
  resource: https://en.wikipedia.org/wiki/Catalysis
  title: Catalysis — lowering the activation barrier without being consumed
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

A chemical reaction that releases energy still will not start until something supplies an
initial input — the activation energy, the barrier between the reactants and the reaction
[^arrhenius]. Wood in air is thermodynamically desperate to burn, and sits there indefinitely
without a match.

The transfer is direct: many changes that would obviously pay off never start, and the reason
is not that the payoff is doubted. It is that the barrier at the beginning is higher than the
motivation available on any given day. Writing tests pays for itself; setting up the test
harness costs an afternoon nobody has.

The intervention that follows is what makes the model useful. A catalyst lowers the barrier
rather than adding energy, and is not consumed doing it [^catalysis]. Applied to people and
organisations: stop trying to raise motivation, which is expensive and decays, and lower the
barrier instead, which is usually cheap and permanent. Prepared templates, defaults, a
scheduled slot, one person who has already done it once.

## When to Avoid

- **When the reaction is not favourable.** Lowering the barrier to a bad idea just gets you
  the bad idea faster. Check the payoff is real before optimising the start.
- **When the barrier is doing useful work.** Friction on destructive or irreversible actions
  is a safety feature. Not every barrier should come down.
- **When the true problem is sustained effort, not starting.** Some things are easy to begin
  and hard to continue, and this model points you at exactly the wrong end.
- **When repeated failed starts are the signal.** If something never sticks despite low
  barriers, the constraint is elsewhere — usually the payoff is not what you assumed.

## Thinking Steps

1. **Confirm the change is actually worth it.** State the ongoing payoff. If it is not clearly
   positive, stop here.
2. **Measure the gap between starting cost and running cost.** If starting is much harder than
   continuing, this is an activation-energy problem.
3. **Enumerate what stands between here and the first step.** Be concrete and unglamorous:
   accounts to create, permissions to request, a decision nobody has made, a blank file.
4. **Remove or pre-pay barriers.** Templates, defaults, a pre-booked hour, a working example
   to copy. Do the setup once for everyone.
5. **Find a catalyst.** A person or artifact that lowers the barrier repeatedly without being
   consumed — the colleague who has done it before, the scaffold command.
6. **Shrink the first step until it is trivially small.** The goal is not a good first step,
   it is one too small to resist.

## Coaching Questions

- "If this is obviously worth doing, why hasn't it started?"
- "What's the very first physical action, and what's in the way of it?"
- "Are we trying to raise motivation when we could lower the barrier?"
- "Who has done this before, and can they do the setup once for everyone?"
- "What's the smallest version that still counts as started?"
```

## File: skills/mental-models/models/asymmetric-warfare.md
size: 3596
sha: 3e0f67263b4b63ffdbe9695f54eaab3be5cdbce9
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/asymmetric-warfare.md

```text
---
type: mental-model
title: Asymmetric Warfare
description: The weaker side wins by refusing the stronger side's terms and changing what counts as winning.
tags:
- strategy
- competition
- conflict
status: stable
sources:
- id: mack
  resource: https://en.wikipedia.org/wiki/Asymmetric_warfare
  title: Asymmetric warfare — conflict between belligerents of unequal strength
- id: arreguin
  resource: https://doi.org/10.2307/2009880
  title: "Why Big Nations Lose Small Wars: The Politics of Asymmetric Conflict (World Politics, 1975)"
  author: Andrew Mack
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

Asymmetric conflict is between opponents whose resources and strategies differ so much that
conventional comparison stops predicting outcomes [^mack]. Mack's insight was that the
stronger side often loses not militarily but politically: for the weaker party the conflict
is existential, for the stronger it is optional, so the weaker can absorb far more pain
relative to its will to continue [^arreguin]. Victory is not defeating the opponent; it is
outlasting their interest.

Translated to business, the small competitor does not win by being a better version of the
incumbent — that is fighting on the incumbent's terms, where resources decide. It wins by
picking a dimension the incumbent cannot follow without damaging itself: a segment too small
to matter, a price that would cannibalise the main line, a support model that does not scale.

The defining constraint is the one people skip: the asymmetry has to be something the
opponent *cannot* copy, not merely something they have not copied. If they can match it next
quarter, it is a feature, not a strategy.

## When to Avoid

- **When you are the incumbent.** The model reads very differently from the strong side, and
  adopting insurgent tactics as the market leader usually reads as flailing.
- **When the asymmetry is copyable.** A cheaper price is not an asymmetry if they can cut
  prices. The advantage must be structurally unavailable to them.
- **When it invites disproportionate response.** Provoking a much stronger opponent who has
  not yet bothered to respond can end the game early.
- **When ethics are treated as another constraint to route around.** Deception and
  norm-breaking are available and cost credibility that is far harder to rebuild than
  revenue.

## Thinking Steps

1. **State the asymmetry precisely.** What do they have that you don't, and what do you have
   that they can't get — speed, focus, willingness to do unscalable things, nothing to lose.
2. **Identify what winning means for each side.** Different objectives is the core asymmetry.
   You may be able to win without them losing.
3. **Find what they cannot do without hurting themselves.** Their commitments are your
   opening: existing customers, margin structure, brand promises, public commitments.
4. **Refuse their metrics.** Competing on feature count against a company with fifty
   engineers is choosing the terrain where you lose.
5. **Check they cannot copy it.** If they can, it is a temporary feature. Keep looking.
6. **Work out how long you can sustain it.** Asymmetric strategies are endurance strategies.
   Know your runway before starting.

## Coaching Questions

- "What would it look like to refuse to compete on their terms?"
- "What can they not do without damaging their existing business?"
- "What can we do that doesn't scale — and would they even want to?"
- "If they wanted to copy this next quarter, could they?"
- "How long can we sustain this, and how long will they bother?"
```

## File: skills/mental-models/models/bias-from-incentives.md
size: 3742
sha: 09687a304866cae47199bcd3cbc5adfdf4a364e7
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/bias-from-incentives.md

```text
---
type: mental-model
title: Bias from Incentives
description: People reach the conclusions their incentives point toward, sincerely and without noticing.
tags:
- human-nature
- incentives
- organisations
- bias
status: stable
sources:
- id: misjudgment
  resource: https://en.wikipedia.org/wiki/Charlie_Munger
  title: The Psychology of Human Misjudgment — incentive-caused bias
  author: Charlie Munger
- id: upton
  resource: https://en.wikipedia.org/wiki/Upton_Sinclair
  title: "\"It is difficult to get a man to understand something when his salary depends upon his not understanding it\""
  author: Upton Sinclair
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

Munger put incentive-caused bias first among the causes of human misjudgment and said he had
underestimated it his whole life [^misjudgment]. The key word is *bias*, not corruption. The
salesperson who believes the product is right for you, the consultant who genuinely
concludes you need a bigger engagement, the engineer certain the rewrite is necessary — these
people are not lying. Their incentives shaped what they noticed, which evidence felt
compelling, and where they stopped looking. Sinclair's line captures it exactly: it is hard
to get someone to understand something when their salary depends on not understanding it
[^upton].

This is why it is the first model to reach for when behaviour looks irrational. Behaviour
that makes no sense given the stated goals usually makes perfect sense given the actual
rewards. "Why does nobody write tests?" is answered by looking at what gets someone promoted.

The uncomfortable half is that it applies to you, and from the inside, incentive-caused bias
is indistinguishable from being right.

## When to Avoid

- **As an accusation.** Stating that someone's view is bought is both insulting and usually
  wrong about the mechanism — they are biased, not dishonest, and treating it as dishonesty
  guarantees they stop listening.
- **When it explains everything.** If every disagreement is reducible to incentives, you have
  a theory that cannot be wrong and therefore tells you nothing. Some people just disagree.
- **When the incentive is weak or ambiguous.** Not every situation has strong enough
  incentives to bend judgement. Look for real magnitude before invoking it.
- **When you have not applied it to yourself first.** Using it exclusively outward is the
  most common failure, and it makes you less accurate, not more.

## Thinking Steps

1. **List who is affected by the decision.** Everyone with a stake, including yourself.
2. **For each, ask what they gain or lose.** Money, status, workload, risk of blame, an
  interesting project. Non-financial incentives are frequently the stronger ones.
3. **Predict their position from incentives alone.** Before hearing their argument, work out
   what conclusion their situation points toward.
4. **Compare prediction to actual position.** Where they match, weight the argument less and
   look for independent evidence. Where they differ, weight it more — someone arguing against
   their own interest is worth listening to.
5. **Run it on yourself.** What conclusion does your position point toward? Notice whether
   that is the one you hold.
6. **Fix the system, not the person.** If the incentive reliably produces the bad outcome,
   the incentive is the thing to change.

## Coaching Questions

- "Who benefits if we decide this way?"
- "What would I conclude if I were paid the way they're paid?"
- "What conclusion do my own incentives point me toward here?"
- "Is anyone here arguing against their own interest? Why aren't we listening harder?"
- "What behaviour are we actually rewarding, as opposed to the one we ask for?"
```

## File: skills/mental-models/models/bottlenecks.md
size: 3690
sha: 6d8ee09e03e84b91a6208b9cdcdaa1f0f5243458
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/bottlenecks.md

```text
---
type: mental-model
title: Bottlenecks
description: A system's throughput is set by its single tightest constraint; work spent anywhere else is wasted.
tags:
- systems-thinking
- performance
- optimization
- operations
status: stable
sources:
- id: toc
  resource: https://en.wikipedia.org/wiki/Theory_of_constraints
  title: Theory of Constraints — the five focusing steps
  author: Eliyahu M. Goldratt
- id: goal
  resource: https://en.wikipedia.org/wiki/The_Goal_(novel)
  title: The Goal — a process of ongoing improvement
  author: Eliyahu M. Goldratt
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

Every system has exactly one constraint that determines its output at any given time.
Improving anything else changes nothing you can measure. Goldratt formalised this as the
Theory of Constraints and gave it five focusing steps: identify the constraint, exploit it,
subordinate everything else to it, elevate it, then repeat because the constraint will have
moved [^toc]. He argued the case as a novel about a failing factory, which is why the idea
spread past operations research into software, hospitals and sales pipelines [^goal].

The counterintuitive part is *subordinate*. Local efficiency away from the constraint is not
merely useless — it is actively harmful, because it builds inventory in front of the
bottleneck and gives everyone the impression of progress. A team optimising its own throughput
while sitting upstream of the real constraint is producing work that queues.

The step people skip is the last one. Elevate a constraint and it moves somewhere else,
usually somewhere less comfortable. Fix deploy coupling and discover the new limit is
on-call capacity.

## When to Avoid

- **When the system isn't throughput-limited.** If the problem is quality, morale, or
  direction, the constraint frame quietly redefines it as a speed problem and optimises the
  wrong thing.
- **When you can't measure where the constraint is.** The model's whole value is knowing
  which one it is. Applied on a guess, it concentrates all your effort on a single wrong
  place — worse than spreading it.
- **When the constraint is a person.** Technically the model still holds. Socially,
  "you are the bottleneck" is rarely the sentence that fixes it, and the framing damages the
  thing you needed to improve.
- **When the constraint is deliberate.** Code review, safety checks and approvals are
  constraints on purpose. Elevating them removes the control you installed.

## Thinking Steps

1. **Map the flow end to end.** Where does work enter, what does it pass through, where does
   it leave. You cannot find a constraint in a system you haven't drawn.
2. **Find where work piles up.** Queues are the reliable tell. Look for the stage with things
   waiting in front of it and idle capacity behind it.
3. **Exploit before you invest.** Get everything possible out of the existing constraint
   before spending money on more of it. Usually it is idle part of the time for stupid reasons.
4. **Subordinate the rest.** Deliberately slow or re-point non-constraint work so it stops
   feeding the queue. This feels wrong and is correct.
5. **Elevate.** Now add capacity — hire, buy, parallelise.
6. **Find the new one.** It has moved. Naming where you expect it to move next is the
   difference between a fix and a treadmill.

## Coaching Questions

- "If we could instantly double the speed of one step, which one changes the output?"
- "Where is work waiting right now?"
- "What are we optimising that sits upstream of the real constraint?"
- "Is the constraint idle at any point, and why?"
- "When we fix this, where does the constraint move to?"
```

## File: skills/mental-models/models/confirmation-bias.md
size: 3697
sha: eb4320dff651540b5a542fe01e447c04e0ee2cc4
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/confirmation-bias.md

```text
---
type: mental-model
title: Confirmation Bias
description: We search for and weight evidence that supports what we already believe, and the search feels neutral from inside.
tags:
- human-nature
- evidence
- reasoning
- bias
status: stable
sources:
- id: wason
  resource: https://en.wikipedia.org/wiki/Wason_selection_task
  title: The Wason selection task — failure to seek falsifying evidence
  author: Peter Wason
- id: popper
  resource: https://en.wikipedia.org/wiki/Falsifiability
  title: Falsifiability — theories are tested by attempts to refute them
  author: Karl Popper
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

Wason gave people a rule and asked which cards they would turn over to test it. Almost
everyone chose cards that could confirm the rule and almost nobody chose the card that could
falsify it — the only one that carried real information [^wason]. The bias is not that we
ignore contrary evidence once we see it. It is that we never go looking, and the search feels
thorough from the inside.

Popper's response was to make refutation the standard: a theory earns confidence by surviving
serious attempts to kill it, not by accumulating supporting instances [^popper]. That is a
procedure, not an attitude, which is what makes it usable. "Be open-minded" is not
actionable. "Name the observation that would prove you wrong, then go look for it" is.

In practice this is the model behind most protracted debugging sessions and most bad
strategy meetings. The team has a theory and spends its time gathering instances consistent
with it, and consistency is cheap — a wrong theory has plenty of confirming instances.

## When to Avoid

- **When you have to act.** Falsification is unbounded; decisions are not. At some point
  you commit on incomplete evidence, and demanding one more disconfirming test becomes
  procrastination in a lab coat.
- **When the belief is well-established.** Not every accepted finding deserves adversarial
  re-litigation. Applied indiscriminately, this becomes the engine of crankery.
- **As a rhetorical weapon.** "You're just confirming your bias" is unanswerable and
  therefore useless in an argument. It is a tool for auditing your own search, not for
  winning.
- **When falsifying evidence is unobtainable.** If no observation could distinguish the
  hypotheses, the honest move is to say the question is undecidable here, not to run a
  theatrical search.

## Thinking Steps

1. **State the belief precisely enough to be wrong.** Vague claims cannot be falsified, which
   is why they survive so long.
2. **Name the observation that would refute it.** Concretely: what would you have to see?
   If nothing would, stop — this is not a factual claim.
3. **Go look for that specific thing.** Not for evidence generally. The bias operates on
   what you search for, so the search is the intervention.
4. **Weight disconfirming evidence at face value.** Notice the impulse to explain it away and
   apply the same scrutiny you would give confirming evidence, which is usually none.
5. **Ask who would disagree and what they know.** Find the strongest version of the opposing
   case, not the weakest.
6. **Set the threshold in advance.** Decide what would change your mind *before* the evidence
   arrives, or the threshold will move to accommodate it.

## Coaching Questions

- "What would we have to see for this to be wrong?"
- "What have we looked for that would contradict this — not just support it?"
- "Who believes the opposite, and what's their best argument?"
- "Are we collecting evidence or collecting agreement?"
- "What would change our minds, and did we decide that before or after looking?"
```

## File: skills/mental-models/models/creative-destruction.md
size: 3642
sha: 3e0d75d470790e4835fc136a07b98608f1ffe80a
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/creative-destruction.md

```text
---
type: mental-model
title: Creative Destruction
description: Growth arrives by destroying the thing that currently works, and incumbents defend the thing being destroyed.
tags:
- economics
- strategy
- innovation
- competition
status: stable
sources:
- id: schumpeter
  resource: https://en.wikipedia.org/wiki/Creative_destruction
  title: Creative destruction — the process of industrial mutation
  author: Joseph Schumpeter
- id: christensen
  resource: https://en.wikipedia.org/wiki/The_Innovator%27s_Dilemma
  title: The Innovator's Dilemma — why well-managed firms lose to inferior new entrants
  author: Clayton Christensen
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

Schumpeter described capitalism as a process of industrial mutation that "incessantly
revolutionises the economic structure from within, incessantly destroying the old one,
incessantly creating a new one" [^schumpeter]. Progress is not additive. The new thing takes
the old thing's place, and someone was employed by the old thing.

Christensen supplied the mechanism for why the incumbent, who can see it coming, loses
anyway [^christensen]. The new entrant starts worse on every axis the incumbent's best
customers care about. Listening to those customers — the thing good management does —
correctly says ignore it. By the time the entrant is good enough, the incumbent's cost
structure and organisation are built around the model being displaced.

Applied internally, this is why rewrites fail politically rather than technically. The
existing system has staff, budget and a track record; the replacement has a prototype. Every
local incentive protects what exists.

## When to Avoid

- **As a euphemism.** "Creative destruction" is often used to describe harm to other people
  as though it were weather. The destruction is real and lands on someone.
- **When the incumbent is simply better.** Not every new entrant is disruptive. Most are just
  worse, and the model gives a flattering story to a failing product.
- **When novelty becomes the goal.** Destroying a working system because destruction feels
  like progress is how organisations lose capability they cannot rebuild.
- **On short timescales.** These processes run over years. Using the model to justify a
  decision this quarter is usually motivated reasoning.

## Thinking Steps

1. **Identify what currently works and who depends on it.** Revenue, staff, customers,
   internal processes. This is what the change would destroy.
2. **Find the thing that is worse but improving.** Ask what is currently dismissed as a toy,
   and at what rate it is getting better.
3. **Compare rates, not levels.** The question is never whether it is good enough today. It
   is whether its trajectory crosses your requirements before you can respond.
4. **Ask who inside would lose.** Name the budget, team or metric that shrinks if the new
   thing wins. That is where the resistance will come from, and it will be framed as risk.
5. **Check what your best customers are telling you.** If they are unanimous that the new
   thing is irrelevant, that is the exact signal Christensen described, not reassurance.
6. **Decide whether to cannibalise yourself.** Doing it deliberately is expensive. Having it
   done to you is worse.

## Coaching Questions

- "What are we currently protecting, and what does protecting it cost?"
- "What's the toy version of our product, and how fast is it improving?"
- "Who inside this company loses if the new approach wins?"
- "Are our best customers telling us to ignore this?"
- "If a competitor did this to us, how long would we have to respond?"
```

## File: skills/mental-models/models/emergence.md
size: 3663
sha: 8a96d672920f5b0a62d8ef81671bd1f18d20a3cf
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/emergence.md

```text
---
type: mental-model
title: Emergence
description: Aggregates have properties their parts don't, so understanding the components does not give you the whole.
tags:
- systems-thinking
- complexity
- scale
status: stable
sources:
- id: more-is-different
  resource: https://doi.org/10.1126/science.177.4047.393
  title: More Is Different — broken symmetry and the nature of the hierarchy of science
  author: P. W. Anderson
- id: emergence
  resource: https://en.wikipedia.org/wiki/Emergence
  title: Emergence — properties an entity has that its parts do not
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

Emergent properties belong to a collection and not to any of its members [^emergence]. A
water molecule is not wet. A neuron does not think. A single trader has no opinion about
market sentiment. Anderson's argument was that this defeats pure reductionism: knowing the
laws governing the parts does not let you derive the behaviour of the assembly, because new
laws appear at each level of scale [^more-is-different].

The practical consequence is that expertise in components does not transfer to the system.
Excellent engineers produce incoherent architectures. Every individual on a team acting
reasonably produces a culture nobody would have chosen. Each hiring decision is defensible
and the org is unrecognisable in two years.

It also means you cannot fix emergent problems at the component level. Adding a rule for
each bad outcome treats the symptom of a structure that will keep generating new ones.
Emergent behaviour is changed by changing interaction patterns — who talks to whom, what
gets rewarded, what is easy versus hard — not by improving parts in isolation.

## When to Avoid

- **When the problem really is one broken component.** Emergence is the fashionable
  explanation; sometimes one service is misconfigured. Check the simple cause first.
- **As an excuse for unpredictability.** "It's emergent" can mean "we have not looked hard
  enough." Many surprising system behaviours have a boring traceable cause.
- **When it removes agency.** If the conclusion is that nobody is responsible because the
  outcome emerged, the model is being used to launder a decision someone made.
- **On small systems.** Three components interacting are usually just three components. The
  concept earns its keep at scale, where the interactions outnumber the parts.

## Thinking Steps

1. **Name the property that's bothering you.** Be specific: "releases are slow", "the culture
   is defensive". Then ask which single component has that property. Usually none do.
2. **If no part has it, look at the interactions.** The behaviour lives in the connections —
   handoffs, dependencies, incentives, meeting structure.
3. **Map who affects whom.** Not the org chart; the actual paths by which one part's output
   becomes another's input.
4. **Identify the rules generating the pattern.** Simple local rules produce complex global
   behaviour. Find the local rule everyone is rationally following.
5. **Intervene on the rule, not the instance.** Change what is easy, what is rewarded, or who
   is connected to whom.
6. **Expect a new emergent property.** Changing interaction structure produces a different
   whole, not a fixed one. Look for what appears next.

## Coaching Questions

- "Which individual part has this property? If none, why do we keep fixing parts?"
- "What simple rule is everyone following that produces this?"
- "Who talks to whom here, actually?"
- "If every person is behaving reasonably and the outcome is bad, what does that tell us?"
- "What new behaviour appears if we change this structure?"
```

## File: skills/mental-models/models/feedback-loops.md
size: 3584
sha: 2fd0ad4843deab78e9c10d27deb0bfa1e4c62452
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/feedback-loops.md

```text
---
type: mental-model
title: Feedback Loops
description: Output that re-enters as input — reinforcing loops accelerate, balancing loops resist, and delay makes both unstable.
tags:
- systems-thinking
- dynamics
- unintended-consequences
status: stable
sources:
- id: meadows
  resource: https://en.wikipedia.org/wiki/Donella_Meadows
  title: Thinking in Systems — stocks, flows, and feedback
  author: Donella Meadows
- id: cybernetics
  resource: https://en.wikipedia.org/wiki/Cybernetics
  title: Cybernetics — control and communication in the animal and the machine
  author: Norbert Wiener
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

A feedback loop exists when a system's output comes back around as its input. Wiener's
cybernetics established the idea as a general one, applying equally to machines, organisms
and organisations [^cybernetics]. Meadows made it practical: systems are stocks connected by
flows, and the flows are governed by loops that either reinforce or balance [^meadows].

Reinforcing loops compound — more users make the product better which attracts more users.
They also compound downward, which is the same loop running in reverse and is why decline
is rarely gradual. Balancing loops seek a target and resist change; they are why so many
well-designed interventions produce nothing at all. The system was holding a level, you
pushed, and it pushed back.

Delay is what turns both into instability. A balancing loop with a long lag overshoots,
corrects, overshoots again. Most organisational thrash — hiring freezes followed by frantic
hiring, alert fatigue followed by alert deletion followed by missed outages — is a delayed
balancing loop oscillating, not a series of bad decisions.

## When to Avoid

- **On genuinely linear, one-shot situations.** If the output does not return as input,
  drawing loops is invented complexity.
- **When you cannot observe the loop.** A hypothesised feedback structure is unfalsifiable
  and endlessly elaborable. Without a measurement, it explains everything and predicts nothing.
- **When it excuses accountability.** "It's a systems problem" is sometimes true and
  sometimes a way of ensuring nobody has to change what they do on Monday.
- **When the timescale exceeds your horizon.** A loop that closes over five years is real but
  useless for a decision you make this quarter — you will never observe the correction.

## Thinking Steps

1. **Name the stock.** What accumulates? Users, trust, debt, unresolved tickets. Loops act on
   stocks, so find the stock first.
2. **Trace the flows in and out.** What raises it, what drains it, and what governs each rate.
3. **Ask whether output feeds back into input.** If more of the stock causes more inflow, it
   reinforces. If more causes more outflow or less inflow, it balances.
4. **Find the delay.** How long between the change and the response arriving? Long delays
   plus strong correction equals oscillation, every time.
5. **Locate the leverage.** Loop strength usually lives in one parameter or one rule. Changing
   the rule beats pushing harder against the loop.
6. **Check for a loop you're fighting.** If effort produces no change, you are probably
   pushing on a balancing loop that is doing its job.

## Coaching Questions

- "What accumulates here, and what fills and drains it?"
- "Does more of this cause more of it, or less?"
- "How long between a change and us seeing the result?"
- "What is holding this at its current level despite our pushing?"
- "If this loop ran backwards, how fast would it unwind?"
```

## File: skills/mental-models/models/first-principles-thinking.md
size: 4014
sha: a89c6aa91e74718b5272262c9dbf993aef763162
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/first-principles-thinking.md

```text
---
type: mental-model
title: First-Principles Thinking
description: Strip a problem to what you know is true, then rebuild upward without borrowing anyone's conclusions.
tags:
- general-thinking
- problem-solving
- innovation
status: stable
sources:
- id: first-principle
  resource: https://en.wikipedia.org/wiki/First_principle
  title: First principle — the foundational proposition that cannot be deduced from any other
- id: descartes
  resource: https://en.wikipedia.org/wiki/Discourse_on_the_Method
  title: Discourse on the Method
  author: René Descartes
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

A first principle is a proposition that cannot be deduced from anything more basic [^first-principle].
Reasoning from first principles means decomposing a problem until you hit those, then building
back up — rather than reasoning by analogy, which is what we do almost all of the time.
Descartes made the method explicit: doubt everything that can be doubted, keep only what
survives, rebuild from there [^descartes].

Most thinking is analogical, and for good reason — it's fast and usually right. "How do
competitors price this?" gets you to an answer in minutes. But analogy inherits every
assumption baked into the thing you're copying, including the ones that were true for
someone else's constraints and were never true for yours. First principles is what you reach
for when the inherited answer keeps failing and nobody can say why.

The cost is real: it is slow, it is effortful, and it frequently reproduces the conventional
answer. That is not a failure. Arriving at the same conclusion by a route you can defend is
worth something the borrowed version never was.

## When to Avoid

- **When speed matters more than novelty.** Most decisions are not worth rebuilding from
  atoms. Analogy is the correct default; first principles is the exception you reach for.
- **When you lack the domain knowledge to identify the actual primitives.** Decomposition by
  a novice produces confident nonsense — you strip to what *you* think is fundamental, which
  is usually just a less examined assumption.
- **When the conventional answer encodes hard-won experience.** Building codes, aviation
  checklists and medical protocols look arbitrary from first principles. They are compressed
  accident reports. "Nobody can explain why this rule exists" is a reason to investigate, not
  to override.
- **As a status move.** Announcing that you reason from first principles while actually
  reasoning by analogy to a different, more flattering reference class is common and hard to
  spot from the inside.

## Thinking Steps

1. **Write the current answer and its justification.** Whatever you or the team currently
   believe, and specifically *why*. You cannot examine an assumption you haven't stated.
2. **Ask of each element: how do I know this?** Trace each claim to its source. Most will
   trace to "someone told me" or "that's how it's done" — those are the ones to attack.
3. **Strip to what survives.** Keep only what is physically, mathematically, or
   contractually necessary. Everything else is a choice someone made.
4. **Name the constraints you actually have.** Not the ones you inherited. Budget, physics,
   law, and time are constraints; convention and precedent are not.
5. **Rebuild.** Construct a solution from the surviving pieces, ignoring how it is normally
   done.
6. **Compare against the conventional answer.** If they match, you have earned confidence.
   If they differ, you have found either an opportunity or a constraint you missed — and
   working out which is the real work.

## Coaching Questions

- "What do we know is true here, as opposed to what we've assumed?"
- "How do we know that? Who told us, and how did they know?"
- "If this industry didn't exist and we started today, what would we build?"
- "Which of our constraints are physics and which are habit?"
- "What would have to be true for the conventional answer to be wrong?"
```

## File: skills/mental-models/models/framing.md
size: 3492
sha: b6e2135b0d953e1d8b4abd8a142091b9af4360f9
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/framing.md

```text
---
type: mental-model
title: Framing
description: The same facts presented differently produce different decisions — so the frame is a choice someone made.
tags:
- human-nature
- communication
- decision-making
- bias
status: stable
sources:
- id: framing-effect
  resource: https://en.wikipedia.org/wiki/Framing_effect_(psychology)
  title: The framing effect — the Asian disease problem
  author: Amos Tversky and Daniel Kahneman
- id: prospect
  resource: https://en.wikipedia.org/wiki/Prospect_theory
  title: Prospect theory — losses loom larger than equivalent gains
  author: Daniel Kahneman and Amos Tversky
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

Tversky and Kahneman gave people a choice between programmes to combat a disease expected to
kill 600. Described in lives saved, most chose the certain option; described in lives lost,
most chose the gamble — despite the options being arithmetically identical [^framing-effect].
The frame, not the facts, drove the decision.

The mechanism is that we evaluate outcomes as changes from a reference point rather than as
final states, and losses hurt roughly twice as much as equivalent gains feel good
[^prospect]. Move the reference point and the same outcome becomes a win or a loss.

The practical use is defensive and offensive at once. Defensively: any decision you're
presented with arrived inside a frame someone chose, and re-describing it in the opposite
direction is a cheap check on whether your preference is about the substance. Offensively:
if you are communicating, you are framing whether you think about it or not, and the default
frame is rarely the best one.

## When to Avoid

- **When reframing becomes manipulation.** The line is whether the alternative frame is
  equally true. Choosing the honest frame that helps is persuasion; choosing the misleading
  one is deception, and the technique is identical.
- **When the reference point is genuinely correct.** Not all frames are arbitrary. If money
  really was spent, "sunk cost" is not a framing trick, it is a fact about the world.
- **When it substitutes for changing the substance.** Reframing a bad deal does not improve
  the deal. Organisations reach for the frame precisely when the substance is unfixable.
- **On people who have seen the reframe.** Once someone notices you are working the frame,
  it reads as spin and costs you the credibility that made it work.

## Thinking Steps

1. **Identify the current frame.** What is being treated as the baseline, and what counts as
   a gain or a loss relative to it?
2. **Restate it in the opposite direction.** Gains as losses, losses as gains. Same numbers.
3. **Check whether your preference survived.** If it flipped, your preference is about the
   frame and you have not actually decided anything yet.
4. **Ask who chose this frame and what it does for them.** Frames are rarely accidental.
5. **Find the reference point.** Change what counts as "normal" and the whole evaluation
   moves.
6. **If communicating, choose deliberately.** Pick the frame that is both true and clearest —
   and be able to state the one you rejected.

## Coaching Questions

- "How would this sound described as a loss instead of a gain?"
- "What are we treating as the baseline, and who picked it?"
- "If we'd never made the earlier investment, what would we choose now?"
- "Does our preference survive restating the same numbers the other way?"
- "Whose frame are we currently inside?"
```

## File: skills/mental-models/models/index.md
size: 3279
sha: 73352cad7401e835dfc4b27ba3d8dc4a9f69ca88
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/index.md

```text
---
okf_version: "0.2"
---

# Mental Models

Reasoning frames for working through a problem. Each concept states the idea and its
sources, the conditions under which it misleads you, the steps to apply it, and questions
to ask. Pick two to four from different areas — a single-area pick leaves blind spots
unchecked.

* [Activation Energy](activation-energy.md) - Change needs an upfront input larger than its running cost, so the barrier to starting is the thing to attack.
* [Asymmetric Warfare](asymmetric-warfare.md) - The weaker side wins by refusing the stronger side's terms and changing what counts as winning.
* [Bias from Incentives](bias-from-incentives.md) - People reach the conclusions their incentives point toward, sincerely and without noticing.
* [Bottlenecks](bottlenecks.md) - A system's throughput is set by its single tightest constraint; work spent anywhere else is wasted.
* [Confirmation Bias](confirmation-bias.md) - We search for and weight evidence that supports what we already believe, and the search feels neutral from inside.
* [Creative Destruction](creative-destruction.md) - Growth arrives by destroying the thing that currently works, and incumbents defend the thing being destroyed.
* [Emergence](emergence.md) - Aggregates have properties their parts don't, so understanding the components does not give you the whole.
* [Feedback Loops](feedback-loops.md) - Output that re-enters as input — reinforcing loops accelerate, balancing loops resist, and delay makes both unstable.
* [First-Principles Thinking](first-principles-thinking.md) - Strip a problem to what you know is true, then rebuild upward without borrowing anyone's conclusions.
* [Framing](framing.md) - The same facts presented differently produce different decisions — so the frame is a choice someone made.
* [Inertia](inertia.md) - Things keep doing what they were doing; change requires a force, and mass determines how much.
* [Inversion](inversion.md) - Approach a goal backward by asking what would guarantee failure, then avoid those things.
* [Leverage](leverage.md) - Find the point where a small input produces a disproportionate output, and apply force there.
* [Margin of Safety](margin-of-safety.md) - Build for materially worse than your best estimate, because your estimate is an estimate.
* [Randomness](randomness.md) - Much of what looks like signal is noise, and we build causal stories over both without noticing.
* [Regression to the Mean](regression-to-the-mean.md) - Extreme results are followed by less extreme ones for statistical reasons, independent of anything you did.
* [Sampling](sampling.md) - Small and self-selected samples lie confidently, and the people you can hear from are rarely the ones you need.
* [Scarcity](scarcity.md) - Not having enough of something captures attention and degrades judgement about everything else.
* [Second-Order Thinking](second-order-thinking.md) - Ask "and then what?" at least twice — the first-order winner is often the second-order loser.
* [Social Proof](social-proof.md) - We infer correct behaviour from what others do, most strongly exactly when we are least certain.
* [Trade-offs](trade-offs.md) - The real cost of a choice is the best thing you gave up to make it, not the money you spent.
```

## File: skills/mental-models/models/inertia.md
size: 3594
sha: 6e14119079adb037dedc2f06d8c3af0b6dab15d5
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/inertia.md

```text
---
type: mental-model
title: Inertia
description: Things keep doing what they were doing; change requires a force, and mass determines how much.
tags:
- science
- change
- organisations
status: stable
sources:
- id: newton
  resource: https://en.wikipedia.org/wiki/Newton%27s_laws_of_motion
  title: Newton's first law — a body remains at rest or in uniform motion unless acted upon
  author: Isaac Newton
- id: inertia
  resource: https://en.wikipedia.org/wiki/Inertia
  title: Inertia — resistance to change in state of motion, proportional to mass
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

A body at rest stays at rest, and a body in motion continues in a straight line, unless acted
on by a force [^newton]. Resistance to that change is proportional to mass [^inertia]. Both
halves matter for the transferred version, and the second one is the half people forget.

At rest: organisations, habits and codebases persist by default. Nothing continues because it
was chosen; it continues because stopping requires a decision and nobody made one. Quarterly
reports, standing meetings, that service nobody owns.

In motion: a project with momentum keeps going in its original direction after the reasons
have expired. This is the more expensive failure, because motion looks like progress. Teams
ship the roadmap written for a market that changed.

And mass sets the cost. A ten-person company turns; a thousand-person company does not turn
at the same price. Underestimating organisational mass is the standard error behind change
programmes that were correct and still failed.

## When to Avoid

- **When stability is the point.** Inertia is what makes systems predictable. Reliability,
  trust and institutional memory are all inertia working correctly.
- **When it becomes fatalism.** "Too much inertia" is a real constraint and also a
  comfortable excuse for not attempting the change.
- **In genuinely fast-moving systems.** Some environments have very little mass and change
  direction on a signal. Assuming inertia there makes you slow.
- **When the persistent thing is persisting for a live reason.** Before concluding a practice
  survives on momentum, check whether it is solving something you have not noticed.

## Thinking Steps

1. **Ask whether this is continuing by decision or by default.** When was it last actively
   chosen? "Nobody remembers" is your answer.
2. **Determine rest or motion.** Are you starting something stationary or redirecting
   something moving? They need different forces and different arguments.
3. **Estimate the mass.** How many people, systems, contracts and habits are attached? Mass
   is what makes the estimate wrong, and it is almost always larger than the plan assumes.
4. **Work out the force required, honestly.** Then ask whether you have it. An underpowered
   change attempt is worse than none — it burns credibility and teaches people that change
   fails here.
5. **Prefer redirecting to stopping.** Changing the direction of something already moving is
   usually cheaper than halting it and starting again.
6. **Remove the force sustaining the old motion.** Often something is actively maintaining
   the current state. Stopping that beats pushing against it.

## Coaching Questions

- "When did we last actually decide to do this?"
- "Is this at rest or already moving, and in what direction?"
- "How much mass is attached to this — people, systems, promises?"
- "Do we have enough force to actually move it, or will we stall halfway?"
- "What's actively keeping this going that we could just stop?"
```

## File: skills/mental-models/models/inversion.md
size: 3689
sha: 10ce9cab41087883f5885a17c31ed53b6c2aafd2
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/inversion.md

```text
---
type: mental-model
title: Inversion
description: Approach a goal backward by asking what would guarantee failure, then avoid those things.
tags:
- general-thinking
- risk
- planning
- decision-making
status: stable
sources:
- id: jacobi
  resource: https://en.wikipedia.org/wiki/Carl_Gustav_Jacob_Jacobi
  title: Carl Gustav Jacob Jacobi — "man muss immer umkehren" (invert, always invert)
  author: Carl Gustav Jacob Jacobi
- id: almanack
  resource: https://www.stripe.press/poor-charlies-almanack
  title: Poor Charlie's Almanack
  author: Charlie Munger
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

Inversion approaches a problem backward. Instead of asking "how do I succeed?", you ask
"what would guarantee failure?" — then systematically avoid those things. The phrasing comes
from the mathematician Carl Jacobi, who told students that hard problems yield when you
invert them [^jacobi]. Munger built it into a standing habit and credited Jacobi directly:
his 1986 commencement speech was structured entirely as prescriptions for a *miserable* life,
on the grounds that the route to a good one is easier to see in the negative [^almanack].

It works because failure modes are more concrete than success factors. "Be a great manager"
resists action; "never let a report find out they're being replaced from someone else" is a
rule you can follow on Tuesday. Avoiding stupidity is a smaller, better-defined target than
achieving brilliance, and it is more reliably reached.

## When to Avoid

- **When the path forward is already clear.** Inversion earns its cost on ambiguous,
  high-stakes, or novel problems. On a well-understood task it adds a step that returns nothing.
- **When it curdles into pessimism.** Cataloguing failure is a risk tool, not a strategy. Teams
  that only invert stop taking the asymmetric bets that actually compound, and mistake
  timidity for rigour.
- **When the failure modes are unknowable.** In genuinely novel territory your list of ways to
  fail is a list of ways you *imagine* failing. Inverting an unfamiliar domain produces
  confident, specific, wrong answers.
- **When it becomes a veto.** "Here's how this could fail" is easy to say and hard to answer.
  Used as rhetoric rather than analysis, it kills proposals without ever making a claim that
  can be tested.

## Thinking Steps

1. **State the goal plainly.** One sentence, concrete enough to be wrong. "Launch the new
   pricing by March without losing enterprise accounts."
2. **Invert it.** Ask what would guarantee the opposite. Not "what might go wrong" — what
   would *reliably* produce disaster.
3. **Generate failure modes without filtering.** Incompetence, bad luck, wrong sequencing,
   the thing everyone knows but nobody says. Quantity first; judge later.
4. **Separate what you control from what you don't.** The uncontrollable half becomes
   contingency planning. The controllable half becomes rules.
5. **Convert each into an avoidance rule.** A failure mode is an observation; a rule is
   something you can be held to. "Don't ship pricing changes in the same week as a migration."
6. **Check the rules don't forbid winning.** If following all of them guarantees you never
   lose and never gain, you have inverted into paralysis. Loosen until the upside survives.

## Coaching Questions

- "It's a year from now and this failed badly. What's the story of how that happened?"
- "What would we have to do to guarantee this goes wrong?"
- "Which of those failure modes are we currently doing?"
- "What must we *not* do, no matter what else changes?"
- "If we wanted to lose our biggest customer on purpose, what would we start doing today?"
```

## File: skills/mental-models/models/leverage.md
size: 3538
sha: 0b7e3d6cfbcd00d5b6348de6d4f1780e435125f4
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/leverage.md

```text
---
type: mental-model
title: Leverage
description: Find the point where a small input produces a disproportionate output, and apply force there.
tags:
- science
- systems-thinking
- strategy
- prioritisation
status: stable
sources:
- id: lever
  resource: https://en.wikipedia.org/wiki/Lever
  title: The lever — force multiplied by distance from the fulcrum
  author: Archimedes
- id: leverage-points
  resource: https://en.wikipedia.org/wiki/Twelve_leverage_points
  title: Leverage points — places to intervene in a system
  author: Donella Meadows
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

A lever multiplies force by trading distance for it — the further from the fulcrum, the more
the same push accomplishes [^lever]. Archimedes' claim about moving the world with a long
enough lever is the point: the input did not change, the placement did.

Meadows generalised this to systems and ranked where interventions actually work [^leverage-points].
Her finding was that people intuitively push on the lowest-leverage points — parameters,
numbers, budgets — because those are visible and adjustable, while the high-leverage points
are rules, information flows, goals and the paradigm underneath. Changing a number is easy
and rarely matters. Changing who gets to see what information is hard and frequently changes
everything.

The practical discipline is not working harder. It is refusing to apply effort until you have
located the place where effort converts into outcome at a better rate. Most of the difference
between people's output is not intensity, it is placement.

## When to Avoid

- **When leverage amplifies mistakes.** Leverage is directionally neutral. A high-leverage
  intervention in the wrong direction is worse than low-leverage flailing, and financial
  leverage is the standard demonstration.
- **When the fulcrum is not where you think.** Acting on an incorrect model of the system
  concentrates all your effort in one wrong place.
- **When the search costs more than the work.** For small tasks, finding the leverage point
  takes longer than just doing it.
- **When high-leverage points are politically unavailable.** Meadows noted the highest ones
  are the most defended. Identifying one you cannot touch can be worse than useless if it
  becomes a reason to do nothing.

## Thinking Steps

1. **Define the outcome you want to move.** Specific and measurable, or you cannot compare
   intervention points.
2. **List candidate intervention points.** Everything you could push on, including ones
   outside your authority.
3. **Estimate the ratio for each.** Effort in versus expected change out. Ratios, not
   absolute impact.
4. **Climb Meadows' ladder.** If your candidates are all parameters and budgets, look higher
   — at rules, at who has what information, at what the system is actually optimising for.
5. **Check the direction before applying force.** Ask what happens if you are wrong about the
   mechanism. High leverage means the error is amplified too.
6. **Apply and measure.** If the output does not move disproportionately, the fulcrum was
   wrong. Re-locate rather than pushing harder.

## Coaching Questions

- "Where's the smallest change that moves this the most?"
- "Are we pushing on a number when we could change a rule?"
- "Who has information they can't act on, and who acts without information?"
- "If we're wrong about the mechanism, how bad is applying force here?"
- "What is this system actually optimising for, as opposed to what we say?"
```

## File: skills/mental-models/models/margin-of-safety.md
size: 3373
sha: 02a45c85978cece6626af51c219af93bbefb7f15
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/margin-of-safety.md

```text
---
type: mental-model
title: Margin of Safety
description: Build for materially worse than your best estimate, because your estimate is an estimate.
tags:
- systems-thinking
- risk
- engineering
- resilience
status: stable
sources:
- id: factor-of-safety
  resource: https://en.wikipedia.org/wiki/Factor_of_safety
  title: Factor of safety — designed capacity beyond expected load
- id: graham
  resource: https://en.wikipedia.org/wiki/Margin_of_safety_(financial)
  title: Margin of safety — buying below intrinsic value to absorb error
  author: Benjamin Graham
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

Engineers do not build a bridge to hold the expected load. They build it to hold several
times the expected load, because materials vary, loads exceed forecasts, and the calculation
itself might be wrong [^factor-of-safety]. The margin is not for the risks you modelled — it
is for the ones you did not.

Graham brought the same idea to investing: buy sufficiently below your estimate of intrinsic
value that you can be substantially wrong and still not lose [^graham]. The margin is
insurance against your own analysis.

The two conditions that make it necessary are uncertainty and asymmetry. If being wrong is
cheap and reversible, run close to the edge. If failure is catastrophic or irreversible, the
margin is the whole design. This is why the model is really about which failures you can
survive, not about being conservative in general — and why "we've never hit the limit" is an
argument for keeping the margin, not removing it.

## When to Avoid

- **When margin has a real competitive cost.** Over-provisioning everything is expensive and
  slow. Margins belong where failure is expensive, not everywhere.
- **When it hides a bad estimate.** A large margin over a number nobody trusts is not safety,
  it is a way to avoid doing the analysis.
- **When the failure is cheap and reversible.** For most software changes, fast rollback beats
  a large safety factor.
- **When margins stack invisibly.** Each layer adding its own conservative buffer produces a
  system sized for a load that cannot occur, at a cost nobody can see or defend.

## Thinking Steps

1. **State the expected load and how confident you are.** Both numbers. The confidence sets
   the margin.
2. **Ask what happens at failure.** Degraded, or gone? Recoverable, or permanent? This decides
   whether you need a margin at all.
3. **Size the margin to the consequence, not the probability.** Low-probability catastrophic
   failure still needs a large margin; high-probability trivial failure needs none.
4. **Identify what the margin is protecting against.** Load variance, or model error? Model
   error needs more, because you cannot bound it.
5. **Check for stacked margins.** Add up the buffers across layers and see what total load
   the system is now sized for.
6. **Protect the margin explicitly.** Unused capacity looks like waste and will be
   reallocated by the first person optimising costs unless it is documented as a margin.

## Coaching Questions

- "What happens if we're wrong by a factor of two?"
- "Is this failure recoverable, and how fast?"
- "How confident are we in the estimate the margin sits on top of?"
- "How many layers have each added their own buffer?"
- "Is that spare capacity waste, or is it the margin doing its job?"
```

## File: skills/mental-models/models/randomness.md
size: 3530
sha: 8e098b3807510e3b3b34ac3c658d520cf4b6f7b9
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/randomness.md

```text
---
type: mental-model
title: Randomness
description: Much of what looks like signal is noise, and we build causal stories over both without noticing.
tags:
- mathematics
- probability
- evidence
- luck
status: stable
sources:
- id: taleb
  resource: https://en.wikipedia.org/wiki/Fooled_by_Randomness
  title: Fooled by Randomness — the hidden role of chance
  author: Nassim Nicholas Taleb
- id: clustering
  resource: https://en.wikipedia.org/wiki/Clustering_illusion
  title: The clustering illusion — seeing patterns in random distributions
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

Random processes produce streaks, clusters and apparent patterns as a matter of course, and
we are reliably bad at recognising them as random [^clustering]. Genuinely random sequences
look less random to us than evenly spaced ones — which is why a shuffled playlist gets
complaints about repeats.

Taleb's argument extends this to outcomes generally: in any domain with a large luck
component, success is heavily sampled from lucky people, and their explanations of their
success are constructed after the fact [^taleb]. The explanation feels compelling to
everyone involved, including the person giving it, because we are unable to experience a
sequence of events without generating a cause.

The practical form is that process and outcome are different things. A good decision can
produce a bad result and a terrible decision can pay off, and if you evaluate decisions by
their outcomes in a high-variance domain, you will systematically learn the wrong lessons.

## When to Avoid

- **In low-variance domains.** Where outcomes are mostly determined by skill and process,
  attributing results to chance is an excuse. Most engineering is not a casino.
- **When it becomes unfalsifiable.** "That was luck" applied to every result you dislike is
  not analysis. It has to be a claim about the variance of a specific process.
- **When there is a discoverable cause.** Reaching for randomness before investigating is
  how root causes stay unfound. Intermittent bugs are not random, they are conditional.
- **When it removes responsibility.** Real luck exists and so does negligence, and the model
  is very comfortable to hide behind.

## Thinking Steps

1. **Estimate the luck component.** How much of the outcome in this domain is determined by
   factors nobody controls? This sets how much to discount the result.
2. **Separate the decision from the outcome.** Judge the decision on what was knowable at the
   time. Write it down before the result arrives, or you cannot do this honestly.
3. **Ask what the distribution would produce anyway.** Would a purely random process generate
   this streak at this rate? Often the answer is yes.
4. **Look for the unsuccessful cases.** Survivors are visible and failures are not, so success
   stories are sampled from the lucky tail by construction.
5. **Increase sample size before concluding.** One quarter, three customers and two incidents
   are not evidence about a process.
6. **Ask what result would have changed the lesson.** If a different outcome would have
   produced the opposite conclusion from the same decision, you are learning from noise.

## Coaching Questions

- "Was this a good decision, or just a good outcome?"
- "How much of this domain is luck?"
- "Would a random process have produced this pattern anyway?"
- "Who made the same call and it didn't work — have we looked for them?"
- "How many observations is this conclusion resting on?"
```

## File: skills/mental-models/models/regression-to-the-mean.md
size: 3707
sha: a379555065a4d2d10c4bc13062461181c596427f
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/regression-to-the-mean.md

```text
---
type: mental-model
title: Regression to the Mean
description: Extreme results are followed by less extreme ones for statistical reasons, independent of anything you did.
tags:
- mathematics
- statistics
- performance
- evaluation
status: stable
sources:
- id: galton
  resource: https://en.wikipedia.org/wiki/Regression_toward_the_mean
  title: Regression toward the mean — Galton's 1886 study of hereditary stature
  author: Francis Galton
- id: kahneman
  resource: https://en.wikipedia.org/wiki/Thinking,_Fast_and_Slow
  title: Thinking, Fast and Slow — regression and the illusion of training effects
  author: Daniel Kahneman
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

When a measurement combines skill and luck, an extreme result usually had extreme luck in it,
and luck does not repeat. So the next measurement lands closer to average — not because
anything changed, but because that is what the arithmetic does. Galton named it while studying
heights: tall parents have tall children who are on average shorter than the parents [^galton].

Kahneman's flight-instructor example is the one that matters for managers. Instructors
observed that praising a good landing was followed by a worse one, and criticising a bad
landing was followed by a better one, and concluded that criticism works and praise
backfires. The pattern is pure regression — exceptional landings are followed by ordinary
ones either way — but it taught a generation of instructors to punish [^kahneman]. This is the
model's real bite: regression manufactures evidence for whatever you happened to do after an
extreme event.

Anything selected *because* it was extreme will regress. Best-performing team, worst-performing
region, the quarter that broke records, the candidate who aced the interview.

## When to Avoid

- **When the process genuinely changed.** Regression assumes a stable underlying distribution.
  If you shipped a real fix, the improvement may be causal. The model is a null hypothesis to
  rule out, not a verdict.
- **When there is no luck component.** Deterministic measurements do not regress. A slow
  query that is slow because of a missing index will stay slow forever.
- **In systems with real momentum.** Reinforcing loops can make extremes persist or intensify.
  Bank runs and viral growth do not regress toward the mean on the relevant timescale.
- **As blanket cynicism.** Explaining every improvement as regression is as unscientific as
  explaining every one as skill. It is a specific claim requiring a specific baseline.

## Thinking Steps

1. **Ask if the case was selected for being extreme.** If you are looking at it *because* it
   was the best or worst, regression is guaranteed to be part of what happens next.
2. **Estimate the luck component.** How much of this measurement is noise? High variance
   means strong regression.
3. **Establish the baseline.** What is the long-run average for this thing? Without it you
   cannot tell regression from change.
4. **Predict the regression explicitly.** Before intervening, write down what you expect
   next with no intervention at all.
5. **Compare the outcome against that prediction, not against the extreme.** This is the step
   that separates a real effect from an artifact.
6. **Watch for the causal story.** If you praised or punished in between, your mind will
   supply a mechanism. Notice it and set it aside.

## Coaching Questions

- "Are we looking at this because it was exceptional?"
- "What would have happened next if we'd done nothing?"
- "How much of this number is noise?"
- "What's the long-run average, and how far from it was this?"
- "Did the process change, or just the result?"
```

## File: skills/mental-models/models/sampling.md
size: 3537
sha: 4e184b20922edfccf6fc81de0be10bb9634e5a56
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/sampling.md

```text
---
type: mental-model
title: Sampling
description: Small and self-selected samples lie confidently, and the people you can hear from are rarely the ones you need.
tags:
- mathematics
- statistics
- evidence
- research
status: stable
sources:
- id: small-numbers
  resource: https://en.wikipedia.org/wiki/Insensitivity_to_sample_size
  title: Belief in the law of small numbers — treating small samples as representative
  author: Amos Tversky and Daniel Kahneman
- id: survivorship
  resource: https://en.wikipedia.org/wiki/Survivorship_bias
  title: Survivorship bias — analysing only the cases that made it through
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

Tversky and Kahneman showed that people treat small samples as though they carry the
properties of the population — the "law of small numbers" — and so read strong conclusions
out of a handful of observations [^small-numbers]. Small samples have high variance, which
means they produce extreme results routinely, which means the striking finding from five
users is the expected output of a process with no signal in it.

The second failure is worse because sample size does not fix it. If the sample is selected by
a process related to what you are measuring, more data makes you more confident and no more
correct. Survivorship bias is the canonical case: studying successful companies tells you
what successful companies do, not what causes success, because the identical behaviours in
the firms that died are not in the dataset [^survivorship].

In practice the sample is almost always self-selected. The customers who answer surveys, the
users who file bugs, the candidates who apply, the people who stayed to give feedback.

## When to Avoid

- **When you must decide now.** Five interviews beat zero. The model says calibrate
  confidence to the sample, not to refuse to act on small ones.
- **On existence proofs.** One counterexample disproves a universal claim. If a single user
  cannot complete signup, that is not a sampling problem.
- **When the population is genuinely small.** With eleven enterprise customers, six is most
  of the population, not a small sample.
- **As a way to dismiss inconvenient data.** "Small sample" is the standard move for
  discarding evidence you do not like, and it is usually applied selectively.

## Thinking Steps

1. **Ask how the sample was selected.** Before size, mechanism: who ended up in this data and
   why. Selection bias is not repaired by more data.
2. **Name who is missing.** The churned customers, the candidates who did not apply, the
   projects that were cancelled. Absence is the information.
3. **Consider the size against the variance.** Noisy measurements need far more observations
   than people expect to say anything.
4. **Ask what result would be surprising.** If almost any outcome would be consistent with
   your theory, the sample cannot test it.
5. **Look for the failures deliberately.** Survivorship is fixed by going and finding the
   dead cases, which is work nobody schedules.
6. **State confidence in proportion.** "Three of five users struggled here, which is a signal
   worth testing" is honest. "Users struggle here" is not.

## Coaching Questions

- "How did these particular people end up in our data?"
- "Who isn't in this sample, and would they answer differently?"
- "How many observations is this, really?"
- "Have we looked at the ones that failed, or only the ones that worked?"
- "What result would have surprised us? If none, what did we learn?"
```

## File: skills/mental-models/models/scarcity.md
size: 3608
sha: 173c127e15c7a8a23dd95644066413cb48033bd3
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/scarcity.md

```text
---
type: mental-model
title: Scarcity
description: Not having enough of something captures attention and degrades judgement about everything else.
tags:
- economics
- human-nature
- attention
- decision-making
status: stable
sources:
- id: scarcity-book
  resource: https://en.wikipedia.org/wiki/Scarcity:_Why_Having_Too_Little_Means_So_Much
  title: Scarcity — how having too little captures the mind
  author: Sendhil Mullainathan and Eldar Shafir
- id: scarcity-econ
  resource: https://en.wikipedia.org/wiki/Scarcity
  title: Scarcity — limited resources against unlimited wants
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

Economics treats scarcity as the basic condition: finite resources, competing uses, so
everything has a price and a trade-off [^scarcity-econ]. Mullainathan and Shafir found the
more useful version for decision-making — scarcity is a psychological state that changes how
well you think [^scarcity-book].

Being short of something captures attention. That produces a real benefit, the focus
dividend: people short on time hit deadlines, people short on money track prices with
unusual accuracy. It also produces tunnelling. Bandwidth goes to the scarce thing and comes
out of everything else, so the person under deadline neglects the relationship, and the
company short on cash stops investing in the thing that would end the shortage.

The compounding version is the scarcity trap: borrowing against the future to solve today's
shortage guarantees a worse shortage next period. A team that ships by taking on technical
debt has less capacity next quarter, which forces more debt. The trap is not stupidity, it is
the rational local response to a binding constraint.

## When to Avoid

- **When the resource is not actually scarce.** Manufactured urgency produces the tunnelling
  costs with none of the benefit. Check whether the deadline is real before reorganising
  around it.
- **As an explanation for others' decisions you dislike.** "They're tunnelling" is a
  convenient way to dismiss a choice made under constraints you are not carrying.
- **When abundance is the actual problem.** Too many options, too much budget and too much
  time produce their own failures, and the scarcity lens will not see them.
- **When it licenses a permanent emergency.** Organisations that explain every shortcut by
  scarcity have made scarcity a culture rather than a condition.

## Thinking Steps

1. **Name what is actually scarce.** Time, money, attention, headcount, political capital.
   Be specific; the stated scarcity is often not the binding one.
2. **Check whether it is real.** Distinguish a genuine constraint from an urgency someone
   manufactured.
3. **Ask what is being neglected.** Whatever is outside the tunnel — maintenance,
   relationships, the strategic work — is where the cost is landing.
4. **Look for the trap.** Is today's fix borrowing from next period? Name the repayment.
5. **Build slack deliberately.** Slack looks like waste under scarcity and it is what stops
   the trap compounding. It has to be designed in, because it will never survive triage.
6. **Decide the important things outside the tunnel.** Make consequential calls when you are
   not in the crunch, because judgement inside it is measurably worse.

## Coaching Questions

- "What's genuinely scarce here, and is the constraint real?"
- "What are we not thinking about because we're focused on this?"
- "Does today's fix make next quarter harder?"
- "Where's our slack, and what happened to it?"
- "Would we make this same call if we weren't under the gun?"
```

## File: skills/mental-models/models/second-order-thinking.md
size: 3728
sha: b9f4a640bc1e9ccb4e787fdc67acfc48b0b1273d
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/second-order-thinking.md

```text
---
type: mental-model
title: Second-Order Thinking
description: Ask "and then what?" at least twice — the first-order winner is often the second-order loser.
tags:
- general-thinking
- consequences
- strategy
- decision-making
status: stable
sources:
- id: marks
  resource: https://en.wikipedia.org/wiki/Howard_Marks_(investor)
  title: The Most Important Thing — first-level versus second-level thinking
  author: Howard Marks
- id: cobra
  resource: https://en.wikipedia.org/wiki/Cobra_effect
  title: The cobra effect — perverse incentives producing the opposite of the intended result
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

First-order thinking stops at the immediate consequence. Second-order thinking asks what
happens *after* that, and after that. Howard Marks framed it as the difference between
first-level thinking ("it's a good company, buy the stock") and second-level thinking ("it's
a good company, but everyone knows that, so it's overpriced — sell") [^marks]. The gap
between those two is where most of the available advantage lives, because first-order
conclusions are the ones everybody reaches.

The classic demonstration is the cobra effect: a bounty on cobra skins produced cobra
farming, and cancelling the bounty released the now-worthless snakes, leaving more cobras
than before the policy [^cobra]. Every step was locally rational. The failure was in stopping
the analysis one step too early.

Second-order effects are usually delayed, usually diffuse, and almost always where the real
cost sits. They are also where compounding lives, which is why the model cuts both ways:
the same discipline that reveals a hidden cost reveals a hidden payoff nobody else priced.

## When to Avoid

- **On trivial or easily reversed decisions.** Applying it to lunch is a waste of a scarce
  resource. Reserve it for decisions that are expensive to undo.
- **When it becomes an infinite regress.** There is always another order. Past the second or
  third, you are usually generating fiction, not analysis — the error bars exceed the signal.
- **When it produces paralysis.** Every action has some bad downstream consequence. If the
  model consistently returns "therefore do nothing," it is being used to rationalise
  inaction, not to evaluate it.
- **In genuinely chaotic systems.** Where small changes produce wildly divergent outcomes,
  detailed second-order prediction is false precision. Build for resilience instead of
  forecasting the specific consequence.

## Thinking Steps

1. **State the action and its intended first-order effect.** "Cut prices 20% → we sell more
   units."
2. **Ask "and then what?"** What does the world do in response? Competitors, customers,
   your own team.
3. **Ask it again.** The second iteration is where most of the value is. Competitors match →
   the volume gain evaporates → you've reset the price expectation permanently.
4. **Look specifically for the actor whose incentives you just changed.** Perverse outcomes
   almost always arrive through someone rationally responding to a new incentive.
5. **Check the time axis.** Name *when* each effect lands. First-order effects are usually
   fast and second-order slow, which is exactly why the fast one dominates the decision.
6. **Ask what the effect is if it works too well.** Many second-order disasters are the
   first-order success arriving at ten times the expected scale.

## Coaching Questions

- "And then what happens?"
- "Who changes their behaviour because of this, and how?"
- "What does this look like in two years if it works exactly as intended?"
- "What are we teaching people to do by doing this?"
- "If this succeeds beyond our expectations, what breaks?"
```

## File: skills/mental-models/models/social-proof.md
size: 3588
sha: 3fc559351bc6b2c814f9a622db9c8f8575be013c
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/social-proof.md

```text
---
type: mental-model
title: Social Proof
description: We infer correct behaviour from what others do, most strongly exactly when we are least certain.
tags:
- human-nature
- influence
- groups
- bias
status: stable
sources:
- id: cialdini
  resource: https://en.wikipedia.org/wiki/Influence:_The_Psychology_of_Persuasion
  title: Influence — social proof as a principle of persuasion
  author: Robert Cialdini
- id: asch
  resource: https://en.wikipedia.org/wiki/Asch_conformity_experiments
  title: The Asch conformity experiments
  author: Solomon Asch
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

When we are unsure what to do, we look at what others are doing and treat it as evidence
[^cialdini]. Asch showed how far this goes: subjects gave obviously wrong answers about line
lengths after hearing confederates give them, and a meaningful fraction did so repeatedly
[^asch]. The line lengths were not ambiguous. The social signal simply outweighed the eyes.

Two conditions amplify it: uncertainty, and similarity. The less confident you are, the more
weight others' behaviour carries — which is precisely backwards, because uncertain situations
are where independent evidence matters most. And the more the others resemble you, the
stronger the pull, which is why an industry converges on practices nobody has tested.

The trap in technology decisions is that adoption is presented as evidence of quality when it
is usually evidence of adoption. Everybody moved to microservices partly because everybody
was moving to microservices, and the companies that quietly moved back rarely write the
conference talk.

## When to Avoid

- **When the crowd has real information you lack.** Following experienced people in an
  unfamiliar domain is usually correct. The model warns against *unexamined* deference, not
  all deference.
- **When contrarianism becomes the reflex.** Being reliably against consensus is as
  thoughtless as being reliably for it, and it feels like independent thinking.
- **On genuine conventions.** Which side of the road to drive on has no independently correct
  answer. Coordination problems are solved by doing what others do.
- **When there is no time.** Under time pressure with no way to evaluate, copying the crowd is
  a reasonable heuristic. Say that out loud rather than pretending it was analysis.

## Thinking Steps

1. **Notice the uncertainty.** Ask whether you would hold this view if nobody else did. The
   pull is strongest where you are least sure, so uncertainty is the cue to check.
2. **Ask what evidence the crowd actually has.** Did they evaluate, or did they also copy?
   Trace one or two steps back and you often find nobody tested anything.
3. **Look for the silent evidence.** Who tried this and stopped? Those cases rarely publish,
   and their absence is what makes the practice look more successful than it is.
4. **Find the dissenter.** Someone who examined it and disagreed is worth more than a hundred
   who agreed by default.
5. **Separate popularity from fit.** Widely adopted is a claim about the average case, not
   about your constraints.
6. **State what would change your mind.** If nothing would, you are holding a social position,
   not an analytical one.

## Coaching Questions

- "If no other company had done this, would we still?"
- "Who here actually evaluated it, versus heard it was standard?"
- "Who tried this and went back? Have we looked?"
- "Who on this team disagrees, and have we asked them properly?"
- "Are we choosing this because it fits us or because it's what's done?"
```

## File: skills/mental-models/models/trade-offs.md
size: 3405
sha: 31bd4a288e960256db19ab065cf32e3cb8446e31
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/models/trade-offs.md

```text
---
type: mental-model
title: Trade-offs
description: The real cost of a choice is the best thing you gave up to make it, not the money you spent.
tags:
- economics
- decision-making
- prioritisation
status: stable
sources:
- id: opportunity-cost
  resource: https://en.wikipedia.org/wiki/Opportunity_cost
  title: Opportunity cost — the value of the best forgone alternative
- id: sowell
  resource: https://en.wikipedia.org/wiki/Basic_Economics
  title: "Basic Economics — \"there are no solutions, only trade-offs\""
  author: Thomas Sowell
generated:
  by: claude-opus-5
  at: '2026-09-10T00:00:00Z'
---

The cost of anything is the best alternative you did not take [^opportunity-cost]. That is
not an accounting cost and it never shows up on a budget, which is exactly why it gets
ignored. Sowell's formulation — there are no solutions, only trade-offs — is the operational
version: any proposal presented as strictly better is a proposal whose costs have not been
found yet [^sowell].

The dominant failure is evaluating options against zero rather than against each other. "Is
this project worth doing?" almost always returns yes, because almost everything has positive
value in isolation. The useful question is what it displaces. A team with one quarter has one
quarter, and the cost of the feature is the other feature.

The second failure is the false binary. "Rewrite or patch" usually has an option C that
nobody costed, and the frame itself was a choice.

## When to Avoid

- **When it becomes an excuse for inaction.** Every option has costs, so a sufficiently
  determined trade-off analysis can justify doing nothing forever.
- **When there genuinely is a Pareto improvement.** They are rare but real — fixing an
  obviously broken process can be better on every axis. Insisting a hidden cost must exist
  is dogma.
- **When the alternatives are incommensurable.** Some things do not convert to a common
  unit, and forcing safety, morale and revenue onto one scale hides a value judgement inside
  arithmetic.
- **On decisions too small to analyse.** The analysis has its own opportunity cost, and for
  most choices it exceeds the value of getting it right.

## Thinking Steps

1. **List the real alternatives, including "do nothing."** Doing nothing is a live option
   with its own cost and it is usually left off the list.
2. **For the leading option, name what it displaces.** Not its price — the specific other
   thing that will not happen because of it.
3. **Check whether the choice is actually binary.** Two options presented as exhaustive
   usually are not. What is option C?
4. **Identify the scarce resource.** Money, engineer-months, attention, goodwill. The
   trade-off is always denominated in whichever is genuinely scarce, and it is rarely money.
5. **Ask what you would need to believe to prefer the alternative.** This surfaces the
   assumption the decision actually rests on.
6. **Say the cost out loud when you decide.** A decision recorded with its forgone
   alternative can be evaluated later. One recorded as "we chose X" cannot.

## Coaching Questions

- "What doesn't happen because we do this?"
- "What's the third option we haven't named?"
- "What's actually scarce here — is it really the money?"
- "What would have to be true for the other choice to win?"
- "If this is strictly better than the alternative, what cost haven't we found?"
```

## File: skills/mental-models/TEMPLATE.md
size: 2276
sha: 5c8cf1298fbc976e0788011a709e242ceebaa378
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/skills/mental-models/TEMPLATE.md

```text
<!--
Copy this file to write your own mental model.

  .mental-models/<name>.md          this project's models — commit them with the code
  ~/.claude/mental-models/<name>.md your personal models, available everywhere

Name the file after the idea, in lowercase with hyphens: blast-radius-first.md

The frontmatter below is Open Knowledge Format. Only `type` is required; everything else
is optional, and `sources` is the one worth the effort. A model whose claims trace to
something real is worth more than three that don't.
-->
---
type: mental-model
title: <Title Case Name>
description: <one sentence — what the model does, not what topic it is about>
tags:
- <area, e.g. incident-response>
- <situation, e.g. outage>
- <the words you would actually use when you have this problem>
status: draft
sources:
- id: <short-key>
  resource: <URL, book page, internal doc, or a link to the incident it came from>
  title: <what it is>
  author: <who>
---

<!--
Two or three paragraphs. What the idea is, where it came from, and what it lets you see
that you'd otherwise miss. Cite claims inline with [^short-key] pointing at a `sources` id.

If it came from something that happened to you, say so — that provenance is worth more
than a citation to a famous book, because nobody else has it.
-->

## When to Avoid

<!--
The section that does the real work, and the reason to write your own model at all.
Conditions where this model actively misleads you — not generic caveats.

Bad:  "Don't apply it rigidly."
Good: "Not for chronic degradation — there's no expanding radius, so it manufactures
       urgency and burns the team on something that needed a project, not a page."
-->
- **<Condition>:** <what it does wrong here, and why>
- **<Condition>:** <what it does wrong here, and why>

## Thinking Steps

<!--
4-6 actions the reader takes, in order. Actions, not descriptions of the concept.
Each step should be something you could catch yourself failing to do.
-->
1. **<Step name>:** <what to do>
2. **<Step name>:** <what to do>
3. **<Step name>:** <what to do>
4. **<Step name>:** <what to do>

## Coaching Questions

<!-- 4-6 questions someone would actually say out loud to make you apply this. -->
- "<question>"
- "<question>"
- "<question>"
- "<question>"
```

## File: README.md
upstream: https://github.com/cyperx84/claude-skills-mental-models/blob/main/README.md

````text
# Mental Models for Claude Code

[![GitHub stars](https://img.shields.io/github/stars/cyperx84/claude-skills-mental-models?style=flat-square)](https://github.com/cyperx84/claude-skills-mental-models/stargazers)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?style=flat-square)](./LICENSE)
[![Claude Code Compatible](https://img.shields.io/badge/Claude%20Code-Compatible-8A2BE2?style=flat-square)](https://code.claude.com/docs)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](./.github/CONTRIBUTING.md)

Mental models as files an agent reads — bring your own, or start with the 21 that ship.

> A latticework for better decisions, one prompt away.

## What It Does

Ask for "inversion," "find the bottleneck," or "help me think through X" and Claude picks
2–4 models from different areas, walks their Thinking Steps against your actual problem,
surfaces the conditions under which each one misleads you, and tells you where they disagree.

The models are files. Twenty-one ship with it — each with a `sources` block whose claims
trace to something real — and you can add your own, which take precedence. No dependencies,
no runtime, no build step.

## Install

**Claude Code — plugin (recommended):**

```bash
/plugin marketplace add cyperx84/claude-skills-mental-models
/plugin install mental-models@mental-models
```

Or from your shell:

```bash
claude plugin marketplace add cyperx84/claude-skills-mental-models
claude plugin install mental-models@mental-models
```

**Any other harness — clone and symlink.** The skill is one self-contained folder with a
`SKILL.md` at its root, which is the format Codex, Cursor, OpenCode, and other
AgentSkills-convention harnesses read:

```bash
git clone https://github.com/cyperx84/claude-skills-mental-models.git
ln -s "$PWD/claude-skills-mental-models/skills/mental-models" ~/.claude/skills/mental-models
# or ~/.agents/skills/, or whatever your harness scans
```

Nothing else to run. The skill reads its own files.

**Upgrading from an older clone?** Previous versions told you to symlink
`.claude/skills/mental-models`. That directory is gone. A stale symlink fails silently — the
skill simply stops activating, with no error. Repoint it:

```bash
cd /path/to/your/claude-skills-mental-models   # your existing clone
git pull                                        # skills/ does not exist until you do
rm -f ~/.claude/skills/mental-models            # -f: the old symlink may already be gone
ln -s "$PWD/skills/mental-models" ~/.claude/skills/mental-models
```

`ln -s` never checks that its target exists, so pull first or you will replace one dangling
symlink with another.

Or drop the symlink entirely and install the plugin above.

## Quick Start

Once installed, it activates on its own:

```
Apply inversion to this architecture decision
```

```
What mental models help with scaling systems?
```

```
Help me think through whether to take this job offer
```

## Bring Your Own Models

The bundled models are a starting set, not a fixed list. Drop a markdown file in either place
and it joins the latticework:

```
.mental-models/<name>.md            this project's or team's models, committed with the code
~/.claude/mental-models/<name>.md   your personal models, available everywhere
```

Copy [`TEMPLATE.md`](./skills/mental-models/TEMPLATE.md) and fill in the sections.
No registration, no config, no rebuild — the skill globs those paths every time it runs, and
a model you wrote wins any name collision with a bundled one.

This is the interesting half. A general model about incidents is fine; *your* model about
how your team handles incidents, sitting in your repo where every agent working there picks
it up, is better. Institutional judgment, version-controlled, applied automatically.

Plugin updates never touch either path.

### It's an OKF bundle

`models/` conforms to Google's [Open Knowledge Format](https://github.com/GoogleCloudPlatform/open-knowledge-format) —
a directory of markdown files with YAML frontmatter, one `type` per concept, an `index.md` at
the root. That is not a detail: it means any OKF bundle is already a valid drop-in here, and
this bundle is readable by any OKF-aware agent. Obsidian vaults work too — `[[wikilinks]]`
are treated as links.

Nothing to convert. If you have a knowledge bundle, it's already in the right shape.

## Why Munger?

Charlie Munger argued that worldly wisdom comes from building a **latticework of mental
models** drawn from many disciplines—then hanging experience on that lattice. A single
discipline gives you a hammer; a latticework gives you judgment. This skill operationalizes
that idea: instead of one framework, Claude reaches across psychology, physics, economics,
math, and strategy to analyze your problem. Read more in
[Poor Charlie's Almanack](https://www.stripe.press/poor-charlies-almanack) or Farnam Street's
[Mental Models hub](https://fs.blog/mental-models/).

## The Models

Twenty-one, listed in [`models/index.md`](./skills/mental-models/models/index.md):

| Area | Models |
|---|---|
| Thinking tools | first-principles thinking, second-order thinking, inversion |
| Systems | bottlenecks, feedback loops, emergence, leverage, margin of safety |
| Physical | activation energy, inertia |
| Evidence | sampling, randomness, regression to the mean |
| Economics | trade-offs, scarcity, creative destruction |
| People | bias from incentives, social proof, confirmation bias, framing |
| Strategy | asymmetric warfare |

There were 98. They were one generation run that mirrored someone else's list with no
citations, so 2.0 replaced them with a smaller set that carries sources. The count was never
the point — [your own models](#bring-your-own-models) are.

One problem, many lenses — that's the point.

## What's In Here

```
skills/mental-models/
├── SKILL.md      entry point: when to activate, how to select, how to apply
├── TEMPLATE.md   the format — copy this to write your own
└── models/       an OKF bundle: index.md plus one file per model
```

Your own models live outside the skill, at `.mental-models/` or `~/.claude/mental-models/`,
so an update can never overwrite them.

## Contributing

Model additions, fixes, and new examples welcome. See [CONTRIBUTING.md](./.github/CONTRIBUTING.md).

## License

[MIT](./LICENSE)

## References

Sources, citations, and further reading in [REFERENCES.md](./REFERENCES.md).
````
