╔═══════════════════════════════════════════════════════════════╗
║ ║
║ ██████╗ ██████╗ ████████╗ ║
║ ██╔════╝██╔═══██╗╚══██╔══╝ ║
║ ██║ ██║ ██║ ██║ ║
║ ██║ ██║ ██║ ██║ ║
║ ╚██████╗╚██████╔╝ ██║ ║
║ ╚═════╝ ╚═════╝ ╚═╝ Chain-of-Thought for Claude Code ║
║ ║
╚═══════════════════════════════════════════════════════════════╝
Structured technical reasoning for any language, framework, or paradigm. Forces Claude to decompose, resolve, and be honest about what it does not know.
Why this skill exists
Most AI responses to technical questions are fast but shallow. They give you an answer. They rarely show you the reasoning behind it. And they almost never tell you when they are uncertain.
This skill changes that.
It forces Claude to decompose the question, resolve each sub-problem in order, and be explicit about what it does not know. The result is a response you can verify, audit, and hand to a colleague without context.
Installation
/plugin marketplace add isSpicyCode/cot-skill-claude-code
/plugin install cot@cot
Usage
┌─ Terminal ──────────────────────────────────────────────────────┐
│ │
│ $ /cot:mode Why is my React app re-rendering on every tick? │
│ │
│ ┌─ How much detail do you need? ──────────────────────────┐ │
│ │ │ │
│ │ 1. Flash · Direct answer. Fast and short. │ │
│ │ 2. Normal · Full structured reasoning. │ │
│ │ 3. Deep · Normal + alternatives + tests + future. │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
The three modes
┌────────────────────────────────────────────────────────────────┐
│ FLASH │
│ ───── │
│ No decomposition. No phases. Direct answer. │
│ Token cost: ▓░░░░ │
│ Best for: syntax lookups · quick concepts · single-step │
└────────────────────────────────────────────────────────────────┘
For syntax lookups, quick concepts, and single-step questions. If the question requires more than three steps to answer correctly, Flash will complete its response and suggest running Normal or Deep.
┌────────────────────────────────────────────────────────────────┐
│ NORMAL │
│ ────── │
│ Phase 1 · Question type identification │
│ Phase 2 · Decomposition (prerequisite → core) │
│ Phase 3 · Sequential resolution │
│ Phase 4 · Summary, known limits, one principle to retain │
│ Token cost: ▓▓▓░░ │
│ Best for: implementation · debugging · review · architecture │
└────────────────────────────────────────────────────────────────┘
- Phase 1 — Identifies the question type: concept, implementation, debug, review, architecture, or comparison.
- Phase 2 — Decomposes into ordered sub-problems, from the simplest prerequisite to the core question.
- Phase 3 — Resolves each sub-problem sequentially, each one building on the previous.
- Phase 4 — Closes with a stable summary, known limits, and one language-independent principle to retain.
┌────────────────────────────────────────────────────────────────┐
│ DEEP │
│ ──── │
│ Everything in Normal, plus: │
│ Layer 5 · Trade-off table (all viable alternatives) │
│ Layer 6 · Full test coverage per sub-problem │
│ Layer 7 · Six-month consequence analysis │
│ Token cost: ▓▓▓▓▓ │
│ Best for: decisions that are hard or costly to reverse │
└────────────────────────────────────────────────────────────────┘