Skip to main content
skill CX Codex

complex-reasoning — Claude Code skill: what it does, how to install

complex-reasoning adds multi-step reasoning frameworks for troubleshooting bugs and evaluating architecture. Activates for deep analytical tasks that require extended thinking.

MIT 167 installs ★ 22 updated 2026-10-22

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add TheLobbi/claude --skill complex-reasoning -a claude-code
Open on GitHub

What complex-reasoning does

This skill provides structured analytical patterns for difficult engineering problems. It includes Chain-of-Thought for linear breakdowns and Tree-of-Thought for exploring multiple solution paths with an evaluation matrix. For thorough domain coverage, it supplies a MECE framework to group issues into non-overlapping categories.

Troubleshooting relies on a hypothesis-driven workflow: testing observations, collecting evidence for and against, and identifying root causes. It also outlines templates for dependency graphs and change impact assessments. The configuration grants access to tools like Bash, Read, Write, Edit, Glob, Grep, Task, and WebFetch.

The skill explicitly lists extended-thinking as a prerequisite dependency. Without models configured for extended thinking, branching explorations hit depth limits early.

What it helps with

  • track down complex bugs with hypothesis testing
  • evaluate competing architecture choices using decision trees
  • audit direct and transitive software dependencies
  • map out rollback plans and blast radius before refactoring

Example prompts for the agent

  • Debug this intermittent production crash step by step using hypothesis-driven debugging.
  • Compare our migration options with Tree-of-Thought and score them in a matrix.
  • Perform a MECE analysis on our background job processing failures.

How to install complex-reasoning

1Skills CLI (Vercel)

npx skills add TheLobbi/claude --skill complex-reasoning -a claude-code

2Manually: put the files in place

~/.claude/skills/complex-reasoning/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/complex-reasoning/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about complex-reasoning

How to install complex-reasoning in Claude Code?

Run npx skills add TheLobbi/claude --skill complex-reasoning -a claude-code. The file is placed in ~/.claude/skills/complex-reasoning/SKILL.md.

What frameworks are included in complex-reasoning?

It defines Chain-of-Thought, Tree-of-Thought, MECE classification, and hypothesis-driven debugging. It also provides templates for dependency mapping and impact analysis.

Does complex-reasoning require any other skills?

Yes, it lists extended-thinking as a prerequisite dependency. It also relies on built-in environment tools like Bash, Read, Write, and Grep.

Source text

SKILL.md · MIT
---
name: complex-reasoning
description: Multi-step reasoning patterns and frameworks for systematic problem solving. Activate for Chain-of-Thought, Tree-of-Thought, hypothesis-driven debugging, and structured analytical approaches that leverage extended thinking.
allowed-tools:
  - Bash
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Task
  - WebFetch
dependencies:
  - extended-thinking
triggers:
  - chain of thought
  - tree of thought
  - step by step
  - reasoning
  - systematic
  - hypothesis
  - debug complex
  - break down
  - analyze systematically
  - multi-step
---

# Complex Reasoning Skill

Structured reasoning frameworks for systematic problem solving, leveraging extended thinking capabilities for deep analysis.

## When to Use

- **Debugging complex issues** with multiple potential causes
- **Architecture decisions** requiring trade-off analysis
- **Root cause analysis** for production incidents
- **Performance optimization** with multiple variables
- **Security vulnerability assessment**
- **Code refactoring** with many dependencies

## Reasoning Frameworks

### Chain-of-Thought (CoT)

Linear step-by-step reasoning for sequential problems.

```markdown
## Chain-of-Thought Analysis

**Problem**: [State the problem clearly]

**Step 1: Understand the Context**
- What do we know?
- What are the constraints?
- What is the expected outcome?

**Step 2: Identify Key Components**
- Component A: [description]
- Component B: [description]
- Interactions: [how they relate]

**Step 3: Analyze Each Component**
- Component A analysis...
- Component B analysis...

**Step 4: Synthesize Findings**
- Key insight 1
- Key insight 2

**Step 5: Formulate Solution**
- Recommended approach
- Rationale
- Trade-offs

**Conclusion**: [Final recommendation with confidence level]
```

### Tree-of-Thought (ToT)

Branching exploration for problems with multiple solution paths.

```markdown
## Tree-of-Thought Exploration

**Root Problem**: [Problem statement]

### Branch 1: Approach A
├── Pros: [List advantages]
├── Cons: [List disadvantages]
├── Feasibility: [High/Medium/Low]
├── Sub-branch 1.1: [Variation]
│   └── Outcome: [Expected result]
└── Sub-branch 1.2: [Variation]
    └── Outcome: [Expected result]

### Branch 2: Approach B
├── Pros: [List advantages]
├── Cons: [List disadvantages]
├── Feasibility: [High/Medium/Low]
└── Sub-branches: [...]

### Branch 3: Approach C
├── Pros: [...]
├── Cons: [...]
└── Feasibility: [...]

### Evaluation Matrix
| Approach | Feasibility | Impact | Risk | Score |
|----------|-------------|--------|------|-------|
| A        | High        | Medium | Low  | 8/10  |
| B        | Medium      | High   | Med  | 7/10  |
| C        | Low         | High   | High | 5/10  |

**Selected Path**: Branch [X] because [reasoning]
```

### MECE Framework

Mutually Exclusive, Collectively Exhaustive analysis.

