systematic-debugging

Enforce root-cause investigation before fixing bugs and test failures.

Updated Apr 24, 2026
One-click install
npx skills add https://github.com/otto-poblysh/pedagemy-early-access --skill systematic-debugging-otto-poblysh
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/otto-poblysh/pedagemy-early-access/tree/main/.agents/skills/systematic-debugging
Command: npx skills add https://github.com/otto-poblysh/pedagemy-early-access --skill systematic-debugging-otto-poblysh

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It prevents wasted time and new regressions by forcing you to investigate the true root cause of bugs, test failures, and unexpected behavior instead of applying random fixes.

Core Features & Use Cases

  • Root-cause-first debugging mandate: Use the “Iron Law” to avoid proposing any fixes until Phase 1 (root cause investigation) is complete.
  • Four-phase process: Follow Investigation → Pattern Analysis → Hypothesis & Testing → Implementation, with explicit rules for moving forward and handling failure.
  • Pressure-resistant guardrails: Includes anti-shortcuts and clear stop conditions (e.g., do not add more fixes after a failed hypothesis; question architecture after 3+ failures).
  • Works for many failure types: Applies to production bugs, CI/build failures, flaky tests, integration issues, performance problems, and deep call-stack errors.

Quick Start

Use this skill when you hit a bug or test failure and start at Phase 1 by reading errors carefully, reproducing the issue consistently, and tracing data flow backward until you identify the root cause.

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 production incidents and flaky tests?

To find the root cause of production incidents and flaky tests, you must enforce a strict investigation phase that traces data flow backward from the error until the original trigger is identified, preventing premature fixes.

What is the best way to debug deep stack-call errors where the original trigger is unclear?

The best way to debug deep stack-call errors is applying a four-phase process: investigation, pattern analysis, single-hypothesis testing, and root-cause implementation, ensuring you stop and re-analyze after any failed hypothesis.

Why do my repeated fixes keep failing to resolve CI/build failures and integration issues?

Repeated fixes fail to resolve CI/build failures and integration issues because applying random patches without finding the root cause introduces regressions, requiring you to question the architecture after three or more failed hypothesis tests.

How to systematically debug performance problems and unexpected behavior before applying changes?

Systematically debug performance problems and unexpected behavior by following the Iron Law: read errors carefully, reproduce the issue consistently, and complete pattern analysis before proposing any implementation changes.

When should I question software architecture during root cause investigation?

You should question software architecture during root cause investigation when you experience three or more failed hypothesis tests, triggering a mandatory stop condition to re-analyze the structural design instead of applying more fixes.