systematic-debugging

Diagnose software issues through a four-phase root-cause debugging process.

3|Updated Feb 14, 2026
One-click install
npx skills add https://github.com/ArtemioPadilla/agent-triforce --skill systematic-debugging-artemiopadilla
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/ArtemioPadilla/agent-triforce/tree/main/.claude/skills/systematic-debugging
Command: npx skills add https://github.com/ArtemioPadilla/agent-triforce --skill systematic-debugging-artemiopadilla

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Provides a structured, four-phase approach to diagnosing software issues by ensuring root-cause analysis before proposing fixes.

Core Features & Use Cases

  • Phase 1: Root Cause Investigation — reproduce issues, collect evidence, and trace data flow.
  • Phase 2: Pattern Analysis — compare against references and identify differences.
  • Phase 3: Hypothesis and Testing — form testable hypotheses and validate with minimal changes.
  • Phase 4: Implementation — apply fixes with guardrails and post-fix validation.
  • Defense in Depth — add layered validation, monitoring, and assertions to prevent regression.
  • Use Cases: debugging flaky tests, complex integrations, performance regressions, and unexpected behavior.

Quick Start

Begin with Phase 1: reproduce the issue, gather evidence, and document the data flow before proposing any fixes.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
What is a structured root-cause debugging process for software issues?

Root-cause debugging is a structured method that enforces evidence gathering, pattern analysis, hypothesis testing, and controlled implementation to resolve software issues. It uses explicit gates to prevent premature fixes before the actual cause is confirmed.

How do I debug flaky tests and complex integration failures?

To debug flaky tests and complex integrations, start by reproducing the issue and tracing data flow to collect evidence. Compare against reference patterns, form testable hypotheses, and validate them with minimal changes before applying fixes.

Can I use this systematic debugging approach for performance regressions?

Yes, this systematic debugging approach applies to performance regressions and unexpected behavior across multi-component systems. It guides you through reproducing issues, analyzing patterns, and validating hypotheses with guardrails.

What is the best way to prevent bug regression after implementing a fix?

The best way to prevent regression is applying defense-in-depth during implementation. This adds layered validation, monitoring, and assertions alongside the primary fix, followed by post-fix validation to ensure system stability.

Why does my debugging process keep fixing symptoms instead of the root cause?

Your debugging process likely skips evidence gathering and applies premature fixes. A disciplined root-cause debugging process enforces explicit gates between investigation, pattern analysis, and hypothesis testing to ensure the true cause is found.

When should I not use a systematic hypothesis-testing approach for debugging?

You should avoid a systematic hypothesis-testing approach for trivial, immediately obvious errors where the root cause is already visible. It is designed for complex multi-component issues requiring disciplined evidence gathering and pattern analysis.