systematic-debugging

Trace data flow backward to identify root causes of technical issues.

Updated Dec 29, 2025
One-click install
npx skills add https://github.com/jmcveen/growth-mastery-1648e850 --skill systematic-debugging-jmcveen
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/jmcveen/growth-mastery-1648e850/tree/main/.claude/skills/systematic-debugging
Command: npx skills add https://github.com/jmcveen/growth-mastery-1648e850 --skill systematic-debugging-jmcveen

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill ensures that technical issues like bugs, test failures, or unexpected behavior are resolved by first understanding and addressing their root cause, preventing superficial fixes that lead to recurring problems.

Core Features & Use Cases

  • Root Cause Analysis: Guides users through a systematic process to identify the fundamental reason for a technical issue.
  • Hypothesis-Driven Debugging: Encourages forming and testing specific hypotheses about the problem's cause.
  • Use Case: When a critical test suite begins failing intermittently, this Skill helps trace the data flow backward from the error, compare the failing code with working examples, and form a testable hypothesis to pinpoint the exact faulty logic before any code changes are made.

Quick Start

Use the systematic-debugging skill to investigate the intermittent test failures in the CI pipeline.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
How do I find the root cause of a bug instead of just patching the symptoms?

Root cause analysis requires tracing data flow backward from the error and forming testable hypotheses. This methodical debugging process ensures you identify fundamental architectural flaws and implement minimal targeted fixes, preventing superficial patches that lead to recurring problems.

What is the best way to troubleshoot intermittent test failures in a CI pipeline?

Troubleshooting intermittent test failures involves comparing failing code with working examples to form a testable hypothesis. This hypothesis-driven debugging approach pinpoints the exact faulty logic by deeply understanding the problem's origin before making any code changes.

How do I fix unexpected software behavior without introducing new issues?

Fixing unexpected software behavior safely requires implementing minimal, targeted fixes based on a deep understanding of the problem. By tracing the data flow backward and testing specific hypotheses, you address fundamental logical flaws and ensure long-term stability.

Why do my bug fixes keep causing the same issues to reappear later?

Bug fixes often fail when they address superficial symptoms rather than the root cause. A systematic debugging process prevents this by enforcing a deep understanding of the problem's origin, ensuring that fixes target fundamental architectural or logical flaws.

When should I use a systematic debugging process for software development?

You should use a systematic debugging process whenever you face technical issues like bugs, test failures, or unexpected behavior. It is essential for preventing superficial fixes and ensuring long-term stability by methodically identifying and addressing fundamental architectural flaws.