$npx skillfedfor your agent

systematic-debugging

This skill enforces disciplined debugging by requiring root cause investigation before any fix attempt. It walks through four phases: isolating the problem through error analysis and reproduction, comparing working patterns against broken code, forming and testing a single hypothesis, and finally implementing the fix while catching architectural issues that multiple failed attempts reveal.

Systematic Debugging guides you through a 4-phase root cause investigation before attempting any fix.

AI-generated summary based on this skill's SKILL.md

★ 2,795  327 MITupdated by moltis-org

Decision gist · record as of 2026-07-27

Systematic Debugging guides you through a 4-phase root cause investigation before attempting any fix. This skill enforces disciplined debugging by requiring root cause investigation before any fix attempt. It walks through four phases: isolating the problem through error analysis and reproduction, comparing working patterns against broken code, forming and testing a single hypothesis, and finally implementing the fix while catching architectural issues that multiple failed attempts reveal.

manual: git clone https://github.com/moltis-org/moltis → cp -r moltis/crates/skills/src/assets/software-development/systematic-debugging ~/.claude/skills/systematic-debugging
crates/skills/src/assets/software-development/systematic-debugging/SKILL.md · version 966d77de

Use it when

  • systematic-debugging emphasizes investigating before implementing.
  • systematic-debugging teaches you to follow the four-phase process: isolate by reproducing the failure.

Verify before relying

Read SKILL.md below before installing (1 file). Open directory: indexed for reading, not audited.

Same gist for agents: .md · .json

Install

moltis-org/moltis/systematic-debugging · repository language: Rust

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 do I debug a failing test systematically?

systematic-debugging guides you through four phases: first, isolate the problem by analyzing error messages and reproducing the failure consistently; second, compare working patterns against broken code to spot differences; third, form and test a single hypothesis about the root cause; fourth, implement your fix while watching for architectural issues that repeated failures might reveal. This structured approach prevents wasted time on symptom fixes.

What's the right way to find the root cause of a bug before fixing?

systematic-debugging emphasizes investigating before implementing. Start by reproducing the bug consistently, then trace data flow to identify which component is actually failing—not where the symptom appears. Compare working and broken code paths, form one testable hypothesis, and verify it before touching any code. This discipline catches architectural problems that random patching would miss.

How can I trace data flow to find where a bug originates?

systematic-debugging teaches you to follow the four-phase process: isolate by reproducing the failure, compare working versus broken behavior, form a hypothesis about the root cause, then test it. By tracing function calls and data transformations systematically rather than guessing, you discover where the bug actually starts—not just where it shows up as a symptom.

Why should I investigate test failures before attempting fixes?

systematic-debugging enforces this discipline because investigating first reveals whether you're fixing a real root cause or just masking a symptom. The four-phase process—isolate, compare, hypothesize, test—helps you recognize when architectural problems exist rather than continuing to patch surface issues. This prevents wasted effort and catches deeper design flaws.

What's the systematic approach to fixing errors without guessing?

systematic-debugging provides a structured four-phase workflow: phase one isolates the problem through error analysis and consistent reproduction; phase two compares working patterns against broken code; phase three forms and tests a single hypothesis; phase four implements the fix while catching architectural issues. Following this methodology prevents random fixes and ensures you're solving the actual problem.

How do I know if my fix is addressing a real problem?

systematic-debugging requires you to trace the root cause before implementing any solution. By systematically investigating and reproducing issues, comparing working and broken code, and forming testable hypotheses, you verify the fix solves the actual problem rather than a symptom. This disciplined approach ensures your fix is real and prevents architectural problems from hiding under repeated failed attempts.

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

(truncated - see the full file via the links below)

File tree — 1 file
crates/skills/src/assets/software-development/systematic-debugging/SKILL.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 or test failure before attempting any fix”

Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →

Related skills

systematic-debugging
by NousResearch · NousResearch/hermes-agent

This skill enforces a disciplined debugging process: establish a tight feedback loop that reproduces the exact symptom, gather evidence across system boundaries, trace data flow to its source, and form testable hypotheses before proposing any fix. By completing each phase sequentially—root cause investigation, pattern analysis, hypothesis testing, and verification—you eliminate guesswork and prevent quick patches from masking deeper issues.

MITupdated Jul 2026
★ 221,503repo stars
Debugging Protocol
by jwilger · jwilger/agent-skills

Debugging Protocol teaches a disciplined four-phase investigation process that enforces root cause analysis before any code change. It prevents the common trap of jumping to fixes without understanding why problems exist, using the Iron Law (investigate first) and Three Strikes Rule (escalate after three failed attempts) to guide systematic problem-solving.

CC0-1.0updated Jul 2026
★ 1repo stars
systematic-debugging
by PracticalSwan · PracticalSwan/agent-skills

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.

MITupdated Jul 2026
★ 6repo stars
systematic-debugging
by secondsky · secondsky/claude-skills

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.

MITupdated Jul 2026
★ 196repo stars
Systematic Debugging
by eyadsibai · eyadsibai/ltk

Systematic Debugging teaches a disciplined four-phase process for tackling any technical issue—from test failures to production bugs. By enforcing root cause investigation before attempting fixes, it eliminates guesswork and the cycle of symptom-patching that creates new problems. The framework emphasizes evidence gathering, pattern analysis, hypothesis testing, and architectural questioning when multiple fixes fail.

no license declared → metadata onlyupdated Jan 2026
★ 6repo stars
bug-hunt-swarm
by Dimillian · Dimillian/Skills

Bug Hunt Swarm deploys four read-only sub-agents in parallel to investigate bugs, regressions, and crashes from different angles—reproduction scope, code paths, recent changes, and proof strategies. The main agent then synthesizes findings into ranked hypotheses with supporting evidence and the fastest path to confirm or disprove each theory, all without making code edits.

MITupdated Mar 2026
★ 3,861repo stars

More skills systematic-debugging (MIT) · Systematic Debugging (unlicensed)

Tags
root-cause-analysistroubleshooting-methodologyevidence-gatheringhypothesis-testingregression-testingdata-flow-tracingproblem-isolationarchitectural-assessmenterror-investigationtest-driven-debugging