Thinking Framework Skills

An evidence-graded library of agent-executable thinking-method skills.

Every method is reduced to its working mechanism, graded honestly on how strong its evidence actually is, and shipped as a skill that produces a concrete artifact, not prose.

What it is  ·  Install  ·  Frameworks  ·  Evidence  ·  Recipes  ·  Live site

---

---

🧠 What this is

AI agents are fluent and fast, and surprisingly weak at the moves that make thinking actually good: reframing a problem before solving the wrong one, separating evidence from inference, imagining how a plan fails before it does, stress-testing a decision from more than one angle. Humans are not much better under time pressure. Both converge too early.

thinking-framework-skills packages the durable core of the structured-thinking tradition (decision science, creativity research, systems thinking, foresight, critical thinking) as small, composable, agent-ready skills. Each one helps a person or an agent reframe a problem, generate options, challenge an assumption, trace a consequence, or stress-test a decision, and hands back a usable artifact.

Three things make it different from a list of mental models:

Relationship to pm-skills: sibling library, no technical coupling. thinking-framework-skills helps decide what to work on and why it is sound; pm-skills helps execute how. They compose; neither depends on the other.

(back to top)

---

⚡ Quick start

Claude Code (recommended):

/plugin marketplace add product-on-purpose/agent-plugins
/plugin install thinking-framework-skills@product-on-purpose

All 63 frameworks (plus the 4 tools and 9 recipes) become available immediately, invocable by name (for example /think-premortem).

Cross-agent (Cursor, Copilot, Cline, and others via the open skills CLI):

npx skills add product-on-purpose/thinking-framework-skills

Clone or download:

git clone https://github.com/product-on-purpose/thinking-framework-skills.git

Your first run. Pick a real decision you are about to commit to, then:

/think-premortem "we're about to launch a free tier to drive signups"

You get a ranked risk register: for each top risk, a leading signal, a mitigation, an owner, and a kill criterion. That artifact, not a feeling of caution, is the point. You do not need an agent - every skill is a procedure you can run by hand with the template on its page.

Not sure which framework you need? Start with the Framework Advisor: describe your situation in plain language and it returns a prioritized Thinking Plan of which skills to run, in order, and what to skip. It is the front door to everything else.

How the Framework Advisor fits into your workflow:

%%{init: {'theme':'base','themeVariables':{'primaryColor':'#eef2ff','primaryBorderColor':'#c7d2fe','lineColor':'#6366f1'}}}%%
flowchart LR
  sit["Your situation(a prompt)"]:::in --> adv{"Framework Advisor(the front door)"}:::router
  adv --> plan["Thinking Plan(prioritized, evidence-graded)"]:::plan
  plan --> s1["run skill 1"]:::skill
  plan --> s2["run skill 2"]:::skill
  s1 --> art["Artifact(s):risk register, option matrix,argument map"]:::art
  s2 --> art
  sit -. "or apply directly" .-> top3["think-top3 /think-random-frameworks"]:::skill
  top3 --> art
  classDef in fill:#dcfce7,stroke:#86efac,color:#166534;
  classDef router fill:#ddd6fe,stroke:#a78bfa,color:#4c1d95;
  classDef plan fill:#fef9c3,stroke:#fde047,color:#854d0e;
  classDef skill fill:#eef2ff,stroke:#c7d2fe,color:#3730a3;
  classDef art fill:#e0f2fe,stroke:#7dd3fc,color:#075985;

📖 Full walkthrough: docs/getting-started.md · Explore the whole library: the live site.

(back to top)

---

🔬 What makes it different

The field of “thinking methods” has three uneven layers: a small empirical core with replicated study evidence, a large practitioner ring of long-standing heuristics with real traction but limited formal validation, and a noisy outer ring where popularity and weak evidence get conflated. Most libraries flatten all three into one shiny catalog.

This one does the opposite, and that honesty is the product:

• Grade evidence transparently. Every skill carries a tier, and its dossier states what the research does and does not show. A practitioner-tier method labeled honestly is more trustworthy than one dressed up as science.
• Do not launder statistics. The often-cited premortem “30%” is usually credited to Klein’s (2007) account, is not found in the study it describes, and was never a 30% gain in decision quality, so the library does not use it. Claims are scoped to what the studies actually measured.
• Mechanism over ritual. The skill implements the durable move and names the branded ritual as lineage, never the reverse. (So the library ships Parallel Perspectives Review, not the trademarked Six Thinking Hats.)
• Flag transferred evidence. Almost no studies test an AI agent running these methods. Where evidence comes from human-subject research, the page says so.

(back to top)

---

🗺️ The library at a glance

