New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Problem Solving Pro

by HoangTheQuyen in HoangTheQuyen/think-better

Systematic problem-solving toolkit: root cause analysis, hypothesis testing, debugging strategies, critical thinking frameworks.

MITAuto-check: notesDevelopment

Install Problem Solving Pro

skills CLI
$ npx skills add HoangTheQuyen/think-better --skill problem-solving-pro -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install HoangTheQuyen/think-better problem-solving-pro --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/HoangTheQuyen/think-better.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/problem-solving-pro .claude/skills/problem-solving-pro && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
problem-solving-pro
GitHub stars
123
Token cost
~2.8k tokens
SKILL.md length
1,192 words
Files
15 (incl. scripts)
Skills in repo
2
Repo updated
First seen
Licence
MIT

At a glance

Systematic problem-solving toolkit: root cause analysis, hypothesis testing, debugging strategies, critical thinking frameworks.

  • Works in 8 steps: Understand the Problem → Generate Problem-Solving Plan (REQUIRED) → Deep-Dive Domain Searches → …
  • User says solve
  • SKILL.md covers Prerequisites, How to Use This Workflow, Search Reference and Example Workflow, plus 4 more sections
  • Runs Python scripts from its folder; calls python3, python and apt

What it does

Problem Solving Pro is an agent skill from HoangTheQuyen/think-better. Systematic problem-solving toolkit: root cause analysis, hypothesis testing, debugging strategies, critical thinking frameworks. Use when user says "solve", "analyze", "diagnose", "debug", "figure out", "what's wrong", "root cause", "why is this happening", "I'm stuck", "break down", "decompose", "structure", "tại sao bị vậy", "tìm nguyên nhân", "phân tích", "giải quyết", "bị kẹt", "không biết làm sao", or describes any problem that needs structured decomposition.

Its SKILL.md is about 2.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 16 other files, including scripts (for example `PROMPT.md`, `scripts/advisor.py` and `scripts/core.py`).

It sits in Development, covering Root cause analysis and Debugging. It works with Python. The repository describes itself as: The Operating System for Clear Thinking & Better Decisions. The licence is MIT.

When your agent uses it

  • User says solve
  • Why is this happening
  • Tìm nguyên nhân
  • Không biết làm sao

Example prompts

  • “analyze”
  • “diagnose”
  • “figure out”
  • “/problem-solving-pro”

Requirements

  • Python 3

Workflow steps

8 steps, taken from the step headings in SKILL.md.

  1. Understand the Problem
  2. Generate Problem-Solving Plan (REQUIRED)
  3. Deep-Dive Domain Searches
  4. Apply the Framework
  5. Understand the Problem
  6. Generate Problem-Solving Plan (REQUIRED)
  7. Deep-Dive Searches
  8. Apply the Framework

What it can do on your machine

Read from SKILL.md and the folder at commit 472b37d. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 3 files in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • python3
    • python
    • apt
    • brew
    • winget

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Problem Solving Pro loads about 2.8k tokens when it runs. Until then it costs about 122 tokens; SKILL.md has 1,192 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~122
When it runs · the whole SKILL.md, loaded when a task matches
~2.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteRuns commands with sudoSKILL.md:39
    sudo apt update && sudo apt install python3

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from HoangTheQuyen/think-better at commit 472b37d, republished under its MIT licence (© HoangTheQuyen). 1,192 words, ~2,809 tokens.

