event4u-app sequential-thinking
When to use
Use this skill when:
- A problem requires multiple interconnected reasoning steps
- The initial scope or approach is uncertain
- You need to filter through complexity to find core issues
- You may need to backtrack or revise earlier conclusions
- You want to explore alternative solution paths
- A decision has significant consequences and needs careful analysis
Do NOT use for:
- Simple queries with direct answers
- Single-step tasks
- Well-understood, routine operations
Core capabilities
Iterative reasoning
Break complex problems into sequential thought steps. Each step builds on previous ones but can also question or revise them.
Dynamic scope
Start with an estimate of needed steps, but adjust as understanding evolves. Don't commit to a fixed plan — let the analysis guide the depth.
Revision tracking
When new information contradicts an earlier conclusion:
- Acknowledge the contradiction explicitly.
- Identify which earlier step needs revision.
- Revise the conclusion with the new evidence.
- Propagate the change to all dependent steps.
Branch exploration
When multiple approaches seem viable:
- Identify the decision point.
- Explore each branch briefly (2-3 steps).
- Compare outcomes and tradeoffs.
- Choose the best path with reasoning.
- Document why alternatives were rejected.
Procedure: Sequential thinking
Step 1: Frame the problem
- What exactly needs to be solved?
- What are the constraints?
- What does success look like?
- What information is missing?
Step 2: Decompose
- Break into independent sub-problems where possible.
- Identify dependencies between sub-problems.
- Order by dependency (solve prerequisites first).
Step 3: Solve iteratively
For each sub-problem:
- Analyze — What do we know? What do we need?
- Hypothesize — What's the most likely solution?
- Verify — Does the hypothesis hold against evidence?
- Conclude or Revise — Accept or go back to step 1.
Step 4: Synthesize
- Combine sub-problem solutions into the overall answer.
- Check for contradictions between sub-solutions.
- Verify the combined solution against the original problem.
Step 5: Validate
- Does the solution actually solve the stated problem?
- Are there edge cases not covered?
- Is the solution proportional to the problem (not over-engineered)?
When to revise
Revise earlier thinking when:
- New evidence contradicts a previous assumption.
- A sub-problem solution doesn't fit the overall picture.
- The user provides new information that changes the context.
- You realize you were solving the wrong problem.
When to branch
Explore alternatives when:
- Two approaches seem equally viable.
- The stakes are high (architecture decisions, data migrations).
- The user asks "what if we did X instead?"
- The first approach hits a dead end.
Integration with other skills
- bug-analyzer — Use sequential thinking for complex root cause analysis.
- feature-planning — Use for architecture decision exploration (Phase 4).
- technical-specification — Use for evaluating alternatives in specs.
- refactorer — Use for planning multi-step refactoring safely.
Anti-patterns
| Anti-pattern | Problem | Fix |
|---|---|---|
| Premature conclusion | Jumping to a solution without analysis | Complete at least Steps 1-3 first |
| Analysis paralysis | Endless exploration without deciding | Set a step limit, then decide |
| Ignoring contradictions | Pushing forward despite conflicting evidence | Stop and revise |
| Linear-only thinking | Never considering alternatives | Branch at key decision points |
| Scope creep | Problem keeps expanding during analysis | Re-frame and constrain |
Output format
- Numbered reasoning steps with conclusions
- Final answer or recommendation with confidence level
Tool availability — this is a procedure, not a tool call
Everything above runs in-session: it is a way of structuring reasoning, and it needs nothing installed.
The wider MCP ecosystem carries a sequentialthinking server exposing a tool of
that name. This package registers no MCP server — mcp.json ships
{"servers": {}} — so on a default install that tool is not present, and
nothing here tries to call it. Registering one is a consumer-side install
decision this package deliberately does not make for you.
So a reader on a default install can answer the question directly: the tool is not available to you, and none of this skill depends on it. If you have registered such a server yourself, the once-per-task limit below governs that call too — the limit is about looping, not about which mechanism does the thinking.
Gotcha
- Don't use sequential thinking for simple tasks — it adds latency without value.
- The model tends to generate too many thoughts — cap at 10 unless the problem truly needs more.
- Each thought should build on the previous one — avoid restating the same point in different words.
Do NOT
- Do NOT use this for simple, well-understood tasks — it adds unnecessary overhead.
- Do NOT run this procedure more than once per task. If you are reaching for it repeatedly, you are looping — stop and act directly instead.
- Do NOT use it as a "thinking proxy" — if the task is "view a file" or "run a command", just do it. No thinking step needed.
- Do NOT skip the validation step — always check the solution against the original problem.
- Do NOT ignore contradictions — they are signals, not noise.
- Do NOT commit to a fixed number of steps upfront — let the problem guide the depth.
References
- Chain-of-Thought (CoT) — arxiv.org/abs/2201.11903 Step-by-step reasoning improves complex problem solving in large language models. This skill constrains CoT by capping the number of thoughts and enforcing a validation step — avoids the common failure mode of unbounded chain expansion.