63 frameworks across 12 cognitive-operation families (56 core plus 7 contested lenses), arranged as a thinking lifecycle. (Four tools and nine recipes ride on top.) You rarely run all twelve; the Framework Advisor picks the few that fit your situation.

%%{init: {'theme':'base','themeVariables':{'primaryColor':'#eef2ff','primaryBorderColor':'#c7d2fe','lineColor':'#6366f1','fontFamily':'system-ui, sans-serif'}}}%%
flowchart TB
    classDef frame fill:#e0e7ff,stroke:#6366f1,color:#1e1b4b,font-weight:bold
    classDef gen fill:#dcfce7,stroke:#16a34a,color:#14532d,font-weight:bold
    classDef analyze fill:#fef9c3,stroke:#ca8a04,color:#713f12,font-weight:bold
    classDef decide fill:#ffedd5,stroke:#ea580c,color:#7c2d12,font-weight:bold
    classDef reflect fill:#f3e8ff,stroke:#9333ea,color:#581c87,font-weight:bold

    PF["1. Problem Framing (6) - frame the real problem"]:::frame
    DI["2. Divergent Ideation (6) - generate options"]:::gen
    PM["3. Perspective & Multi-Lens (2) - see it from other angles"]:::gen
    SC["4. Systems & Consequences (9) - trace consequences"]:::analyze
    AB["5. Assumption & Belief Challenge (5) - challenge assumptions"]:::analyze
    RC["6. Reasoning Clarity (5) - clarify the reasoning"]:::analyze
    DO["7. Decision & Option Evaluation (12) - decide between options"]:::decide
    SO["8. Strategy & Opportunity (2) - test strategy against alternative futures"]:::decide
    EV["9. Ethics & Values Deliberation (4) - weigh the moral trade-off"]:::decide
    RR["10. Risk & Resilience (4) - anticipate what could go wrong"]:::decide
    SY["11. Synthesis (4) - turn inputs into a message"]:::reflect
    MR["12. Meta-Thinking & Reflection (4) - learn and route"]:::reflect

    PF --> DI --> PM --> SC --> AB --> RC --> DO --> SO --> EV --> RR --> SY --> MR

In text: frame the problem, generate options, see it from other angles, trace consequences, challenge assumptions, clarify the reasoning, decide between options, test strategy against alternative futures, weigh the moral trade-off, anticipate what could go wrong, synthesize, then reflect. See the full color-coded map (by evidence tier) on the live site.

(back to top)

---

🔬 The evidence model

Honest grading is the differentiator, so the key comes before the catalog: every skill and every claim is labeled with one of seven tiers, from strongest to weakest.

A few skills carry a split grade (for example M/P or S/M): the mechanism rests on one tier while a specific claim about it rests on another. Where a grade leans on human-subject research that has not been tested on an AI agent, the skill’s dossier flags that transfer explicitly rather than overclaiming.

A strong-evidence core anchors the library; everything else is honestly labeled around it. The bibliography aggregates the graded sources so a skeptic can trace any claim to its grounding. See docs/concepts.md for the short version.

(back to top)

---

📚 The catalog

All 63 frameworks, by family. Seven are contested lenses (SWOT, ACH, Five Whys, Eisenhower/MoSCoW/Pareto, Complexity Domain Sort, Reflective Equilibrium, QCA): famous-but-weak methods graded honestly and shipped caveat-first, explicit-request-only, marked Contested lens in their rows. The Tier column is the evidence grade defined just above. Each name links to its full page - mechanism, numbered procedure, worked example, and graded sources - on the live site. (The routers and applicators are listed under Tools; the chains under Recipes.)

Problem Framing - frame the real problem (6)

Divergent Ideation - generate options (6)

Perspective & Multi-Lens - see it from other angles (2)

Systems & Consequences - trace consequences (9)

Assumption & Belief Challenge - challenge assumptions (5)

Reasoning Clarity - clarify the reasoning (5)

Decision & Option Evaluation - decide between options (12)

Strategy & Opportunity - test strategy against alternative futures (2)

Ethics & Values Deliberation - weigh the moral trade-off (4)

Risk & Resilience - anticipate what could go wrong (4)

Synthesis - turn inputs into a message (4)

Meta-Thinking & Reflection - learn and route (4)

Browse them five other ways - by job, by evidence, by artifact, by situation, or on the map - in the site’s Explore section. The skills themselves live in skills/.

(back to top)

---

🛠️ Tools (meta-skills)

Four skills are tools, not thinking methods: they operate over the library - routing you to the right framework, applying several at once, or researching new ones. They carry no evidence tier of their own (any grade in a tool’s dossier is about the tool’s behavior, not a method), and they live under /tools/ on the site.

