home / skills / jackspace / claudeskillz / sequential-thinking_mrgoonie

sequential-thinking_mrgoonie skill

safe

This skill guides structured, step-by-step problem solving with revision and branching to adapt scope and explore alternatives.

This is most likely a fork of the sequential-thinking skill from mamba-mental

npx playbooks add skill jackspace/claudeskillz --skill sequential-thinking_mrgoonie

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

Files (4)

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

Overview

This skill enables systematic, step-by-step reasoning for complex problems that need iterative thought, branching, and revision. It provides a structured pattern to decompose tasks, adjust scope as you learn, and keep a clear trace of the reasoning chain. Use it when multi-stage analysis or design planning is required and outcomes depend on progressive refinement.

How this skill works

You record discrete reasoning steps (thoughts) with metadata: step number, whether more steps are needed, and an estimated total. The skill supports dynamic scope updates, explicit revisions of prior steps, and branching from any point to explore alternatives. Context and history are preserved so you can backtrack, compare branches, and converge on a final conclusion.

When to use it

Solving multi-stage problems that require decomposition and progressive refinement
Design planning for systems or experiments where scope is uncertain initially
Tasks that may require backtracking, re-evaluating assumptions, or correcting earlier steps
Exploring multiple approaches in parallel to compare trade-offs
Filtering complex information to find core issues or failure modes

Best practices

Start with a rough estimate for total steps and update it as understanding improves
Write short, explicit thoughts that capture intent, evidence, and next action
Mark revisions clearly and link them to the thought number being revised
Create branches when multiple viable strategies emerge and label them with branch IDs
Express uncertainty in thoughts to signal where further investigation is needed

Example use cases

Decomposing a bioinformatics pipeline into sequential validation steps, revising when a dataset fails QC
Designing cloud infrastructure: iterate through architecture choices, branch for cost vs. performance options
Debugging a complex production bug by stepping through hypotheses and backtracking when a test disproves one
Planning a data-science experiment: sequentially select features, models, and evaluation criteria with revisions
Exploring research ideas where early assumptions are likely to change and alternative methods should be compared

FAQ

Can I change the estimated total steps mid-process?

Yes — adjust totalThoughts dynamically as you learn more; the pattern expects scope changes.

How do I represent alternative approaches?

Use branchFromThought and branchId to fork the chain and track each approach separately.