systematic-debugging

Trace data flows from symptom to source to diagnose root causes.

4|Updated Mar 15, 2024
One-click install
npx skills add https://github.com/izyanrajwani/agent-skills-library --skill systematic-debugging-izyanrajwani
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/izyanrajwani/agent-skills-library/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/izyanrajwani/agent-skills-library --skill systematic-debugging-izyanrajwani

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

Root-cause analysis for debugging. Use when bugs, test failures, or unexpected behavior have non-obvious causes, or after multiple fix attempts have failed.

Core Features & Use Cases

  • Systematic approach to debugging across multi-component systems, guiding users through error messages, reproductions, and data-flow tracing.
  • Four-phase framework (root cause investigation, pattern analysis, hypothesis testing, implementation) with escalation for persistent issues.
  • Reference techniques and supporting materials in references/ to help trace data flow and add defense-in-depth instrumentation.

Quick Start

Describe the failing symptom, then trace the data flow to the source using the four phases, and apply defense-in-depth checks before implementing a fix.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
How do I find the root cause of a bug after multiple fix attempts have failed?

Root-cause debugging traces data flows from the observed symptom back to the source using a four-phase process: investigation, pattern analysis, hypothesis testing, and implementation. It enforces defense-in-depth validation and structured evidence gathering to ensure fixes address the actual origin.

What is the best way to debug flaky behavior and failing tests across multi-component systems?

Debugging flaky behavior across multi-component systems requires tracing data flows from error messages through environmental factors. A systematic phase-based approach applies stack-trace instrumentation and pattern analysis to isolate non-obvious causes in complex, interconnected environments.

How does tracing data flow help diagnose elusive bugs?

Tracing data flow helps diagnose elusive bugs by mapping the path of execution and state changes from the symptom to the originating source. This systematic method uses reference techniques and structured evidence gathering to pinpoint exact failure points.

When should I use a systematic debugging process instead of standard troubleshooting?

Use a systematic debugging process when bugs have non-obvious causes, when test failures persist across multiple fix attempts, or when dealing with multi-component systems. It escalates from error message analysis to environmental factor checks using defense-in-depth validation.

Can I apply phase-based analysis to debug issues in any software environment?

Yes, phase-based analysis applies across multi-component systems and diverse debugging scenarios. It guides investigators from error messages and reproductions through hypothesis testing to implementation, adding defense-in-depth instrumentation regardless of the specific software stack.

Why does my bug fix keep failing to resolve the unexpected behavior?

Bug fixes fail when they address symptoms rather than the root cause. Systematic debugging enforces a four-phase process with structured evidence gathering and defense-in-depth checks to ensure the implementation targets the true source of the unexpected behavior.