Deep Analysis — Structured Reasoning Engine

Multi-step reasoning through the sequential-thinking MCP server. Decomposes complex problems into discrete thinking steps with branching, revision, and hypothesis verification.

When to Use

• Architectural decisions with multiple valid approaches
• Performance diagnosis where the bottleneck is unclear
• Technology selection requiring trade-off evaluation
• Complex debugging (use /investigate for full root cause protocol)
• System design with many interconnected parts
• Migration strategies with risk assessment

Do NOT use for: Simple lookups, straightforward implementations, well-established patterns, or tasks where the answer is obvious.

Pre-Flight Gate

Activation is decided by the frontmatter description alone — this file is read only AFTER the skill has been selected. Nothing here can prevent over-triggering, so this gate is a post-selection redirect, not a filter.

Before proceeding, check the ABORT conditions below. If any holds, STOP, say in one line which one fired, and take the redirect instead of starting the chain. Being invoked — including a literal /deep-analysis or "give me a deep analysis" — does NOT override an ABORT: the phrasing that selected this skill is not evidence the problem is hard.

PROCEED only when no ABORT fired AND the problem is genuinely open — several defensible answers, an architectural or trade-off decision, an unexplained bottleneck, or a design space that must be reasoned through rather than looked up.

Protocol

1. Frame the Problem

Start the sequential-thinking chain with a clear problem statement and all known constraints.

mcp__sequential-thinking__sequentialthinking({
  thought: "PROBLEM: <clear statement>. CONSTRAINTS: <known limits>. Let me decompose this...",
  thoughtNumber: 1,
  totalThoughts: 10,  // Initial estimate — adjust as needed
  nextThoughtNeeded: true
})

2. Reason Through Steps

Each thought builds on the previous. Adjust totalThoughts up or down as understanding deepens.

mcp__sequential-thinking__sequentialthinking({
  thought: "Step 2: Analyzing option A. Strengths: ... Weaknesses: ...",
  thoughtNumber: 2,
  totalThoughts: 10,
  nextThoughtNeeded: true
})

3. Branch When Alternatives Exist

Explore competing approaches without losing the main thread.

mcp__sequential-thinking__sequentialthinking({
  thought: "BRANCH: What if we use approach B instead? Let me evaluate...",
  thoughtNumber: 5,
  totalThoughts: 12,
  nextThoughtNeeded: true,
  branchFromThought: 3,
  branchId: "approach-B"
})

4. Revise When Evidence Changes

Don't force a conclusion — revise earlier thinking when new evidence contradicts it.

mcp__sequential-thinking__sequentialthinking({
  thought: "REVISION: My assumption in step 3 was wrong. Evidence shows X instead of Y...",
  thoughtNumber: 7,
  totalThoughts: 14,
  nextThoughtNeeded: true,
  isRevision: true,
  revisesThought: 3
})

5. Conclude with Verification

Final thought must verify the conclusion against the original problem and constraints.

mcp__sequential-thinking__sequentialthinking({
  thought: "CONCLUSION: Approach A is recommended because [evidence]. Verified against constraints: [check]. Risks: [list].",
  thoughtNumber: 10,
  totalThoughts: 10,
  nextThoughtNeeded: false
})

Key Parameters

Thinking Budget

• Up to 31,999 tokens per reasoning chain
• Typical analyses: 8-15 steps
• Adjust totalThoughts dynamically — don't force exactly N steps
• Balance depth vs response time

Integration with Other Skills

References

• Reasoning Patterns — hypothesis testing, design space exploration, root cause templates
• Integration Guide — pairing with agents and other skills