
Think
- 1 installs
- 3.5k repo stars
- Updated July 24, 2026
- aidotnet/opendeepwiki
think is a Claude Code skill that enforces multi-step analysis, hypothesis testing and option evaluation before answering complex questions.
About
think is a Claude Code skill that enforces deliberate, multi-step reasoning before answering complex questions. A developer or agent uses it for architecture decisions, root-cause investigations, product or policy trade-offs, and other multi-hop analytical work. It follows a five-step workflow of understanding the problem, generating hypotheses, analyzing and comparing, validating, and synthesizing a conclusion.
- Enforces a 5-step deliberate reasoning workflow before answering complex questions
- Requires generating and comparing at least two candidate hypotheses
- Wraps internal reasoning in <think> blocks and guards against confirmation bias
Think by the numbers
- 1 all-time installs (skills.sh)
- Ranked #2,479 of 3,282 Productivity & Planning skills by installs in the Skillselion catalog
- Data as of Aug 5, 2026 (Skillselion catalog sync)
think capabilities & compatibility
Free; a guidance-only reasoning skill with no dependencies.
- Capabilities
- deliberate reasoning · decision support · hypothesis testing · planning
- Use cases
- planning · research
- Pricing
- Free
What think says it does
Deliberate reasoning skill: enforce multi-step analysis, hypothesis testing, and option evaluation before answering complex questions
Brainstorm at least two distinct approaches, explanations, or solution paths.
npx skills add https://github.com/aidotnet/opendeepwiki --skill thinkAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 1 |
|---|---|
| repo stars | ★ 3.5k |
| Last updated | July 24, 2026 |
| Repository | aidotnet/opendeepwiki ↗ |
What it does
Enforce structured multi-step reasoning and hypothesis comparison before answering complex or high-stakes questions.
Who is it for?
Architecture, root-cause and decision questions that need careful reasoning and option comparison.
Skip if: Simple, single-step questions where deliberate multi-hop reasoning is unnecessary.
When should I use this skill?
A task requires careful judgment, non-trivial trade-offs or multi-hop reasoning.
What you get
A transparent, step-by-step reasoning trail ending in a compared recommendation with next steps.
- Structured reasoning trails
- Compared recommendations with next steps
By the numbers
- 5-step reasoning workflow
- at least 2 candidate hypotheses required
Files
Think — Deliberate Reasoning Skill
Use this skill whenever a task requires careful judgment, non-trivial trade-offs, or multi-hop reasoning. Follow the deliberate workflow before responding.
Reasoning Workflow
1. Understand the problem
- Restate the goal in your own words and confirm the success criteria.
- List known inputs, missing data, and explicit constraints.
- Flag ambiguities that must be resolved or acknowledged.
2. Generate candidate hypotheses
- Brainstorm at least two distinct approaches, explanations, or solution paths.
- Note the core assumption powering each option.
- Explain why each option could plausibly work and where it might fail.
3. Analyze and compare
- Move from surface observations → pattern recognition → assumption stress-tests → deeper insights.
- Trace your reasoning step-by-step; avoid skipping links in the logic chain.
- Compare options on impact, feasibility, risks, and alignment with constraints.
4. Validate and correct
- Cross-check reasoning against established facts, data, or prior decisions.
- Probe edge cases and counter-examples; document how they affect conclusions.
- If you spot a flaw, explicitly call it out (e.g., “Wait, that contradicts earlier data…”) and adjust.
5. Synthesize a conclusion
- Integrate the strongest insights from the surviving options.
- Summarize decisive evidence, trade-offs, and residual uncertainties.
- Deliver a recommendation with clear next steps or safeguards.
Guardrails and Principles
- Fight confirmation bias: actively look for evidence that disproves each hypothesis.
- Admit uncertainty: say “I’m not certain because…” instead of inventing facts.
- Stay scoped: solve the asked question first before exploring tangents.
- Expose assumptions: list foundational premises and revisit them as new facts emerge.
- Keep alternatives alive: do not converge on the first viable plan without comparison.
Output Format
Use structured markers to keep the reasoning transparent:
- “Let me restate the problem…” — comprehension
- “Here are the candidate paths…” — hypotheses/options
- “Digging into the analysis…” — step-by-step reasoning
- “Hold on, verify…” — validation or correction
- “Overall recommendation…” — final synthesis
Wrap the internal reasoning inside <think>...</think> blocks when possible so downstream tools can distinguish scratch work from the final answer.
When to Invoke
- Architecture, system design, or technology selection questions
- Root-cause investigations of complex bugs or incidents
- Product or policy decisions with competing constraints
- Multi-factor analytical questions (e.g., forecasting, prioritization)
- Any scenario demanding high precision or auditability
Related skills
FAQ
What is the think skill's workflow?
A five-step workflow: understand the problem, generate candidate hypotheses, analyze and compare, validate and correct, then synthesize a conclusion.
When should think be invoked?
For architecture and system-design choices, root-cause investigations, product or policy decisions, and other multi-factor analytical questions.