systematic-debugging

Investigate technical failures through a four-phase root cause analysis process.

Updated Mar 20, 2026
One-click install
npx skills add https://github.com/sixscripts-ai/ghostssh --skill systematic-debugging-sixscripts-ai
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/sixscripts-ai/ghostssh/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/sixscripts-ai/ghostssh --skill systematic-debugging-sixscripts-ai

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic debugging helps engineers identify the true root cause of any bug, test failure, or unexpected behavior before proposing fixes, preventing symptom fixes that propagate risk.

Core Features & Use Cases

  • Four-phase process (Root Cause Investigation → Pattern Analysis → Hypothesis and Testing → Implementation) that ensures disciplined problem solving.
  • Anti-patterns and defenses that resist rushed shortcuts and enforce evidence collection, documentation, and verification.
  • Deep tracing and defense-in-depth techniques such as root-cause tracing and multi-layer validation to harden fixes across code paths and environments.
  • Applicable scenarios include production outages, flaky tests, integration failures, and performance issues in software systems.

Quick Start

Follow the four phases in order to diagnose the issue and implement a root-cause fix before attempting symptom patches.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
What is root-cause debugging and why does it matter for production outages?

Root-cause debugging identifies the true origin of production outages, flaky tests, and integration failures before applying fixes. It prevents symptom patches that mask underlying issues and propagate risk across software systems by enforcing evidence collection and systematic investigation.

How do I debug flaky tests and integration failures systematically?

Debug flaky tests and integration failures by following a four-phase process: root cause investigation, pattern analysis, hypothesis testing, and implementation. This systematic debugging approach enforces evidence collection and documentation before applying code fixes to prevent recurring symptoms.

What's the best way to stop symptom fixes when tracing software bugs?

The best way to stop symptom fixes is deep root-cause tracing combined with multi-layer validation. This defense-in-depth technique hardens fixes across code paths and environments, ensuring the true origin of bugs is resolved rather than temporarily masking unexpected behavior.

Can I apply systematic debugging to performance problems across different teams?

Yes, systematic debugging applies to any technical issue including performance problems across teams. The four-phase process works for production outages, test failures, and integration glitches, requiring root cause investigation before fixes to ensure disciplined problem solving regardless of the system scope.

Why does rushing to fix bugs without pattern analysis increase risk?

Rushing fixes without pattern analysis increases risk because it bypasses hypothesis testing and evidence collection. Systematic debugging resists these anti-patterns by enforcing a four-phase process that validates root causes before implementation, preventing incomplete fixes that propagate failure across code paths.