Sequential Thinking
Invoke structured multi-step reasoning with revision and branching when a solo builder faces fuzzy scope, architecture tradeoffs, or debugging that needs backtracking.
Overview
Sequential Thinking is a journey-wide agent skill that runs systematic step-by-step reasoning with revision and branching—usable whenever a solo builder needs to decompose complex problems before committing.
Install
npx skills add https://github.com/mrgoonie/claudekit-skills --skill sequential-thinkingWhat is this skill?
- Iterative reasoning via mcp__reasoning__sequentialthinking with explicit thought steps
- Dynamic thought count—adjust total steps as understanding evolves
- Revision tracking and branch exploration from any prior thought
- Maintained context across a full reasoning chain for multi-stage analysis
- Hard skip rule: do not use for simple facts or single-step tasks
Adoption & trust: 1.3k installs on skills.sh; 2.1k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your agent jumps to a single answer on intertwined problems, so you cannot revise assumptions or compare alternative paths safely.
Who is it for?
Complex analysis, design planning, and decomposition when scope is unclear and you have MCP sequential thinking available.
Skip if: Simple queries, direct factual lookups, or single-step edits where extra reasoning adds latency without value.
When should I use this skill?
Complex problems require systematic step-by-step reasoning with ability to revise thoughts, branch into alternative approaches, or dynamically adjust scope.
What do I get? / Deliverables
You get a maintained sequential thought chain with optional branches and revisions, ready to inform plans, fixes, or design choices in the next skill step.
- Documented thought chain with revisions and branches
- Clear next-step recommendation after reasoning completes
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Branch three MVP scope options after revising an earlier assumption about customer willingness to pay.
Decompose a multi-service feature into ordered thoughts before writing an implementation plan.
Walk a code review finding through revised thoughts when the first root-cause guess fails.
Trace production errors across layers with backtracking when logs contradict the initial hypothesis.
Compare launch channel tradeoffs in a branched reasoning path before committing spend.
How it compares
Procedural MCP reasoning workflow—not a static checklist template or a one-shot code generator.
Common Questions / FAQ
Who is sequential-thinking for?
It is for solo builders and agent users who run Claude Code or similar environments with reasoning MCP and need disciplined multi-step analysis.
When should I use sequential-thinking?
Use it journey-wide: during Build for architecture and PM decomposition, during Ship for review and debugging tradeoffs, during Validate when scoping ambiguous bets, and during Operate when triaging multi-cause incidents.
Is sequential-thinking safe to install?
The skill orchestrates an MCP reasoning tool, not arbitrary shell; review the Security Audits panel on this page and your MCP server permissions before enabling.
SKILL.md
READMESKILL.md - Sequential Thinking
# 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 # Advanced Usage: Revision and Branching ## Revising Previous Thoughts When a thought proves incorrect or incomplete, use revision to correct the reasoning chain: ```typescript { thought: "Actually, the N+1 problem isn't the bottleneck—profiling shows the issue is missing indexes on join columns.", thoughtNumber: 5, totalThoughts: 7, isRevision: true, revisesThought: 2, // References thought #2 nextThoughtNeeded: true } ``` **When to revise**: - New evidence contradicts earlier conclusions - Assumptions prove incorrect - Scope was misunderstood - Need to correct factual errors ## Branching Into Alternatives Explore different solution paths by branching from a specific thought: ```typescript // Main path (thoughts 1-3) { thought: "Could optimize with caching or database indexes.", thoughtNumber: