playbooks

home / skills / git-fg / thecattoolkit / applying-reasoning

applying-reasoning skill

/plugins/sys-cognition/skills/applying-reasoning

This skill helps you solve complex problems using structured mental models to guide architectural decisions, debugging, and strategic planning.

npx playbooks add skill git-fg/thecattoolkit --skill applying-reasoning

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

Files (5)
SKILL.md
1.8 KB
---
name: applying-reasoning
description: "Applies structured mental models to solve complex problems. Use when solving architectural decisions, root cause analysis, or strategic planning."
allowed-tools: [Read, Write, Edit, Glob, Grep, Bash]
---

# Reasoning Engine Protocol



## Library of Models
(See `references/` for detailed definitions)

| Model | Use Case |
|:---|:---|
| **First Principles** | Building from scratch; verifying assumptions. |
| **Inversion** | Debugging; identifying failure modes. |
| **Pareto (80/20)** | Prioritization; finding high-leverage tasks. |
| **Second Order** | Architectural changes; predicting side effects. |
| **5 Whys** | Root cause analysis. |

## Standard Combinations
- **The Hardening (First Principles + Inversion):** Use for critical security or reliability code.
- **The Efficiency (Pareto + Via Negativa):** Use for refactoring and cleanup.
- **The Diagnostic (5 Whys + Occam's Razor):** Use for debugging.

## Research Protocol (Core Mandate)
1. **Research**: Use `Grep` and `Bash` to find architectural patterns, performance bottlenecks, or technical debt.
2. **Framework Application**: Apply the `thinking-frameworks` methodology to the evidence found.
3. **Synthesis**: Create an `ANALYSIS.md` report using the template below.

## Constraints
- **Evidence-First**: Never make a claim without a file reference or shell output to support it.
- **Truth-First**: Contradict the user if the codebase evidence suggests their proposed path is flawed.

## Artifact Schema: `ANALYSIS.md`
When a Deep Analysis is requested, produce this artifact:

```markdown
# Strategic Analysis: {Topic}

## Executive Summary
{Concise findings}

## Framework Application
### {Framework Name}
**Insight:** {What did this model reveal?}

## Synthesis & Recommendations
1. {Actionable Item 1}
2. {Actionable Item 2}
```

Overview

This skill applies structured mental models to solve complex technical and strategic problems. It guides decision-making for architecture choices, root cause analysis, prioritization, and strategic planning. The approach combines proven frameworks to produce evidence-backed recommendations and clear next steps.

How this skill works

The skill inspects codebases, logs, and system outputs to gather evidence, then maps findings to a library of mental models (First Principles, Inversion, Pareto, Second Order, 5 Whys). It synthesizes insights into a concise analysis artifact with an executive summary, framework-specific insights, and prioritized recommendations. The output emphasizes traceable claims and actionable items tied to the evidence found.

When to use it

  • Making high-impact architectural or design decisions
  • Investigating production incidents and performing root cause analysis
  • Prioritizing technical debt and refactoring work using leverage-based criteria
  • Evaluating planned changes for potential second-order effects
  • Preparing strategic technical recommendations for leadership

Best practices

  • Start from evidence: include file references, logs, or command output for every claim
  • Choose the simplest model that explains the issue; escalate to combinations when needed
  • Use First Principles to validate assumptions before designing solutions
  • Apply Inversion to enumerate and defend against failure modes for critical changes
  • Document findings in a short analysis artifact with clear, prioritized actions

Example use cases

  • Compare two database migration strategies by listing assumptions, risks, and expected side effects
  • Debug a recurring latency spike using 5 Whys and Inversion to find the root cause and failure modes
  • Trim deployment complexity by applying Pareto to identify the 20% of modules causing 80% of slowdowns
  • Assess a major refactor for second-order impacts on observability and rollback paths

FAQ

What formats do outputs use?

Outputs are concise analysis artifacts with an executive summary, framework application, and prioritized recommendations.

How are claims validated?

Every substantive claim should reference supporting evidence such as file paths, grep results, or shell outputs.

When should models be combined?

Combine models when single-model insights are insufficient: e.g., use First Principles plus Inversion for critical security or reliability changes.