thinking-sequentially

AI agent structures complex reasoning through numbered thought sequences with explicit dependencies. Use when facing multi-step problems, complex debugging, or architectural decisions.

16 stars

Best use case

thinking-sequentially is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

AI agent structures complex reasoning through numbered thought sequences with explicit dependencies. Use when facing multi-step problems, complex debugging, or architectural decisions.

Teams using thinking-sequentially should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/thinking-sequentially/SKILL.md --create-dirs "https://raw.githubusercontent.com/diegosouzapw/awesome-omni-skill/main/skills/ai-agents/thinking-sequentially/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/thinking-sequentially/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How thinking-sequentially Compares

Feature / Agentthinking-sequentiallyStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

AI agent structures complex reasoning through numbered thought sequences with explicit dependencies. Use when facing multi-step problems, complex debugging, or architectural decisions.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# Thinking Sequentially

## Purpose

Structure complex reasoning through numbered thought sequences:

- Decompose multi-step problems into traceable chains
- Track dependencies between insights explicitly
- Create checkpoints for periodic review
- Enable revision when assumptions change
- Support parallel hypothesis exploration

## Quick Start

1. **Define** - State the problem clearly as THOUGHT 1
2. **Decompose** - Break into numbered thoughts with dependencies
3. **Track** - Mark dependencies explicitly: "depends on THOUGHT 2"
4. **Checkpoint** - Summarize every 5-10 thoughts
5. **Revise** - Update thoughts when assumptions change, invalidate dependents
6. **Branch** - Explore parallel hypotheses when needed

## Features

| Feature | Description | Guide |
|---------|-------------|-------|
| Numbered Chains | Explicit THOUGHT 1, 2, 3... with IDs | Number every insight, never skip |
| Dependencies | Mark what each thought relies on | `[THOUGHT 4] <- depends on [2, 3]` |
| Checkpoints | Periodic summaries of findings | Every 5-10 thoughts, list key findings |
| Revisions | Update previous thoughts with new data | Mark original as revised, create new |
| Branching | Explore multiple hypotheses in parallel | Create named branches, select winner |
| Visual Maps | Diagram thought relationships | ASCII diagrams for complex chains |

## Common Patterns

```
# Problem Analysis Pattern
THOUGHT 1: Problem statement
THOUGHT 2: Success criteria
THOUGHT 3: Constraints
THOUGHT 4: Assumptions (validate!)
THOUGHT 5-N: Solution exploration
=== CHECKPOINT ===

# Decision Making Pattern
THOUGHT 1: Decision to make
THOUGHT 2: Options identified
THOUGHT 3-N: Evaluate each option
THOUGHT N+1: Comparison matrix
THOUGHT N+2: Recommendation

# Investigation Pattern
THOUGHT 1: What we observed
THOUGHT 2: What we expected
THOUGHT 3: Gap analysis
THOUGHT 4-N: Hypothesis testing
=== CHECKPOINT: Root cause ===
```

```
# Visual thought mapping
        [THOUGHT 1: Problem]
               |
    +----------+----------+
    |                     |
[THOUGHT 2]         [THOUGHT 3]
    |                     |
    +----------+----------+
               |
        [THOUGHT 4: Synthesis]
```

## Use Cases

- Multi-step debugging requiring traceable reasoning chains
- Architectural decisions with complex trade-off analysis
- Code review requiring systematic examination of multiple concerns
- Root cause analysis with hypothesis tracking
- Complex refactoring requiring dependency-aware planning

## Best Practices

| Do | Avoid |
|----|-------|
| Number every thought explicitly | Skipping numbers for "obvious" thoughts |
| Mark dependencies clearly | Hiding dependencies in prose |
| Summarize at checkpoints | Exceeding 20 thoughts without checkpoint |
| Allow revision with reason | Deleting invalid thoughts (strike through) |
| Time-box each thought | Infinite exploration without bounds |
| Branch for parallel exploration | Branching more than 3 levels deep |
| Validate assumptions early | Proceeding with invalidated dependencies |

## Related Skills

See also these related skill documents for complementary techniques:

