systematic-debugging

Investigate root causes before applying fixes across four debugging phases.

58|6|Updated Dec 23, 2025
One-click install
npx skills add https://github.com/Matt-Aurora-Ventures/Jarvis --skill systematic-debugging-matt-aurora-ventures
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/Matt-Aurora-Ventures/Jarvis/tree/main/.windsurf/skills/systematic-debugging
Command: npx skills add https://github.com/Matt-Aurora-Ventures/Jarvis --skill systematic-debugging-matt-aurora-ventures

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic debugging provides a disciplined, phase-driven approach to diagnosing and resolving bugs by focusing on root causes rather than quick symptom fixes, reducing rework and firefighting.

It enforces a four-phase process and mandates root-cause investigation before proposing changes, leveraging anti-pattern awareness and defense-in-depth practices to make failures traceable and prevent regression.

Core Features & Use Cases

  • Phase-based workflow with four clearly defined stages: Root Cause Investigation, Pattern Analysis, Hypothesis and Testing, and Implementation.
  • Mandatory Phase 1 before any fixes are proposed to ensure root causes are understood.
  • Anti-patterns and red-flag guidance that resist rushing or guessing under time pressure.
  • Defense-in-depth approach: validate data and behavior across multiple layers and add contextual instrumentation.
  • References and templates to trace data flow, verify hypotheses, and verify fixes.

Use Case: When debugging a flaky test, a production incident, or a performance regression, follow the process to identify the actual trigger and prevent recurring issues.

Quick Start

Load the skill, begin with Phase 1: Root Cause Investigation, then proceed through Phases 2–4 following the defined steps and anti-pattern guidance.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
What is a systematic approach to root cause debugging for production incidents?

Systematic debugging is a disciplined, four-phase process mandating root cause investigation before any fixes. It enforces pattern analysis, hypothesis testing, and implementation to resolve production incidents and prevent recurring symptom patches.

How do I stop fixing symptoms and find the actual root cause of flaky test failures?

To stop fixing symptoms, follow a strict root cause investigation phase before proposing changes. This process enforces data flow tracing and pattern analysis to identify the actual trigger behind flaky test failures, preventing regression.

What is the best way to debug performance regressions without introducing new issues?

The best way to debug performance regressions is applying a defense-in-depth approach alongside a mandatory hypothesis and testing phase. This validates behavior across multiple layers, ensuring your performance fixes are verified and traceable.

Can I use this debugging method for integration problems across any tech stack?

Yes, you can use this phase-driven debugging method for integration problems across any tech stack. It provides tech-agnostic anti-pattern guidance and templates to trace data flow and verify fixes universally.

Why does my quick bug fix keep causing regressions in my software development workflow?

Quick bug fixes cause regressions when they bypass root cause investigation. Applying anti-pattern awareness and a structured implementation phase ensures failures are fully understood and validated before changes are applied.

When should I not use a quick patch and instead trace data flow for debugging?

You should avoid quick patches during production incidents or complex test failures. Instead, trace data flow and apply defense-in-depth instrumentation to identify the actual trigger and prevent firefighting and rework.