ck:sequential-thinking

Decompose complex problems into sequenced, revisable thoughts with branching support.

Updated Apr 2, 2026
One-click install
npx skills add https://github.com/hidonguyen/trade-ops --skill ck-sequential-thinking-hidonguyen
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ck:sequential-thinking
Source: https://github.com/hidonguyen/trade-ops/tree/main/.opencode/skills/sequential-thinking
Command: npx skills add https://github.com/hidonguyen/trade-ops --skill ck-sequential-thinking-hidonguyen

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This skill provides a structured methodology for decomposing complex, ambiguous, or multi-step problems into a sequence of discrete, verifiable thoughts. It reduces errors from leaps of logic, enables explicit revisions and branching, and makes hypothesis generation and verification auditable and repeatable.

Core Features & Use Cases

  • Thought Sequencing & Revision: Create numbered thoughts, mark revisions, record why a revision occurred, and assess downstream impact.
  • Branching & Hypothesis Testing: Explore alternative approaches in parallel, compare outcomes, and converge on a decision with explicit rationale.
  • CLI Utilities & Persistence: Optional scripts validate thought structure, format outputs for display, and persist a local thought history for deterministic workflows.
  • Use Case: Walk through debugging a slow API endpoint step-by-step, generate hypotheses, verify with profiling, and record revisions until the root cause is confirmed.

Quick Start

Use the sequential-thinking skill to decompose the problem "investigate slow API endpoint" into five thoughts and verify each step.

Frequently Asked Questions about ck:sequential-thinking

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I break down complex debugging problems into verifiable steps?

Step-by-step analysis decomposes complex debugging problems into a sequence of discrete, verifiable thoughts. You create numbered thoughts, mark revisions, and assess downstream impact to reduce errors from leaps of logic and make hypothesis verification auditable.

What is sequential thinking for problem solving and when should I use it?

Sequential thinking is a structured methodology for decomposing ambiguous, multi-step problems into discrete, revisable thoughts. Use it for architecture decisions, adaptive planning, and hypothesis testing where progressive refinement and explicit branching are needed to reach a decision.

Can I explore alternative approaches and branch my reasoning during analysis?

Yes, branching and hypothesis testing support allows you to explore alternative approaches in parallel. You can compare outcomes across branches and converge on a decision with explicit rationale rather than committing to a single linear path.

How do I track and persist thought history for deterministic workflows?

Thought history is persisted locally using CLI utilities that validate thought structure and format outputs for display. This local persistence ensures workflows remain deterministic and auditable without requiring external network access.

Does this problem-solving methodology require external network access or dependencies?

No external network access or dependencies are required. The skill operates entirely offline using local scripts and references to validate thought sequences, format outputs, and persist history locally.

What's the best way to revise an earlier thought without losing the reasoning context?

Mark revisions explicitly and record why a revision occurred, then assess downstream impact on subsequent thoughts. This approach maintains full reasoning context by preserving the original thought history while tracking progressive refinement.