- **writing-plans** - Structure plans as numbered thought sequences
- **debugging-systematically** - Apply sequential debugging steps
- **tracing-root-causes** - Use numbered investigation chains
- **brainstorming-ideas** - Generate options in thought steps

Related Skills

A3criticalthinking

16
from diegosouzapw/awesome-omni-skill

Toyota-style A3 problem solving with embedded priority hierarchy: Safety First, then Customer Value, then Shareholder Value. Structured thinking framework for manufacturing decisions, root cause analysis, and countermeasure development. USE WHEN user says 'A3', 'problem solving', 'root cause', 'countermeasure', '5 whys', 'fishbone', 'ishikawa', 'priority decision', 'safety first', 'critical thinking', or needs structured analysis of manufacturing problems. Integrates with AutomotiveManufacturing and HoshinKanri skills.

sequentialthinking

16
from diegosouzapw/awesome-omni-skill

Use this skill for systematic problem-solving through structured, iterative thinking. Break down complex problems, iterate on understanding, catch edge cases, and validate solutions comprehensively.

sequential-thinking

16
from diegosouzapw/awesome-omni-skill

[Planning] 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.

bgo

10
from diegosouzapw/awesome-omni-skill

Automates the complete Blender build-go workflow, from building and packaging your extension/add-on to removing old versions, installing, enabling, and launching Blender for quick testing and iteration.

Coding & Development

backend-patterns

16
from diegosouzapw/awesome-omni-skill

Backend patterns for ORPC routers, Drizzle schemas, and server-side code. Use when creating API endpoints, database tables, or services.

backend-passport-js

16
from diegosouzapw/awesome-omni-skill

Authentication middleware for Express.js and Node.js applications. Use when building Express APIs that need JWT authentication, OAuth, or custom auth strategies. Provides 500+ authentication strategies. Choose Passport.js over Auth.js for Express backends, pure API servers, or when you need maximum control over auth flow.

backend-nodejs

16
from diegosouzapw/awesome-omni-skill

Node.js/TypeScript backend expert. Handles Express/Fastify API routes, TypeScript strict mode, Prisma ORM, Zod validation, error handling, configuration management. Use when project is Node.js backend (package.json + TypeScript server).

Backend Node.js Expert

16
from diegosouzapw/awesome-omni-skill

专注于 Node.js 后端开发模式与最佳实践。

Backend Migrations

16
from diegosouzapw/awesome-omni-skill

Create and manage database schema migrations with reversible operations, zero-downtime deployments, and safe rollback strategies. Use this skill when writing database migrations for PostgreSQL, MySQL, SQLite, MongoDB, or any database system; when using ORMs like Prisma, Sequelize, TypeORM, ActiveRecord, Django ORM, or similar migration tools; when implementing schema changes (adding tables, columns, indexes, constraints); when performing data migrations or transformations; when creating indexes on large tables with concurrent options to avoid locks; when separating schema changes from data migrations for safer rollbacks; when implementing zero-downtime deployment strategies for high-availability systems; when versioning database schemas and managing migration order; or when working with database change management in production environments.

backend

16
from diegosouzapw/awesome-omni-skill

Skill para diseñar y construir backends y APIs **modulares**, **auditables**, **resilientes** y **multi-tenant**, con seguridad fuerte, modelado correcto (incl. ledger cuando aplique), datos y jobs/colas operables.

backend-guidelines

16
from diegosouzapw/awesome-omni-skill

Comprehensive backend development guide for Node.js/Express/TypeScript microservices. Use when creating routes, controllers, services, repositories, middleware, or working with Express APIs, Prisma database access, Sentry error tracking, Zod validation, unifiedConfig, dependency injection, or async patterns. Covers layered architecture (routes → controllers → services → repositories), BaseController pattern, error handling, performance monitoring, testing strategies, and migration from legacy patterns.

backend-guide

16
from diegosouzapw/awesome-omni-skill

Complete backend development guide covering Node.js, Python, Go, Java, PHP, databases, APIs, authentication, and server architecture. Use when building server applications, APIs, or backend systems.