Frameworks, tools, and recipes, in one line: a framework is a single graded thinking method (the 63 in the catalog above); a tool helps you choose or apply frameworks (the 4 here); a recipe is a fixed chain of frameworks for a recurring job (the 9 below).

(back to top)

---

⚙️ How a skill works

Each skill is a self-contained unit: a portable SKILL.md (the mechanism and procedure), an evidence/dossier.md (the graded sources and honest caveats), a references/EXAMPLE.md (a worked example that sets the quality bar), and a skill.meta.yml sidecar (governance, taxonomy, relationships).

%%{init: {'theme':'base','themeVariables':{'primaryColor':'#eef2ff','primaryBorderColor':'#c7d2fe','lineColor':'#6366f1','fontFamily':'system-ui, sans-serif'}}}%%
flowchart LR
    classDef you fill:#1e293b,stroke:#0f172a,color:#fff,font-weight:bold
    classDef skill fill:#4f46e5,stroke:#3730a3,color:#fff,font-weight:bold
    classDef art fill:#166534,stroke:#14532d,color:#fff,font-weight:bold

    U["Youa messy situation"]:::you
    S["A think- skillmechanism + procedure"]:::skill
    A["A concrete artifactrisk register, option matrix,argument map, Thinking Plan"]:::art

    U -- invoke --> S -- produces --> A

When you run /think-premortem "...", the agent loads the skill, follows its numbered procedure, mirrors the worked example, and produces the artifact. No prompt engineering required. The docs site is a generated view of these files; see docs/architecture.md for how the skills become the site.

(back to top)

---

🧩 Recipes

Recipes chain several skills into one end-to-end job, passing a compressed artifact at each handoff. Nine ship today:

Browse them on the live site or in _workflows/.

(back to top)

---

🧭 Find your way in

(back to top)

---

📖 Documentation

• Live site - the full, searchable, interactive experience (per-framework pages, learning tracks, explorers, the bibliography, the Showcase and per-framework Samples). This is the home for using the library.
• docs/ - the repo-browser and contributor layer: architecture, concepts, contributing, conformance, troubleshooting, the authoring loop, and the release process.
• skills/ - the frameworks themselves (the source of truth the site renders).

(back to top)

---

🥇 Conformance: what advanced (Gold) tier means

This plugin is built to the agent-skills-toolkit Advanced Skill Library Standard, which grades a skill library on three tiers. Each tier includes everything below it:

thinking-framework-skills validates at advanced (Gold) with 0 errors against Standard 0.8, the version it declares (library.json sets "standard": "0.8"). .github/workflows/ci.yml pins the exact toolkit commit CI grades with, and that commit is deliberately newer than the declared Standard.

Two dials, and the difference matters. The pinned toolkit is which validator runs. The declared Standard is which version of the rules the library holds itself to. Running a newer validator against an older declared Standard is supported by design: findings from rules introduced after 0.8 are held at warn rather than counted as failures. That is why the run reports 0 errors and 89 warnings, not 90 failures.

What those warnings are, because a number without an explanation is not a disclosure.

• 82 are post-0.8 documentation requirements (G8 folder READMEs, G7 docs frontmatter, G10 Diataxis coverage), introduced at Standard 0.10 and later. They are real work the library has not done, held at warn by the declared-version ceiling. Measured: declaring 0.13 instead returns convergent with 84 errors, which is why adopting it is a deliberate project rather than a version bump.
• 7 are U5 (description quality) on the seven contested lenses, and they score low for the reason those skills exist: their descriptions lead with an evidence caveat instead of a trigger phrase, which a heuristic tuned for discoverability penalizes. The library keeps the caveat and carries the warnings rather than rewording seven descriptions to score better than they deserve.

The error count is the number that gates, and it is zero. (For the record: the run was 0 errors, 0 warnings through v0.10.0, became 0 errors, 7 warnings when the contested lenses shipped in v0.11.0, and became 0 errors, 128 warnings when the toolkit pin moved forward in v0.13.x, became 0 errors, 129 warnings when the troubleshooting page shipped without taxonomy frontmatter, became 0 errors, 90 warnings when the G9 docblock sweep paid off all 39 source-docblock warnings, and became 0 errors, 89 warnings when docs/reference/ gave the Diataxis reference quadrant its first page.)

The Standard itself moves faster than this library re-pins, and that is a deliberate choice rather than an oversight: re-pinning is a release-sized decision here, so the tier claim above always names the Standard version it holds at rather than implying the newest one. Graded against a newer Standard, the result will differ until the next re-pin. Concretely, it earns Gold through:

