Verified:GitHub

debugging-strategies

Guide systematic debugging through reproduction, evidence gathering, hypothesis formation, and verification.

2|Updated May 20, 2026

Search Tags:#debugging #root cause analysis #log analysis #performance profiling #breakpoints #production incident #memory leak detection

Ready to run

npx skills add https://github.com/Dianshu-Liao/SkilLGuard --skill debugging-strategies-dianshu-liao

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: debugging-strategies
Source: https://github.com/Dianshu-Liao/SkilLGuard/tree/main/data/skills/debugging-strategies
Command: npx skills add https://github.com/Dianshu-Liao/SkilLGuard --skill debugging-strategies-dianshu-liao

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and assets (resource) components.

What problem does it solve?

This Skill helps you systematically debug bugs, diagnose performance problems, and narrow down root causes without relying on guesswork or trial-and-error.

Core Features & Use Cases

Structured debugging workflow: Reproduce reliably, gather high-signal evidence, form hypotheses, and verify with targeted tests.
Cross-technology techniques: Applies to JavaScript/TypeScript, Python, Go, and general engineering workflows like Git bisect and differential debugging.
Tooling and patterns: Covers debugger tactics (breakpoints, tracing), logging approaches, profiling, memory leak detection, and production-safe investigation practices.
Issue-type playbooks: Provides strategies for intermittent bugs, performance regressions, and production incidents.

Quick Start

Use debugging-strategies to create a step-by-step plan to diagnose the cause of an intermittent failure in a web service, starting with reproduction and ending with a validated fix.

Frequently Asked Questions about debugging-strategies

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

FAQPage Schema

How do I find the root cause of an intermittent bug in a web service?▼

Systematically debug intermittent failures by guiding reliable reproduction, evidence gathering from logs, hypothesis formation, and verification with targeted tests to narrow down the root cause.

What is the best way to debug a memory leak across unfamiliar codebases?▼

Debug memory leaks in unfamiliar codebases by applying deterministic reasoning over profiling signals and tool-based evidence to narrow scope and confirm the root cause without guesswork.

How do I diagnose a performance regression using profiling and stack traces?▼

Diagnose performance regressions by analyzing profiling signals and stack traces, forming hypotheses based on environment diffs, and verifying the root cause through targeted tests.

Can I use this structured debugging workflow for production incidents in Python and Go?▼

Yes, this workflow applies to production incidents across Python, Go, JavaScript/TypeScript, and general engineering workflows, utilizing production-safe investigation practices and log analysis.

When should I use git bisect versus breakpoints for troubleshooting software issues?▼

Use git bisect for narrowing down regressions across commits and breakpoints for tracing execution flow and inspecting state, applying deterministic reasoning over evidence to confirm root causes.

Why does trial-and-error fail when debugging complex software issues?▼

Trial-and-error fails because it lacks deterministic reasoning over stack traces, environment diffs, and profiling signals, which are required to systematically narrow scope and confirm root causes.