systematic-debugging
Systematic Debugging enforces a disciplined four-phase process: investigate root cause, analyze patterns, form and test hypotheses, then implement fixes. It stops you from guessing at solutions and catching yourself in cycles of failed patches that mask underlying problems.
Systematic Debugging helps you find the actual root cause of a bug before attempting any fix.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-07-11
Systematic Debugging helps you find the actual root cause of a bug before attempting any fix. Systematic Debugging enforces a disciplined four-phase process: investigate root cause, analyze patterns, form and test hypotheses, then implement fixes. It stops you from guessing at solutions and catching yourself in cycles of failed patches that mask underlying problems.
Use it when
- Systematic Debugging's root cause analysis phase focuses on understanding why a failure occurred, not just where it appears.
- Systematic Debugging provides a structured framework for investigating production issues and test failures step by step.
Verify before relying
Read SKILL.md below before installing (12 files). Open directory: indexed for reading, not audited.
Install
PracticalSwan/agent-skills/systematic-debugging · repository language: Python
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
How to debug a problem systematically?
Systematic Debugging guides you through a four-phase process: first investigate to find the root cause rather than treating symptoms, then analyze patterns in failures, form testable hypotheses about what's broken, and only then implement fixes. This disciplined approach stops you from guessing at solutions and prevents cycles of failed patches that mask underlying problems.
What is the root cause analysis for bugs in Systematic Debugging?
Systematic Debugging's root cause analysis phase focuses on understanding why a failure occurred, not just where it appears. By investigating before attempting fixes, you avoid wasting time on wrong solutions. The skill teaches you to trace data flow through multi-component systems and recognize whether you're facing an architectural problem or just a symptom that needs deeper investigation.
How does Systematic Debugging help with production bug investigation?
Systematic Debugging provides a structured framework for investigating production issues and test failures step by step. Rather than jumping to solutions under time pressure, the skill enforces a methodology that has you investigate systematically, analyze patterns, form hypotheses, and test them before implementing fixes. This prevents architectural problems from being masked by temporary patches.
When should I recognize architectural problems vs. symptom fixes?
Systematic Debugging teaches you to distinguish between fixing surface symptoms and addressing underlying architectural issues. During the investigation and pattern-analysis phases, the skill helps you trace bugs through multi-layer systems to see whether repeated failures point to a deeper design problem rather than isolated bugs. This recognition prevents you from applying band-aid fixes that fail repeatedly.
Why does Systematic Debugging emphasize finding root cause before fixing?
Systematic Debugging stops you from guessing at solutions, which creates cycles of failed patches. By enforcing a four-phase process that prioritizes root cause investigation, you avoid wasting time on wrong fixes. The skill ensures you understand the actual failure before implementing solutions, making your debugging more efficient and preventing architectural problems from being masked by temporary workarounds.
SKILL.md
Rendered from the published skill. Quoted content, verbatim.
Systematic Debugging
Overview
Random fixes waste time and create new bugs. Quick patches mask underlying issues.
Core principle: ALWAYS find root cause before attempting fixes. Symptom fixes are failure.
Violating the letter of this process is violating the spirit of debugging.
The Iron Law
NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST
If you haven't completed Phase 1, you cannot propose fixes.
When to Use
Use for ANY technical issue: - Test failures - Bugs in production - Unexpected behavior - Performance problems - Build failures - Integration issues
Use this ESPECIALLY when: - Under time pressure (emergencies make guessing tempting) - "Just one quick fix" seems obvious - You've already tried multiple fixes - Previous fix didn't work - You don't fully understand the issue
Don't skip when: - Issue seems simple (simple bugs have root causes too) - You're in a hurry (rushing guarantees rework) -
(truncated - see the full file via the links below)
File tree — 12 files
systematic-debugging/CHANGELOG.md
systematic-debugging/CREATION-LOG.md
systematic-debugging/SKILL.md
systematic-debugging/condition-based-waiting-example.ts
systematic-debugging/condition-based-waiting.md
systematic-debugging/defense-in-depth.md
systematic-debugging/find-polluter.sh
systematic-debugging/root-cause-tracing.md
systematic-debugging/test-academic.md
systematic-debugging/test-pressure-1.md
systematic-debugging/test-pressure-2.md
systematic-debugging/test-pressure-3.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Find the root cause of a bug before attempting fixes”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
Debugging provides structured methodologies across four sub-skills: systematic investigation to isolate root causes, backward tracing through call stacks, layered validation to prevent recurrence, and verification before claiming fixes are complete. Use it when encountering bugs, test failures, or unexpected behavior.
This skill enforces a disciplined debugging methodology that prioritizes root cause discovery over quick patches. Work through four phases—investigation, pattern analysis, hypothesis testing, and implementation—completing each before advancing. The framework prevents the trap of symptom-fixing by requiring evidence gathering across component boundaries and data flow tracing before any fix attempt.
Systematic Debugging enforces a disciplined four-phase process: investigate root cause, analyze patterns, form and test hypotheses, then implement fixes. It stops you from guessing or patching symptoms, ensuring you understand the actual problem before making changes.
This skill guides you through a disciplined five-phase debugging workflow designed to eliminate guesswork and prevent band-aid fixes. Start by reliably reproducing the issue, then systematically narrow down the failing component, trace the chain of causation, apply a minimal fix at the root cause, and finally verify the solution works without introducing new problems. The methodology emphasizes understanding *why* a bug occurs before attempting repairs.
Systematic Debugging enforces disciplined root-cause investigation before any code changes, using a 4-phase pipeline: evidence gathering, pattern comparison, hypothesis testing, and targeted fixes. It prevents the common failure mode of applying surface-level patches that mask underlying issues. Works with test failures, production bugs, performance problems, and build failures across any tech stack.
Debug helps you trace application issues methodically from symptom to root cause using structured log analysis, error parsing, and hypothesis testing. It enforces a disciplined four-phase workflow: investigate the error completely, analyze patterns in working code, form and test a single hypothesis, then implement the fix—preventing the common trap of patching symptoms instead of solving underlying problems.
More skills Systematic Debugging (unlicensed) · Debugging (unlicensed) · debug-systematic (MIT) · systematic-debugging (MIT) · debug-investigator (MIT) · root-cause-tracing (MIT) · parallel-debugging (MIT) · Causal Inference Root Cause (unlicensed)