Download SKILL.mdSave it as .claude/skills/problem-solving-pro/SKILL.md (or your agent's skills folder). This skill also uses 14 other files; get the full folder from GitHub.
name
problem-solving-pro
description
Systematic problem-solving toolkit: root cause analysis, hypothesis testing, debugging strategies, critical thinking frameworks. Use when user says "solve", "analyze", "diagnose", "debug", "figure out", "what's wrong", "root cause", "why is this happening", "I'm stuck", "break down", "decompose", "structure", "tại sao bị vậy", "tìm nguyên nhân", "phân tích", "giải quyết", "bị kẹt", "không biết làm sao", or describes any problem that needs structured decomposition.

Goal

Help users solve complex problems systematically using proven frameworks — turning vague issues into structured analyses with actionable recommendations.

problem-solving-pro

Comprehensive structured problem-solving framework for tackling any complex challenge. Contains a 7-step methodology, 15 decomposition frameworks, 8 prioritization techniques, 12 analysis tools, 12 cognitive biases with debiasing strategies, 10 communication patterns, 12 mental models, and 10 team dynamics patterns. Searchable database with reasoning-based recommendations that adapts to your specific problem type.

Prerequisites

IMPORTANT: Detect the correct Python command first. Some systems use python3, others use python. Run:

bash
python3 --version 2>/dev/null || python --version

Use whichever command succeeds (python3 or python) for ALL script calls below. If the system only has python (common on Windows), substitute python everywhere you see python3 in this document.

If Python is not installed at all, install it based on user's OS:

macOS:

bash
brew install python3

Ubuntu/Debian:

bash
sudo apt update && sudo apt install python3

Windows:

powershell
winget install Python.Python.3.12

Note: On Windows, Python 3 is typically available as python (not python3).

How to Use This Workflow

When user requests problem-solving help (analyze, solve, diagnose, decide, structure, decompose, plan, strategy, recommendation), follow this workflow:

Step 1: Understand the Problem

Extract key information from user's problem description:

  • Problem type: Business performance, market entry, organizational change, product, cost reduction, innovation, crisis, data/analytics, partnership/M&A, policy
  • Complexity: Well-structured, ill-structured, wicked
  • Keywords: revenue, growth, decline, entry, change, innovation, cost, crisis, etc.
  • Context: Industry, scale, time pressure, stakeholder dynamics
Step 2: Generate Problem-Solving Plan (REQUIRED)

Always start with --plan to get comprehensive recommendations with reasoning:

bash
python3 scripts/search.py "<problem_description>" --plan [-p "Project Name"]

This command:

  1. Classifies the problem type automatically
  2. Searches across all 9 knowledge domains in parallel
  3. Applies reasoning rules to select best frameworks and tools
  4. Returns a complete solving plan: methodology, decomposition, analysis, communication, mental models, bias warnings
  5. Includes anti-patterns to avoid and a problem-solving checklist

Example:

bash
python3 scripts/search.py "revenue declining 20% despite market growth" --plan -p "Revenue Recovery"
Step 2b: Persist Problem-Solving Plan

To save the plan for reference:

bash
python3 scripts/search.py "<problem>" --plan --persist -p "Project Name"

This creates:

  • solving-plans/project-name/PLAN.md — Complete problem-solving plan
Step 3: Deep-Dive Domain Searches

Use when the plan's recommendation needs more detail, OR when user asks about a specific topic (e.g., "how do I do a root cause analysis?"):

bash
python3 scripts/search.py "<keyword>" --domain <domain> [-n <max_results>]

When to use domain searches:

NeedDomainExample
Understand the methodology stepssteps--domain steps "define problem"
Classify the problemproblem-types--domain problem-types "wicked systemic"
Choose decomposition frameworkdecomposition--domain decomposition "MECE logic tree"
Pick prioritization techniqueprioritization--domain prioritization "impact feasibility"
Select analysis toolsanalysis--domain analysis "root cause benchmark"
Identify cognitive biasesbiases--domain biases "confirmation anchoring"
Structure communicationcommunication--domain communication "pyramid executive"
Apply mental modelsheuristics--domain heuristics "first principles inversion"
Improve team dynamicsteam--domain team "red team brainstorm"
Step 4: Apply the Framework

Guide the user through the recommended process:

  1. Define: Help craft a precise problem statement
  2. Decompose: Build the recommended logic tree (MECE)
  3. Prioritize: Apply 80/20 to focus on what matters
  4. Plan: Design specific analyses for priority issues
  5. Analyze: Guide data gathering and hypothesis testing
  6. Synthesize: Extract 'so what' insights and build the argument
  7. Communicate: Structure the recommendation for the audience

Search Reference

Available Domains
DomainRecordsUse ForExample Keywords
steps7Understanding each step of the methodologydefine, disaggregate, prioritize, analyze, synthesize, communicate
problem-types8Classifying the type of problemdiagnostic, opportunity, wicked, prediction, negotiation, design
decomposition10Choosing how to break down the problemissue tree, hypothesis tree, MECE, profitability, process, scenario
prioritization8Deciding where to focus effortpareto, impact-feasibility, sensitivity, dot-voting, MoSCoW, weighted
analysis12Selecting analytical methodsbenchmark, root cause, regression, scenario, fermi, A/B test, pre-mortem
biases12Identifying thinking errors to avoidconfirmation, anchoring, sunk cost, groupthink, overconfidence, framing
communication10Structuring findings and recommendationspyramid, SCR, action titles, BLUF, one-page, storytelling, day-1 answer
heuristics12Applying mental models to the problemfirst principles, inversion, second-order, Bayesian, Occam, leverage
team10Improving team problem-solving effectivenessred team, brainstorm, psychological safety, hypothesis-driven, workplan

Example Workflow

User request: "Our company's revenue has declined 20% this year despite the market growing. Help me figure out what's going on and what to do about it."

Step 1: Understand the Problem
  • Problem type: Business Performance / Diagnostic
  • Complexity: Ill-structured (multiple potential causes)
  • Keywords: revenue, decline, market growth, performance gap
  • Context: Company underperforming vs market
Step 2: Generate Problem-Solving Plan (REQUIRED)
bash
python3 scripts/search.py "revenue declining 20% despite market growth" --plan -p "Revenue Diagnosis"

Output: Complete plan with profitability tree decomposition, Pareto prioritization, benchmarking + root cause analysis toolkit, pyramid principle communication, and bias warnings (confirmation bias, anchoring).

Step 3: Deep-Dive Searches
bash
# Get decomposition framework details
python3 scripts/search.py "profitability revenue cost" --domain decomposition

# Get root cause analysis methodology
python3 scripts/search.py "root cause 5 whys diagnostic" --domain analysis

# Check for relevant biases
python3 scripts/search.py "confirmation bias anchoring" --domain biases
Show full SKILL.md (480 more words)Show less
Step 4: Apply the Framework

Walk the user through:

  1. Define: "Revenue declined 20% YoY (vs market +5%) — identify root drivers and recommend recovery actions within 90 days"
  2. Decompose: Profitability tree → Revenue (Price × Volume) → Costs (Fixed + Variable)
  3. Prioritize: Which branches explain >80% of the decline?
  4. Analyze: Benchmark against competitors, test hypotheses on each priority branch
  5. Synthesize: Group findings into themes, extract 'so what' for each
  6. Communicate: Start with the recommendation (pyramid), support with evidence

Then: Synthesize the plan + domain searches into a structured problem-solving approach for the user.

Output Formats

The --plan flag supports two output formats:

bash
# ASCII box (default) - best for terminal display
python3 scripts/search.py "market entry strategy" --plan

# Markdown - best for documentation
python3 scripts/search.py "market entry strategy" --plan -f markdown

Key Principles

  1. Start with the problem, not the solution — Invest time in defining and framing before solving
  2. Disaggregate before analyzing — Break it down MECE before diving into any branch
  3. Prioritize ruthlessly — 80/20: focus on the vital few issues that drive the answer
  4. Be hypothesis-driven — State your best guess early, then test it (Day 1 Answer)
  5. So what? — Every finding must pass the 'so what' test to matter
  6. Answer first — Lead with the recommendation, support with evidence (Pyramid Principle)
  7. Watch for biases — Confirmation bias, anchoring, and groupthink are the most dangerous
  8. Iterate — Update your answer as evidence comes in (Bayesian updating)
  9. Simple first — Use the simplest analysis that answers the question (Occam's Razor)
  10. Communication is the final product — The best analysis is worthless if you can't drive action
  11. What you'd have to believe — When stuck or attached to an idea, ask "what would have to be true for this to be the right answer?" to break framing ruts and rigorously test assumptions.

Constraints

  • Always start with Step 2 (--plan) before doing domain searches — the plan provides context for everything else
  • Problem statement must be specific — reject vague statements; ask for measurable outcomes
  • Keep the logic tree to 3 levels max — deeper than 3 loses clarity
  • Limit to top 3 priority branches — 80/20 rule; don't analyze everything
  • When user is vague, ask — if the problem type is unclear, ask: "What would success look like?" before running the plan

Error Handling

If the Python scripts fail or are unavailable:

  1. Check Python: Run python3 --version or python --version — if neither is found, guide the user to install it
  2. Manual fallback: If scripts cannot run, apply the Key Principles above manually:
    • Ask the user to describe the problem → classify the type yourself
    • Suggest a decomposition framework (e.g., Issue Tree for diagnostic, Hypothesis Tree for uncertain causes)
    • Walk through the 7-step methodology: Define → Decompose → Prioritize → Plan → Analyze → Synthesize → Communicate
    • Warn about the 3 most common biases for that problem type
  3. Script errors: If search.py returns no results, try broader keywords or search a different domain
  4. Non-English queries: The knowledge base is English-only. Translate the user's key terms to English before calling search.py — this ensures rich results for any language

© HoangTheQuyen, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 14 other files (scripts) in .agents/skills/problem-solving-pro of HoangTheQuyen/think-better.

  • SKILL.md
  • PROMPT.md
  • data/analysis-tools.csv
  • data/cognitive-biases.csv
  • data/communication.csv
  • data/decomposition.csv
  • data/heuristics.csv
  • data/prioritization.csv
  • data/problem-types.csv
  • data/reasoning.csv
  • data/steps.csv
  • data/team-dynamics.csv
  • scripts/advisor.py
  • scripts/core.py
  • scripts/search.py

Open the folder on GitHubat commit 472b37d

Compare with similar skills

Problem Solving Pro next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Problem Solving Pro compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Problem Solving Pro this skillHoangTheQuyen/think-better123—~2.8kAutomated safety check: NotesMIT
The Art of Debuggingstas00/the-art-of-debugging1.7k—~6.1kAutomated safety check: NotesCC-BY-SA-4.0
Bug DetectiveGalaxy-Dawn/claude-scholar5.7k1 repos~2.1kAutomated safety check: PassMIT
Flowfile Debugging PlaybookEdwardvaneechoud/Flowfile373—~6.3kAutomated safety check: PassMIT
Debug Like Expertglittercowboy/taches-cc-resources2k—~2.8kAutomated safety check: PassMIT
Runtime Error ExplainerArabelaTso/Skills-4-SE253—~4.8kAutomated safety check: PassApache-2.0

Similar skills

  • The Art of Debugging

    stas00/the-art-of-debugging

    Condensed debugging method and tool recipes for Unix, Python and PyTorch programs: crashes, hangs, segfaults, wrong output, CUDA OOM, NaN values and slowness.

    1.7k GitHub stars~6.1k tokensUpdated 2 days ago
    DevelopmentAuto-check: notes

  • Bug Detective

    Galaxy-Dawn/claude-scholar

    Applies a systematic debugging workflow to errors, exceptions and failures, with error-type tables, localization techniques and reference notes for Python, JavaScript and shell.

    5.7k GitHub starsUsed in 1 repo~2.1k tokens
    DevelopmentAuto-check passed

  • Flowfile Debugging Playbook

    Edwardvaneechoud/Flowfile

    Symptom-to-cause triage playbook for Flowfile (core/worker/kernel/frontend/AI) — covers "no such table" DB cascades (two distinct causes), import-time Alembic migration corruption, silent…

    373 GitHub stars~6.3k tokensUpdated today
    DevelopmentAuto-check passed

  • Debug Like Expert

    glittercowboy/taches-cc-resources

    Deep analysis debugging mode for complex issues. An agent skill from glittercowboy/taches-cc-resources.

    2k GitHub stars~2.8k tokensUpdated 6 mo ago
    DevelopmentAuto-check passed

  • Runtime Error Explainer

    ArabelaTso/Skills-4-SE

    Explains runtime errors and compilation failures with actionable debugging guidance.

    253 GitHub stars~4.8k tokensUpdated 1 mo ago
    DevelopmentAuto-check passed

  • Debugging Mwaa Workflow

    aws/agent-toolkit-for-aws

    Official

    Diagnoses and root-causes Amazon MWAA workflow failures across Provisioned (Python DAG) and Serverless (YAML workflow) environments.

    2.8k GitHub stars~2.3k tokensUpdated yesterday
    Backend & APIsAuto-check passed

More from HoangTheQuyen/think-better

  • Make Decision

    HoangTheQuyen/think-better

    AI-powered decision-making framework: 10+ methodologies, cognitive bias detection, strategic planning, career & business decisions.

    123 GitHub stars~2.7k tokensUpdated 6 mo ago
    Auto-check: notes

Works with

Categories

Questions about Problem Solving Pro

What does Problem Solving Pro do?

Systematic problem-solving toolkit: root cause analysis, hypothesis testing, debugging strategies, critical thinking frameworks. Problem Solving Pro is an agent skill from HoangTheQuyen/think-better. Systematic problem-solving toolkit: root cause analysis, hypothesis testing, debugging strategies, critical thinking frameworks.

When should I use Problem Solving Pro?

Problem Solving Pro fits situations like: user says solve; why is this happening; Tìm nguyên nhân; không biết làm sao.

How do I install Problem Solving Pro in Claude Code?

Run `npx skills add HoangTheQuyen/think-better --skill problem-solving-pro -a claude-code`. Or copy the skill folder (.agents/skills/problem-solving-pro in HoangTheQuyen/think-better) into .claude/skills/problem-solving-pro in your project. Claude Code loads it when a task matches its description.

How do I install Problem Solving Pro in Codex?

Run `npx skills add HoangTheQuyen/think-better --skill problem-solving-pro -a codex`. Or copy the skill folder (.agents/skills/problem-solving-pro in HoangTheQuyen/think-better) into .agents/skills/problem-solving-pro in your project. Codex loads it when a task matches its description.

Can I use Problem Solving Pro in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add HoangTheQuyen/think-better --skill problem-solving-pro -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/problem-solving-pro, .gemini/skills/problem-solving-pro, .github/skills/problem-solving-pro and .opencode/skills/problem-solving-pro in your project.

What does Problem Solving Pro need to run?

Going by SKILL.md and its folder, Problem Solving Pro needs Python for the scripts in its folder and the command-line tools its instructions call (python3, python, apt, brew and winget). Our summary lists: Python 3.

Does Problem Solving Pro access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Problem Solving Pro safe to install?

Our automated static check of SKILL.md found notes only (runs commands with sudo), nothing it rates as a warning. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Problem Solving Pro use?

Problem Solving Pro is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Problem Solving Pro use?

About 2.8k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Problem Solving Pro?

Skills that share tags, products or a category with Problem Solving Pro: The Art of Debugging (stas00/the-art-of-debugging, 1.7k stars), Bug Detective (Galaxy-Dawn/claude-scholar, 5.7k stars), Flowfile Debugging Playbook (Edwardvaneechoud/Flowfile, 373 stars) and Debug Like Expert (glittercowboy/taches-cc-resources, 2k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Problem Solving Pro?

HoangTheQuyen (a GitHub user) maintains it in HoangTheQuyen/think-better, which has 123 GitHub stars. The repository holds 2 skills in this directory. The repository was last updated on April 5, 2026.

Source: HoangTheQuyen/think-better on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.