• Self-hosting CI that passes. Every pull request runs scripts/check.mjs (the Standard’s validators) via .github/workflows/ci.yml, and check is a required status check on main. The same one command reproduces the result locally.
• Generated INDEX and manifests. INDEX.md, .claude-plugin/plugin.json, the Codex manifest, and manifest.generated.json are all generated from the authored library.json and drift-checked; a hand-edit is a CI error.
• Curated release notes. RELEASE-NOTES.md is maintained separately from the technical CHANGELOG.md.
• Deprecation policy and all Bronze and Silver requirements, by inclusion.

Two Gold checks are not applicable here, and the library says so rather than papering over it: hook documentation and chain/hook eval coverage apply only to plugins that ship hooks or chained components. This library ships neither - its recipes are workflow chains of independent skills, not runtime chain contracts - so those checks pass vacuously. Every skill still carries its own eval/cases.md.

Full breakdown, check by check: docs/conformance.md (also the canonical list of all check.mjs gate layers and how they relate to the Standard’s G1-G7 Gold requirements). The Standard itself: agent-skills-toolkit / STANDARD.md.

(back to top)

---

📊 Project status

v0.18.6 - public and growing. The library grows additively, and evidence grades are refreshed as the research does. User-facing highlights live in RELEASE-NOTES.md; the full technical history is in CHANGELOG.md.

At a glance

Repo structure

thinking-framework-skills/
├── skills/                  # 63 frameworks + 4 tools (the source of truth)
│   └── think-/      #   SKILL.md, evidence/dossier.md, references/, eval/cases.md, skill.meta.yml
├── frameworks/              # registry.mjs (the catalog) + per-method dossiers
├── _workflows/              # Recipe definitions (multi-skill chains) as workflow components
├── commands/                # Slash commands (generated from _workflows/, plus the research engine's)
├── agents/                  # Claude Code subagents (two generated from _workflows/)
├── recipes/                 # Human-readable recipe write-ups
├── scripts/                 # gen-site, gen-manifest, gen-recommendable, and the check.mjs gate
├── site/                    # Astro Starlight docs site (a generated view of skills/)
├── docs/                    # Contributor and build docs
│   └── internal/            #   AUTHORING.md, specs/, release-plans/, research/
├── .github/workflows/       # CI: the self-hosting conformance gate + Pages deploy
├── library.json             # Authored manifest (the canonical component index)
├── INDEX.md                 # Generated catalog index (drift-checked)
├── CHANGELOG.md             # Technical version history
├── RELEASE-NOTES.md         # Curated, user-facing release highlights
└── AGENTS.md                # Universal agent-discovery file

Changelog

Full detail in CHANGELOG.md; curated highlights in RELEASE-NOTES.md.

(back to top)

---

🤝 Contributing

Contributions, ideas, and framework proposals are welcome. The bar is deliberately high - it is what keeps the library trustworthy.

A new framework must clear the selection bar. It has to:

1. Add a distinct, durable cognitive move - not duplicate one already shipped. The overlap ceiling is real: candidates that reduce to an existing skill are rejected or become recipes.
2. Carry an honest evidence grade with a dossier of graded sources, including what the research does not show.
3. Produce a concrete artifact, not prose.
4. State when not to use it.

To propose or build one:

1. Open an issue describing the move and its evidence - the fastest way to get feedback before you build.
2. Read docs/contributing.md and the per-skill authoring loop in docs/internal/AUTHORING.md.
3. Mirror an existing skill’s 5-file structure (SKILL.md, evidence/dossier.md, references/, eval/cases.md, skill.meta.yml).
4. Run the conformance gate locally (node scripts/check.mjs) before opening a PR; CI runs the same gate.

Diagrams follow the pm-skills utility-mermaid-diagrams house style. Commit with Conventional Commits.

(back to top)

---

📄 License

Distributed under the Apache License 2.0. In short: you may use this library commercially, modify and redistribute it, use it privately, and include it in proprietary software. The only requirements are attribution and including the license notice.

On method names and trademarks. Names that are trademarks or carry specific licenses remain the property of their owners. This library implements the underlying cognitive mechanisms, names them descriptively, and notes lineage and attribution in each skill’s references rather than claiming the brands.

(back to top)

---

👋 About the maintainer

Built and maintained by Jonathan Prisant (@jprisant), a product leader who thinks in systems and gets unreasonably excited about understanding and solving problems. thinking-framework-skills is the reasoning sibling to pm-skills: one helps you decide what to work on and why it is sound, the other helps you execute how.

If this library has sharpened a decision, or saved you from a bad one, consider starring the repo and sharing it with your team.

Built with purpose by Product on Purpose Evidence-graded thinking, packaged as skills your agent can actually run