systematic_debugging

Systematically debugs technical issues through four phases: investigation, analysis, hypothesis, implementation.

18|8|Updated May 31, 2023
One-click install
npx skills add https://github.com/jpmorgan-payments/embedded-finance --skill systematic-debugging-jpmorgan-payments
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic_debugging
Source: https://github.com/jpmorgan-payments/embedded-finance/tree/main/.github/skills/superpowers/systematic-debugging
Command: npx skills add https://github.com/jpmorgan-payments/embedded-finance --skill systematic-debugging-jpmorgan-payments

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill provides a structured, repeatable process to systematically identify and resolve the root cause of any bug, test failure, or unexpected behavior, preventing the common pitfalls of quick fixes and symptom-based patching.

Core Features & Use Cases

  • Four-Phase Framework: Guides users through Investigation, Pattern Analysis, Hypothesis, and Implementation.
  • Root Cause Mandate: Emphasizes finding the fundamental issue, not just addressing immediate symptoms.
  • Pressure Resistance: Includes specific language and structural defenses to prevent rationalization under time pressure.
  • Use Case: When a critical test fails in CI, instead of guessing or adding arbitrary waits, use this Skill to methodically trace the failure back to its origin, ensuring a robust fix.

Quick Start

Use the systematic_debugging skill to investigate any bug or test failure you encounter.

Frequently Asked Questions about systematic_debugging

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

FAQPage Schema
How do I systematically debug a test failure instead of just patching the symptom?

Systematic debugging guides you through Investigation, Pattern Analysis, Hypothesis, and Implementation phases to find root causes. This structured process prevents symptom-based patching and ensures robust issue resolution.

What is the best way to find the root cause of an unexpected bug under time pressure?

Root cause analysis under time pressure requires structural defenses against rationalization. The systematic debugging process includes specific rules and anti-patterns to resist debugging shortcuts and maintain methodical investigation even during critical incidents.

Why do my bug fixes keep recurring when I use arbitrary waits or guess at solutions?

Recurring bug fixes happen when you address symptoms instead of root causes. Systematic debugging prevents this by enforcing pattern analysis and hypothesis formation before implementation, stopping common pitfalls like arbitrary waits and guesswork.

Can I use a systematic debugging process for any technical issue or test failure?

Yes, systematic debugging provides a repeatable process for any bug, test failure, or unexpected behavior. It works by prioritizing root cause analysis across a structured four-phase framework to ensure consistent and robust issue resolution.

What are the common anti-patterns to avoid during technical troubleshooting?

Common troubleshooting anti-patterns include guessing, adding arbitrary waits, and applying symptom-based patches. Systematic debugging resists these shortcuts by enforcing a structured investigation and hypothesis process before any implementation begins.