playbooks

home / skills / dmdorta1111 / jac-v1 / sequential-thinking

sequential-thinking skill

/.claude/skills/sequential-thinking

This skill guides complex problem solving through structured, reflective steps with adaptive planning and hypothesis verification.

npx playbooks add skill dmdorta1111/jac-v1 --skill sequential-thinking

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

Files (15)
SKILL.md
3.1 KB
---
name: sequential-thinking
description: Apply structured, reflective problem-solving for complex tasks requiring multi-step analysis, revision capability, and hypothesis verification. Use for complex problem decomposition, adaptive planning, analysis needing course correction, problems with unclear scope, multi-step solutions, and hypothesis-driven work.
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 applies structured, reflective problem-solving through sequential, inspectable thought steps that adapt as new information emerges. It helps break complex tasks into manageable thoughts, supports branching alternatives, and provides mechanisms for revision and hypothesis verification. Use it when you need multi-step analysis, dynamic course correction, or documented reasoning.

How this skill works

The skill guides the solver to produce a loose estimate of steps, then records each thought as a discrete, focused item that builds on prior context. Thoughts state assumptions, uncertainties, and explicit next actions; branches and revisions are created when alternatives or corrections arise. Hypotheses are proposed and then verified with tests or checks until a final, confident solution is reached.

When to use it

  • Complex problem decomposition with many dependencies
  • Adaptive project or research planning that will evolve
  • Debugging or investigation needing hypothesis testing
  • Problems with unclear or emerging scope
  • Multi-step solutions that require context preservation and review

Best practices

  • Start with a short, loose estimate of total thoughts and adjust as you go
  • Keep each thought focused on a single aspect and reference prior context explicitly
  • Mark revisions and branches clearly, stating why the change was made and its impact
  • Use hypothesis + verification cycles for uncertain conclusions
  • Choose explicit mode for collaborative or auditable reasoning and implicit mode for compact responses

Example use cases

  • Designing a multi-component system with iterative architecture choices
  • Debugging a complex bug using hypothesis generation and stepwise tests
  • Creating an adaptive project plan that must pivot as new constraints appear
  • Conducting research where evidence accumulates and conclusions must be revised
  • Exploring multiple design alternatives then converging on a rationale-backed decision

FAQ

When should I show the thought sequence to stakeholders?

Show it when transparency, auditability, or collaboration matters; use explicit mode for visible reasoning and implicit mode for concise delivery.

How do I decide to branch or revise?

Branch when multiple viable approaches exist; revise when new evidence contradicts earlier assumptions—always record original claim, reason for change, and downstream impact.

Is this method lightweight enough for routine tasks?

Yes. Apply implicitly for routine tasks so the process informs decisions without cluttering outputs; escalate to explicit sequences for high-complexity work.