home / skills / samhvw8 / dotfiles / sequential-thinking

sequential-thinking skill

safe

This skill helps you solve complex problems by guiding step-by-step decomposition, hypothesis testing, and adaptive revisions for reliable outcomes.

npx playbooks add skill samhvw8/dotfiles --skill sequential-thinking

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

Files (15)

SKILL.md

3.6 KB

---
name: sequential-thinking
description: "Structured reflective problem-solving methodology. Process: decompose, analyze, hypothesize, verify, revise. Capabilities: complex problem decomposition, adaptive planning, course correction, hypothesis verification, multi-step analysis. Actions: decompose, analyze, plan, revise, verify solutions step-by-step. Keywords: sequential thinking, problem decomposition, multi-step analysis, hypothesis verification, adaptive planning, course correction, reflective thinking, step-by-step, thought sequence, dynamic adjustment, unclear scope, complex problem, structured analysis. Use when: decomposing complex problems, planning with revision capability, analyzing unclear scope, verifying hypotheses, needing course correction, solving multi-step problems."
version: 1.0.0
license: MIT
---

# Sequential Thinking

Structured problem-solving via manageable, reflective thought sequences with dynamic adjustment.

## When to Apply

- Complex problem decomposition
- Adaptive planning with revision capability
- Analysis needing course correction
- Problems with unclear/emerging scope
- Multi-step solutions requiring context maintenance
- Hypothesis-driven investigation/debugging

## Core Process

### 1. Start with Loose Estimate
```
Thought 1/5: [Initial analysis]
```
Adjust dynamically as understanding evolves.

### 2. Structure Each Thought
- Build on previous context explicitly
- Address one aspect per thought
- State assumptions, uncertainties, realizations
- Signal what next thought should address

### 3. Apply Dynamic Adjustment
- **Expand**: More complexity discovered → increase total
- **Contract**: Simpler than expected → decrease total
- **Revise**: New insight invalidates previous → mark revision
- **Branch**: Multiple approaches → explore alternatives

### 4. Use Revision When Needed
```
Thought 5/8 [REVISION of Thought 2]: [Corrected understanding]
- Original: [What was stated]
- Why revised: [New insight]
- Impact: [What changes]
```

### 5. Branch for Alternatives
```
Thought 4/7 [BRANCH A from Thought 2]: [Approach A]
Thought 4/7 [BRANCH B from Thought 2]: [Approach B]
```
Compare explicitly, converge with decision rationale.

### 6. Generate & Verify Hypotheses
```
Thought 6/9 [HYPOTHESIS]: [Proposed solution]
Thought 7/9 [VERIFICATION]: [Test results]
```
Iterate until hypothesis verified.

### 7. Complete Only When Ready
Mark final: `Thought N/N [FINAL]`

Complete when:
- Solution verified
- All critical aspects addressed
- Confidence achieved
- No outstanding uncertainties

## Application Modes

**Explicit**: Use visible thought markers when complexity warrants visible reasoning or user requests breakdown.

**Implicit**: Apply methodology internally for routine problem-solving where thinking aids accuracy without cluttering response.

## Scripts (Optional)

Optional scripts for deterministic validation/tracking:
- `scripts/process-thought.js` - Validate & track thoughts with history
- `scripts/format-thought.js` - Format for display (box/markdown/simple)

See README.md for usage examples. Use when validation/persistence needed; otherwise apply methodology directly.

## References

Load when deeper understanding needed:
- `references/core-patterns.md` - Revision & branching patterns
- `references/examples-api.md` - API design example
- `references/examples-debug.md` - Debugging example
- `references/examples-architecture.md` - Architecture decision example
- `references/advanced-techniques.md` - Spiral refinement, hypothesis testing, convergence
- `references/advanced-strategies.md` - Uncertainty, revision cascades, meta-thinking

Overview

This skill implements a structured reflective problem-solving methodology called sequential thinking. It guides multi-step analysis through decomposition, hypothesis generation, verification, and iterative revision to produce verifiable, confidence-rated outcomes. The process supports both explicit, visible reasoning and implicit internal use to improve accuracy without cluttering results.

How this skill works

The skill decomposes complex problems into manageable thoughts and assigns an initial loose estimate of steps. Each thought focuses on one aspect, records assumptions and uncertainties, and signals the next step. Dynamic adjustments let the process expand, contract, branch, or revise as new information appears; hypotheses are proposed and verified before a final, confidence-rated solution is returned.

When to use it

Decomposing complex problems into clear, ordered steps
Planning work that requires revision and course correction
Analyzing tasks with unclear or evolving scope
Verifying hypotheses or troubleshooting with iterative tests
Producing multi-step solutions while preserving context across steps

Best practices

Start with a loose step-count and adjust as understanding improves
Structure each thought: one focus, stated assumptions, and next-action signal
Use explicit thought markers when users need transparency; use implicit mode for routine tasks
Apply branching to compare approaches and document decision rationale
Record revisions clearly: original statement, reason for change, and impact on the plan

Example use cases

Debugging a complex system by forming hypotheses and running stepwise verifications
Designing a multi-stage project plan that may need adaptive replanning
Investigating ambiguous requirements by decomposing and iteratively clarifying assumptions
Comparing alternative architectures using branching and documented trade-offs
Validating experimental or data-analysis hypotheses with step-by-step tests

FAQ

Should I always show the internal thoughts to users?

No. Use explicit thought markers when transparency is required or the problem is complex; otherwise run the methodology implicitly and present only the distilled result.

How do I know when the process is complete?

Complete when the hypothesis is verified, all critical aspects are addressed, outstanding uncertainties resolved, and confidence is sufficient for the decision or deliverable.