playbooks

home / skills / zpankz / mcp-skillset / think

think skill

/think

This skill orchestrates structured reasoning with non-linear thinking, mental models, and executable notebooks to tackle complex analysis and design.

npx playbooks add skill zpankz/mcp-skillset --skill think

Review the files below or copy the command above to add this skill to your agents.

Files (7)
SKILL.md
2.0 KB
---
name: think
description: Cognitive enhancement toolkit combining non-linear reasoning, mental models, and literate programming. Use for complex analysis, system design, debugging, deep learning, and research workflows.
---

# Think Skill

Orchestrate three MCP tools for structured reasoning.

## Quick Navigation

| Need | Go To |
|------|-------|
| Non-linear reasoning | [THOUGHTBOX.md](THOUGHTBOX.md) |
| Reasoning frameworks | [MODELS.md](MODELS.md) |
| Executable notebooks | [NOTEBOOK.md](NOTEBOOK.md) |
| Tool combinations | [PATTERNS.md](PATTERNS.md) |
| Problem→Solution routing | [SELECTION.md](SELECTION.md) |
| Concrete examples | [EXAMPLES.md](EXAMPLES.md) |

## Tools At a Glance

| Tool | Purpose | Key Feature |
|------|---------|-------------|
| `thoughtbox` | Step-by-step reasoning | 7 patterns: forward, backward, branching, revision, interleaved, first principles, meta-reflection |
| `mental_models` | Structured schemas | 15 models across 9 tags |
| `notebook` | Literate programming | 10 operations, executable JS/TS |

## When to Use This Skill

- **Complex problems** → decomposition + branching
- **Debugging** → five-whys + backward thinking
- **Architecture decisions** → pre-mortem + trade-off matrix
- **Deep learning** → Sequential Feynman notebook
- **Research tasks** → interleaved reasoning loops

## Minimal Invocation

```javascript
// Reasoning
thoughtbox({ thought: "...", thoughtNumber: 1, totalThoughts: 10, nextThoughtNeeded: true })

// Framework
mental_models({ operation: "get_model", args: { model: "five-whys" } })

// Notebook
notebook({ operation: "create", args: { title: "...", language: "typescript" }})
```

## MCP Resources (On-Demand)

| Resource | Access |
|----------|--------|
| Patterns cookbook | `thoughtbox({ includeGuide: true })` |
| Model content | `mental_models({ operation: "get_model", args: { model: "..." } })` |
| Notebook ops | `thoughtbox://notebook/operations` |
| Interleaved guides | `thoughtbox://interleaved/{mode}` |

---

*For deeper content, follow links above. Each file is self-contained.*

Overview

This skill is a cognitive enhancement toolkit that combines non-linear reasoning, a library of mental models, and an executable literate-programming notebook. It helps you structure thinking for complex analysis, system design, debugging, deep learning workflows, and research. The tools interoperate so you can iterate, test, and document reasoning in code and prose.

How this skill works

The skill orchestrates three capabilities: a thought engine for stepwise and branching reasoning patterns, a mental-models library for applying structured frameworks, and a notebook that supports executable JavaScript/TypeScript literate programming. Invoke the thought engine to generate and revise chains of reasoning, query mental models to apply formal schemas, and create runnable notebook cells to test hypotheses and document results. These components can be combined into interleaved loops: think, model, implement, and reflect.

When to use it

  • Decomposing complex, multi-step problems where branching and revision are needed
  • Root-cause analysis and debugging using backward reasoning and five-whys
  • Architecture or product decisions requiring pre-mortem and trade-off analysis
  • Designing or iterating deep learning experiments with sequential, testable notebooks
  • Research workflows that need interleaved hypothesis generation, testing, and documentation

Best practices

  • Start with a clear problem statement, then map the scope into numbered thoughts or steps
  • Choose a mental model that fits the task (e.g., five-whys for causes, trade-off matrix for decisions)
  • Use branching thoughts to explore alternatives, then prune and converge with revision steps
  • Keep notebook cells small and focused: one hypothesis, one experiment, one observation
  • Interleave reflection: periodically run meta-reflection patterns to reassess assumptions

Example use cases

  • Debugging a production bug: run backward reasoning to find the trigger, document findings in the notebook, and record the fix path
  • Architecture trade-off: generate alternative designs with branching thoughts, score them using a trade-off model, and capture results in a decision notebook
  • Research experiment: outline hypotheses with the thought engine, implement experiments in executable cells, and iterate using interleaved reasoning
  • Model selection for ML: use mental models to compare criteria, run small benchmark cells in the notebook, and apply revision patterns on results

FAQ

How do the three tools fit together?

Use the thought engine to generate and refine reasoning, consult mental models to apply formal frameworks, and record or run experiments in the notebook. Repeat these steps in loops for iterative progress.

What languages can the notebook run?

The notebook supports JavaScript and TypeScript for executable cells and literate-programming workflows.