home / skills / linehaul-ai / linehaulai-claude-marketplace / sequential-thinking

sequential-thinking skill

safe

This skill guides structured, iterative reasoning to solve complex problems, enabling revision, branching, and dynamic scope adjustment for clear multi-step

npx playbooks add skill linehaul-ai/linehaulai-claude-marketplace --skill sequential-thinking

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

Files (4)

SKILL.md

3.2 KB

---
name: sequential-thinking
description: Use when complex problems require systematic step-by-step reasoning with ability to revise thoughts, branch into alternative approaches, or dynamically adjust scope. Ideal for multi-stage analysis, design planning, problem decomposition, or tasks with initially unclear scope.
keywords: [reasoning, problem-solving, structured-thinking, analysis]
license: MIT
disable-model-invocation: true
user-invocable: true
---

# Sequential Thinking

Enables structured problem-solving through iterative reasoning with revision and branching capabilities.

## Core Capabilities

- **Iterative reasoning**: Break complex problems into sequential thought steps
- **Dynamic scope**: Adjust total thought count as understanding evolves
- **Revision tracking**: Reconsider and modify previous conclusions
- **Branch exploration**: Explore alternative reasoning paths from any point
- **Maintained context**: Keep track of reasoning chain throughout analysis

## When to Use

Use `mcp__reasoning__sequentialthinking` when:
- Problem requires multiple interconnected reasoning steps
- Initial scope or approach is uncertain
- Need to filter through complexity to find core issues
- May need to backtrack or revise earlier conclusions
- Want to explore alternative solution paths

**Don't use for**: Simple queries, direct facts, or single-step tasks.

## Basic Usage

The MCP tool `mcp__reasoning__sequentialthinking` accepts these parameters:

### Required Parameters

- `thought` (string): Current reasoning step
- `nextThoughtNeeded` (boolean): Whether more reasoning is needed
- `thoughtNumber` (integer): Current step number (starts at 1)
- `totalThoughts` (integer): Estimated total steps needed

### Optional Parameters

- `isRevision` (boolean): Indicates this revises previous thinking
- `revisesThought` (integer): Which thought number is being reconsidered
- `branchFromThought` (integer): Thought number to branch from
- `branchId` (string): Identifier for this reasoning branch

## Workflow Pattern

```
1. Start with initial thought (thoughtNumber: 1)
2. For each step:
   - Express current reasoning in `thought`
   - Estimate remaining work via `totalThoughts` (adjust dynamically)
   - Set `nextThoughtNeeded: true` to continue
3. When reaching conclusion, set `nextThoughtNeeded: false`
```

## Simple Example

```typescript
// First thought
{
  thought: "Problem involves optimizing database queries. Need to identify bottlenecks first.",
  thoughtNumber: 1,
  totalThoughts: 5,
  nextThoughtNeeded: true
}

// Second thought
{
  thought: "Analyzing query patterns reveals N+1 problem in user fetches.",
  thoughtNumber: 2,
  totalThoughts: 6, // Adjusted scope
  nextThoughtNeeded: true
}

// ... continue until done
```

## Advanced Features

For revision patterns, branching strategies, and complex workflows, see:
- [Advanced Usage](references/advanced.md) - Revision and branching patterns
- [Examples](references/examples.md) - Real-world use cases

## Tips

- Start with rough estimate for `totalThoughts`, refine as you progress
- Use revision when assumptions prove incorrect
- Branch when multiple approaches seem viable
- Express uncertainty explicitly in thoughts
- Adjust scope freely - accuracy matters less than progress visibility

Overview

This skill enables structured, step-by-step problem solving when tasks require multi-stage reasoning, revisions, or parallel exploration. It provides a disciplined way to decompose complex problems, track progress, and explicitly manage scope and branching. Use it to keep reasoning transparent and recoverable as understanding evolves.

How this skill works

You record individual reasoning steps (thoughts) with a step number and an estimate of total steps, and mark whether further steps are needed. The skill supports revising previous steps and creating branches from any point so alternative approaches can be explored without losing context. Context is preserved across the chain so you can backtrack, compare branches, and conclude when remaining work is complete.

When to use it

Solving problems that require multiple interconnected reasoning steps
When initial scope or approach is uncertain and may change
Decomposing large designs, plans, or analyses into manageable steps
When you expect to revisit assumptions and revise conclusions
Exploring multiple solution paths in parallel to compare outcomes

Best practices

Start with a rough estimate for totalThoughts and refine it as you progress
Express uncertainty explicitly in each thought to guide revisions
Use isRevision and revisesThought to keep change history clear
Create branches when distinct approaches are viable; tag with branchId
Keep each thought focused and actionable to simplify later review

Example use cases

Designing a multi-component system where requirements evolve
Investigating a complex bug that needs layered hypotheses and tests
Planning a phased project with alternatives for resource allocation
Decomposing a research question into experiments and analyses
Comparing algorithmic approaches by branching from a common analysis point

FAQ

What parameters must I provide for each reasoning step?

Provide thought (text), thoughtNumber, totalThoughts (estimate), and nextThoughtNeeded (boolean).

How do I handle changing scope mid-analysis?

Adjust totalThoughts dynamically and use isRevision or branchFromThought to reflect re-evaluation or new directions.