sequential-thinking

Break down complex problems into iterative reasoning steps with revision and branching.

Updated Aug 23, 2026

Search Tags:#planning #problem solving #branching #decomposition #reasoning #iterative

Ready to run

npx skills add https://github.com/roaming-rockenfels/ghostfolio --skill sequential-thinking-roaming-rockenfels

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: sequential-thinking
Source: https://github.com/roaming-rockenfels/ghostfolio/tree/main/.agents/skills/sequential-thinking
Command: npx skills add https://github.com/roaming-rockenfels/ghostfolio --skill sequential-thinking-roaming-rockenfels

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a structured approach to tackle complex problems by breaking them down into sequential, iterative steps, allowing for revision and exploration of alternative paths.

Core Features & Use Cases

Iterative Reasoning: Deconstruct complex challenges into manageable thought processes.
Dynamic Scope Adjustment: Adapt the estimated effort as understanding evolves.
Revision and Branching: Revisit and refine previous conclusions or explore alternative solutions.
Use Case: When designing a new software feature, use this Skill to outline the requirements, brainstorm different architectural approaches, and then refine the chosen path through iterative steps.

Quick Start

Use the sequential-thinking skill to break down the problem of optimizing database queries, starting with identifying potential bottlenecks.

Frequently Asked Questions about sequential-thinking

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

FAQPage Schema

How do I break down complex software problems into manageable steps?▼

Decomposing complex software problems requires systematic step-by-step reasoning to break challenges into iterative thought processes. This method allows dynamic scope adjustment and revision tracking to navigate unclear project boundaries.

What is the best way to explore alternative architectural approaches during software design?▼

Exploring alternative architectural approaches uses branching capabilities to investigate multiple solution paths simultaneously. This method allows you to revisit and refine previous conclusions while maintaining the overall design context.

Can I adjust the scope of my analysis dynamically as my understanding of a problem evolves?▼

Yes, dynamic scope adjustment is supported to adapt estimated effort as your understanding evolves. You can modify the problem decomposition parameters during step-by-step reasoning without losing previously established context.

How do I refine previous conclusions when a chosen software design path proves ineffective?▼

Refining previous conclusions requires revision tracking to revisit and correct earlier steps in your analysis. You can explore alternative approaches through branching while preserving the reasoning context established in prior stages.

When should I use iterative reasoning for problem decomposition instead of direct execution?▼

Iterative reasoning for problem decomposition is necessary when encountering unclear scope, multi-stage analysis requirements, or when alternative approaches need exploration. It provides dynamic revision tracking that direct execution methods lack.