{"enrichment":{"faq":[{"a":"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.","q":"How do I debug a failing test systematically?"},{"a":"systematic-debugging emphasizes investigating before implementing. Start by reproducing the bug consistently, then trace data flow to identify which component is actually failing\u2014not 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.","q":"What's the right way to find the root cause of a bug before fixing?"},{"a":"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\u2014not just where it shows up as a symptom.","q":"How can I trace data flow to find where a bug originates?"},{"a":"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\u2014isolate, compare, hypothesize, test\u2014helps you recognize when architectural problems exist rather than continuing to patch surface issues. This prevents wasted effort and catches deeper design flaws.","q":"Why should I investigate test failures before attempting fixes?"},{"a":"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.","q":"What's the systematic approach to fixing errors without guessing?"},{"a":"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.","q":"How do I know if my fix is addressing a real problem?"}],"shadow_tags":["root-cause-analysis","troubleshooting-methodology","evidence-gathering","hypothesis-testing","regression-testing","data-flow-tracing","problem-isolation","architectural-assessment","error-investigation","test-driven-debugging"],"summary_rewrite":"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."},"files":[{"bytes":10361,"path":"crates/skills/src/assets/software-development/systematic-debugging/SKILL.md","sha256":"9a97aab450ceed0abe04f8e71517c066ccc51039b1340805a2a96158a41b0b10","url":"https://skillfed.io/files/moltis-org/moltis/systematic-debugging/966d77de/SKILL.md"}],"id":"moltis-org/moltis/systematic-debugging","links":{"html":"https://skillfed.io/moltis-org/moltis/systematic-debugging","md":"https://skillfed.io/moltis-org/moltis/systematic-debugging.md","repo":"https://github.com/moltis-org/moltis"},"meta":{"agents_supported":[],"first_seen":"2026-07-28","forks":327,"language":"Rust","last_updated":"2026-07-27","license":"MIT","name":"systematic-debugging","publisher":"moltis-org","stars":2795},"relations":{"categories":["software-engineering","quality-assurance","devops"],"similar":[{"id":"mateaix/mateclaw/systematic-debugging"},{"id":"graniet/kheish/systematic-debugging"},{"id":"NousResearch/hermes-agent/systematic-debugging"},{"id":"PracticalSwan/agent-skills/systematic-debugging"},{"id":"secondsky/claude-skills/systematic-debugging"},{"id":"NickCrew/Claude-Cortex/systematic-debugging"},{"id":"eyadsibai/ltk/systematic-debugging"},{"id":"getcrew44/crew44/systematic-debugging"},{"id":"rpamis/comet/systematic-debugging"},{"id":"beita6969/ScienceClaw/systematic-debugging"}]},"slug":{"owner":"moltis-org","repo":"moltis","skill":"systematic-debugging"},"version":"966d77de"}