skills.rest
KILWA73
KILWA73COMMUNITY
Explore all skills by this author →
GitHub

debug-solver

Diagnose bugs and performance issues through structured root-cause analysis.

Updated Apr 12, 2026
Search Tags:#architecture#debugging#algorithm#problem-solving#code-analysis#root-cause#stack-trace
One-click install
npx skills add https://github.com/KILWA73/MiniSoc --skill debug-solver
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: debug-solver
Source: https://github.com/KILWA73/MiniSoc/tree/main/.agents/skills/debug-solver
Command: npx skills add https://github.com/KILWA73/MiniSoc --skill debug-solver

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill helps engineers accurately diagnose and resolve bugs, performance issues, and design questions by extracting the real problem, identifying root causes, and guiding through structured, repeatable debugging processes.

Core Features & Use Cases

  • Structured problem understanding: restate the user's issue, surface hidden assumptions, and clarify constraints.
  • Root-cause analysis & solution ranking: identify root patterns, generate multiple approaches, and rank them.
  • Code-level fixes & verification: propose concrete code changes, create test cases, and validate with reasoning.
  • Comprehensive edge-case handling: consider invalid inputs, race conditions, and environment differences across runtimes.
  • Use Case: when a developer asks "my code is broken" or "it's slow", this skill guides to the underlying cause and actionable remedies.

Quick Start

Describe the bug report or code snippet and ask me to diagnose the root cause and propose an actionable fix.

Frequently Asked Questions about debug-solver

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I find the root cause of a bug from a stack trace?▼

To find the root cause of a bug from a stack trace, you systematically analyze the error to identify underlying patterns, restate the problem to surface hidden assumptions, and generate ranked solutions for actionable code-level fixes.

What is the best way to diagnose performance issues across different runtime environments?▼

Diagnosing performance issues across runtime environments involves structured problem understanding to clarify constraints, root-cause analysis to identify bottlenecks, and comprehensive edge-case testing to handle environment differences and race conditions.

How do I debug algorithm problems and handle invalid inputs?▼

Debugging algorithm problems and handling invalid inputs requires systematically restating the issue, proposing concrete code changes, and validating the logic with test cases that specifically target edge cases and invalid input scenarios.

Can I use systematic problem-solving for architecture decisions and design flaws?▼

Yes, systematic problem-solving applies to architecture decisions by extracting the real design problem, identifying root patterns in the architecture, and guiding you through structured analysis to generate and rank multiple architectural approaches.

Why does my code still fail after applying an initial bug fix?▼

Code still fails after an initial bug fix when hidden assumptions are missed or edge cases like race conditions are ignored; structured root-cause analysis surfaces these underlying patterns to propose robust, verified code-level fixes.

Related Skills

Explore More Software Engineering Skills→
jk278jk278

debugging-assistant

Diagnose software bugs from stack traces and error logs.

Community
Advanced
thrawn01thrawn01
11

bug-detector

Analyze code to identify bugs, logic errors, and edge-case issues.

Community
Intermediate
dakshrawat298-gifdakshrawat298-gif

security-fix-review

Review security patches for root-cause coverage and bypass risks.

Community
Intermediate
beomeodevbeomeodev

ms-essentials-debug

Diagnose and fix My-Spec runtime errors with stack trace analysis and root-cause investigation.

Community
Advanced