Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
aidotnet avatar

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)
At a glance

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
From the docs

What think says it does

Deliberate reasoning skill: enforce multi-step analysis, hypothesis testing, and option evaluation before answering complex questions
SKILL.md
Brainstorm at least two distinct approaches, explanations, or solution paths.
SKILL.md
npx skills add https://github.com/aidotnet/opendeepwiki --skill think

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs1
repo stars3.5k
Last updatedJuly 24, 2026
Repositoryaidotnet/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

SKILL.mdMarkdownGitHub ↗

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.

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.