Claude Cursor opencode Skill

sequential-thinking

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.

LLM Mart · 0 points · 3 views 0 listing impressions 0 install-command copies
Download vodailocz-kilo-kit-mcp-skills_problem-solving_sequential-thinking-0448e6c.zip · 7 KB

Install

skills CLI npx skills add https://github.com/VoDaiLocz/kilo-kit-mcp/tree/main/skills/problem-solving/sequential-thinking
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install vodailocz-kilo-kit-mcp@llmmart
Git git clone https://github.com/VoDaiLocz/kilo-kit-mcp.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole vodailocz/kilo-kit-mcp collection as a plugin from our marketplace. Git is the plain clone.

README

Sequential Thinking Skill

Agent skill for systematic problem-solving through iterative reasoning with revision and branching capabilities.

What This Skill Does

Enables Claude to break down complex problems into sequential thought steps, revise conclusions when needed, and explore alternative solution paths—all while maintaining context throughout the reasoning process.

Installation

This skill requires the Sequential Thinking MCP server to be installed and configured in your Claude Desktop or Claude Code environment.

Step 1: Install MCP Server

Choose one of the following methods:

NPX (Recommended)

Add to your claude_desktop_config.json or MCP settings:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}

Docker

{
  "mcpServers": {
    "sequentialthinking": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "mcp/sequentialthinking"]
    }
  }
}

Step 2: Add Skill to Project

Copy this skill folder to your project's .claude/skills/ directory:

cp -r sequential-thinking /path/to/your/project/.claude/skills/

Step 3: Verify Installation

Restart Claude and check that the mcp__reasoning__sequentialthinking tool is available.

Usage

Once installed, Claude will automatically use this skill when:

  • Facing complex multi-step problems
  • Needing to revise earlier conclusions
  • Exploring alternative solution approaches
  • Working through uncertain or evolving scopes

You can also explicitly request it:

"Let's think through this step-by-step using sequential thinking"

Configuration

Disable Logging (Optional)

To suppress thought information logging, set environment variable:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"],
      "env": {
        "DISABLE_THOUGHT_LOGGING": "true"
      }
    }
  }
}

Skill Structure

sequential-thinking/
├── SKILL.md              # Main skill definition
├── README.md             # This file
└── references/
    ├── advanced.md       # Revision and branching patterns
    └── examples.md       # Real-world use cases

When Claude Uses This Skill

The skill activates for:

  • Complex analysis: Breaking down multi-faceted problems
  • Design decisions: Exploring and comparing alternatives
  • Debugging: Systematic investigation with course correction
  • Planning: Multi-stage project planning with evolving scope
  • Architecture: Evaluating trade-offs across approaches

Learn More

License

MIT

Skill manifest

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

// 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:

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
Files (kilo-kit-mcp)
  • references
    • advanced.md 3.2 KB
      Loading…
    • examples.md 7.6 KB
      Loading…
  • README.md 3 KB
    # Sequential Thinking Skill
    
    Agent skill for systematic problem-solving through iterative reasoning with revision and branching capabilities.
    
    ## What This Skill Does
    
    Enables Claude to break down complex problems into sequential thought steps, revise conclusions when needed, and explore alternative solution paths—all while maintaining context throughout the reasoning process.
    
    ## Installation
    
    This skill requires the Sequential Thinking MCP server to be installed and configured in your Claude Desktop or Claude Code environment.
    
    ### Step 1: Install MCP Server
    
    Choose one of the following methods:
    
    #### NPX (Recommended)
    
    Add to your `claude_desktop_config.json` or MCP settings:
    
    ```json
    {
      "mcpServers": {
        "sequential-thinking": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
        }
      }
    }
    ```
    
    #### Docker
    
    ```json
    {
      "mcpServers": {
        "sequentialthinking": {
          "command": "docker",
          "args": ["run", "--rm", "-i", "mcp/sequentialthinking"]
        }
      }
    }
    ```
    
    ### Step 2: Add Skill to Project
    
    Copy this skill folder to your project's `.claude/skills/` directory:
    
    ```bash
    cp -r sequential-thinking /path/to/your/project/.claude/skills/
    ```
    
    ### Step 3: Verify Installation
    
    Restart Claude and check that the `mcp__reasoning__sequentialthinking` tool is available.
    
    ## Usage
    
    Once installed, Claude will automatically use this skill when:
    - Facing complex multi-step problems
    - Needing to revise earlier conclusions
    - Exploring alternative solution approaches
    - Working through uncertain or evolving scopes
    
    You can also explicitly request it:
    ```
    "Let's think through this step-by-step using sequential thinking"
    ```
    
    ## Configuration
    
    ### Disable Logging (Optional)
    
    To suppress thought information logging, set environment variable:
    
    ```json
    {
      "mcpServers": {
        "sequential-thinking": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"],
          "env": {
            "DISABLE_THOUGHT_LOGGING": "true"
          }
        }
      }
    }
    ```
    
    ## Skill Structure
    
    ```
    sequential-thinking/
    ├── SKILL.md              # Main skill definition
    ├── README.md             # This file
    └── references/
        ├── advanced.md       # Revision and branching patterns
        └── examples.md       # Real-world use cases
    ```
    
    ## When Claude Uses This Skill
    
    The skill activates for:
    - **Complex analysis**: Breaking down multi-faceted problems
    - **Design decisions**: Exploring and comparing alternatives
    - **Debugging**: Systematic investigation with course correction
    - **Planning**: Multi-stage project planning with evolving scope
    - **Architecture**: Evaluating trade-offs across approaches
    
    ## Learn More
    
    - [MCP Sequential Thinking Server](https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking)
    - [Model Context Protocol](https://modelcontextprotocol.io/)
    - [Agent Skills Documentation](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview.md)
    
    ## License
    
    MIT
    
  • SKILL.md 3.1 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.
    license: MIT
    ---
    
    # 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
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.