Systematic-Debugging

Diagnose root causes of bugs before applying fixes using a four-phase framework.

149|10|Updated Oct 30, 2025
One-click install
npx skills add https://github.com/tilework-tech/nori-profiles --skill systematic-debugging-tilework-tech
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Systematic-Debugging
Source: https://github.com/tilework-tech/nori-profiles/tree/main/src/installer/features/profiles/config/_mixins/_swe/skills/systematic-debugging
Command: npx skills add https://github.com/tilework-tech/nori-profiles --skill systematic-debugging-tilework-tech

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a rigorous, four-phase framework for debugging, ensuring you always find the root cause of any technical issue before attempting fixes, preventing wasted time and the introduction of new bugs.

Core Features & Use Cases

  • Root Cause Investigation: Guides through reading errors, reproducing issues, checking changes, and gathering evidence.
  • Pattern Analysis: Helps identify differences between working and broken code, and understand dependencies.
  • Hypothesis Testing: Enforces forming single hypotheses and testing them minimally, one variable at a time.
  • Use Case: When a critical production bug arises, use this skill to systematically investigate, analyze, hypothesize, and implement a fix, ensuring the problem is resolved permanently without guesswork.

Quick Start

A test is failing unexpectedly. Guide me through systematic debugging to find 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 a bug instead of applying random fixes?

Root cause analysis involves systematically investigating errors, reproducing the issue consistently, checking recent changes, and gathering evidence before forming hypotheses. This four-phase framework—root-cause investigation, pattern analysis, hypothesis testing, and implementation—ensures you diagnose the actual problem, not just symptoms, preventing wasted debugging time and new bugs from misguided fixes.

What's the best way to debug test failures without guessing?

Systematic debugging enforces a structured approach: first, investigate by reading error messages and reproducing failures; second, analyze patterns between working and broken code; third, form a single hypothesis and test it minimally, changing one variable at a time. This disciplined method eliminates guesswork and prevents introducing new issues during troubleshooting.

Can I use this framework for production bugs and performance problems?

Yes. The four-phase debugging framework applies to any technical issue: test failures, production bugs, performance degradation, build failures, integration failures, and unpredictable system behavior. The same root-cause investigation, pattern analysis, and hypothesis testing process works across all these problem types.

Why does my debugging take so long when I jump straight to fixes?

Skipping root-cause investigation leads to surface-level fixes that don't address the underlying problem, causing bugs to resurface or new failures to emerge. Systematic debugging requires completing Phase 1 investigation before proposing any fix, ensuring you spend time on the actual cause rather than repeatedly patching symptoms.

How do I test my debugging hypothesis without breaking more code?

Hypothesis testing in systematic debugging requires isolating variables: form a single hypothesis about the root cause, then test it minimally by changing one thing at a time. This controlled approach lets you verify or reject each hypothesis with evidence, avoiding cascading failures from simultaneous changes.