systematic-debugging

Guide root-cause investigation for technical bugs with an evidence-driven four-phase workflow.

7|2|Updated Apr 30, 2026
One-click install
npx skills add https://github.com/MRWillisT/PullNexus --skill systematic-debugging-mrwillist
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/MRWillisT/PullNexus/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/MRWillisT/PullNexus --skill systematic-debugging-mrwillist

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Systematic debugging helps you stop wasting time on guess-and-check fixes by guiding you to identify the true root cause of a bug or unexpected behavior first, using evidence.

Core Features & Use Cases

  • Root-cause investigation first: Forces an investigation workflow (read errors, reproduce, check recent changes, trace data flow) before any fix is proposed.
  • Evidence-driven iteration: Emphasizes instrumentation at narrow boundaries and interpreting evidence to revise hypotheses rather than stacking changes.
  • Test-first remediation: Requires a failing test (when possible) before implementing a single fix and verifying it resolves the actual issue.

Example use cases

  • Intermittent production 500s that are hard to reproduce locally.
  • Regressions after a dependency/config change where the diff doesn’t reveal the cause.
  • Multi-layer failures across workflow → build → signing or API → service → database boundaries.

Quick Start

Use systematic-debugging when you hit a technical issue and ask: "Help me follow Phase 1 root-cause investigation first—what exact evidence should we gather to prove where it breaks, before proposing any fix?"

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
What is the best way to find the root cause of intermittent production 500s?

Root cause investigation for intermittent production 500s requires gathering exact evidence through instrumentation to prove where the system breaks across component boundaries before proposing any fix. This approach enforces evidence-driven iteration instead of guess-and-check troubleshooting.

How do I debug multi-layer failures across API, service, and database boundaries?

Debugging multi-layer failures across API, service, and database boundaries involves tracing data flow and reading errors at narrow boundaries to isolate the exact component at fault. You must reproduce the issue and verify your hypothesis with a failing test before implementing a fix.

Why should I use systematic debugging instead of applying fixes directly?

Systematic debugging prevents wasted time on guess-and-check fixes by enforcing an evidence-driven workflow that identifies the true root cause first. By requiring a failing reproduction test before remediation, it ensures the proposed fix actually resolves the underlying issue.

How do I troubleshoot performance regressions after a dependency or config change?

Troubleshooting performance regressions after a dependency or config change requires checking recent changes and tracing data flow to build an evidence-based hypothesis. You must instrument the system at narrow boundaries to interpret evidence and revise your hypothesis before fixing.

Can I use test-driven development to verify fixes for unexpected behavior?

Test-driven development applies to unexpected behavior by requiring a failing reproduction test before implementing any single fix. This test-first remediation verifies that your changes actually resolve the issue and prevents stacking multiple unverified changes.