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.
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
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/thinking-sequentially/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How thinking-sequentially Compares
| Feature / Agent | thinking-sequentially | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/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 stepsRelated Skills
A3criticalthinking
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
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
[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
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.
backend-patterns
Backend patterns for ORPC routers, Drizzle schemas, and server-side code. Use when creating API endpoints, database tables, or services.
backend-passport-js
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
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
专注于 Node.js 后端开发模式与最佳实践。
Backend Migrations
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
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
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
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.