```markdown
## MECE Analysis

**Problem Space**: [Define the complete problem]

### Category 1: [Mutually exclusive category]
- Sub-element 1.1
- Sub-element 1.2
- Sub-element 1.3

### Category 2: [Mutually exclusive category]
- Sub-element 2.1
- Sub-element 2.2

### Category 3: [Mutually exclusive category]
- Sub-element 3.1
- Sub-element 3.2
- Sub-element 3.3

**Completeness Check**:
- [ ] Categories are mutually exclusive (no overlap)
- [ ] Categories are collectively exhaustive (cover all cases)
- [ ] Each sub-element belongs to exactly one category

**Priority Matrix**:
| Category | Urgency | Impact | Action |
|----------|---------|--------|--------|
| 1        | High    | High   | Now    |
| 2        | Medium  | High   | Next   |
| 3        | Low     | Medium | Later  |
```

### Hypothesis-Driven Debugging

Systematic approach to debugging complex issues.

```markdown
## Hypothesis-Driven Debug Session

**Symptom**: [Observed behavior]
**Expected**: [What should happen]
**Environment**: [Relevant context]

### Hypothesis 1: [Most likely cause]
**Evidence For**:
- [Supporting observation 1]
- [Supporting observation 2]

**Evidence Against**:
- [Contradicting observation]

**Test**: [How to validate]
**Result**: [Confirmed/Refuted]

### Hypothesis 2: [Second most likely]
**Evidence For**:
- [...]

**Evidence Against**:
- [...]

**Test**: [...]
**Result**: [...]

### Root Cause Identified
**Cause**: [Confirmed root cause]
**Evidence Chain**: [How we proved it]
**Fix**: [Remediation steps]
**Prevention**: [How to prevent recurrence]
```

## Code Analysis Patterns

### Dependency Analysis

```markdown
## Dependency Analysis: [Component Name]

### Direct Dependencies
| Dependency | Version | Purpose | Risk Level |
|------------|---------|---------|------------|
| dep-a      | 2.3.1   | Auth    | Low        |
| dep-b      | 1.0.0   | Data    | Medium     |

### Transitive Dependencies
- Total: [N] packages
- Security vulnerabilities: [N]
- Outdated: [N]

### Dependency Graph
```
[component]
├── dep-a
│   ├── sub-dep-1
│   └── sub-dep-2
└── dep-b
    └── sub-dep-3
```

### Risk Assessment
1. **High Risk**: [Dependencies with known issues]
2. **Medium Risk**: [Outdated or unmaintained]
3. **Low Risk**: [Stable, well-maintained]

### Recommendations
1. [Action item 1]
2. [Action item 2]
```

### Impact Analysis

```markdown
## Impact Analysis: [Proposed Change]

### Affected Components
| Component | Impact Type | Severity | Test Required |
|-----------|-------------|----------|---------------|
| Service A | Direct      | High     | Yes           |
| Service B | Indirect    | Medium   | Yes           |
| Client C  | Downstream  | Low      | Optional      |

### Risk Assessment
- **Breaking Changes**: [List any]
- **Performance Impact**: [Expected effect]
- **Data Migration**: [Required/Not required]

### Rollback Plan
1. [Step 1]
2. [Step 2]
3. [Verification]

### Recommendation
[Go/No-Go with reasoning]
```

## Integration with Extended Thinking

When using these frameworks with extended thinking:

```python
# Enable extended thinking for complex reasoning
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},  # deeper reasoning for complex problems
    system="""You are a systematic problem solver. Use structured
    reasoning frameworks like Chain-of-Thought, Tree-of-Thought,
    or MECE analysis as appropriate for the problem.""",
    messages=[{
        "role": "user",
        "content": "Analyze this architecture decision using ToT..."
    }]
)
```

## Best Practices

1. **Choose the right framework**: CoT for linear problems, ToT for branching decisions
2. **Document your reasoning**: Makes it reviewable and repeatable
3. **Validate assumptions**: Each step should build on verified facts
4. **Consider alternatives**: Always explore at least 2-3 approaches
5. **Quantify when possible**: Use metrics to compare options
6. **Time-box exploration**: Set limits on analysis depth

## See Also

- [[extended-thinking]] - Enable deep reasoning capabilities
- [[deep-analysis]] - Analytical templates
- [[debugging]] - General debugging patterns
- [[testing]] - Validation strategies

© TheLobbi · MIT · TheLobbi/claude

Similar skills

All skills for Agent setup: memory, context, orchestration →
thought-based-reasoning NeoLabHQ thought-based-reasoning — a skill for Claude and other AI coders that gives the model a method for working through hard problems in explicit steps. Useful when a plain prompt returns the wrong answer. CX Codex +1 1,500installs tao-generate-video-reasoning-annotations NVIDIA Corporation tao-generate-video-reasoning-annotations turns raw videos into a training dataset with captions, descriptions and QA pairs carrying reasoning traces. Useful when you need labelled video data. CX Codex +1 1,600installs critical-thinking-logical-reasoning sammcj critical-thinking-logical-reasoning is a Claude Code skill that examines arguments in articles, reports and transcripts. It runs after an explicit request for critique. CX Codex +1 2,500installs recall-reasoning parcadei recall-reasoning — a Claude Code skill that digs through past sessions for decisions, working approaches, and dead ends. Query it before starting work similar to something already done. CX Codex +1 605installs clinical-diagnostic-reasoning curiositech clinical-diagnostic-reasoning detects cognitive biases in medical decisions, audits differential hypotheses, and structures diagnostic error reviews. Useful during treatment planning and clinical case debriefs. CX Codex +1 178installs critical-reasoning andrewgleave The critical-reasoning skill examines arguments for logical errors, untested assumptions, and weak explanations. Use it to critique an idea or check whether a conclusion follows. CX Codex +1 170installs

From the same set3

Project sponsors

Companies that keep this analytics open