systematic-debugging

Diagnose bugs through a four-phase root cause investigation process before proposing fixes.

Updated Jun 21, 2026
One-click install
npx skills add https://github.com/NicolaeRotaru/ad-mycity --skill systematic-debugging-nicolaerotaru
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/NicolaeRotaru/ad-mycity/tree/main/.cursor/skills/systematic-debugging
Command: npx skills add https://github.com/NicolaeRotaru/ad-mycity --skill systematic-debugging-nicolaerotaru

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Random fixes and quick patches waste time, mask underlying issues, and introduce new bugs. This Skill enforces a disciplined debugging methodology that finds the root cause before any fix is attempted, replacing guess-and-check thrashing with systematic investigation. ## Core Features & Use Cases - Four-Phase Process: Root cause investigation, pattern analysis, hypothesis testing, and verified implementation, each gated so you cannot skip ahead. - Multi-Component Evidence Gathering: Instrument component boundaries (CI, build, signing, APIs, databases) with diagnostic logging to pinpoint exactly which layer fails. - Architectural Escalation: After three failed fixes, the process forces you to stop and question the architecture instead of attempting a fourth patch. - Use Case: A CI signing pipeline fails intermittently. Instead of retrying random config changes, you add logging at each layer (workflow, build script, keychain, codesign), identify that secrets fail to propagate from workflow to build, and fix the actual source. ## Quick Start Use the systematic-debugging skill to investigate this failing test and find its root cause before suggesting any fix.

Frequently Asked Questions about systematic-debugging

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I debug a bug systematically instead of guessing?▼

Follow four phases: investigate the root cause by reading errors and reproducing the issue, analyze patterns by comparing working and broken code, form and test a single hypothesis minimally, then implement one fix with a failing test. Never propose fixes before completing the investigation phase.

How to find which component fails in a multi-layer system?▼

Add diagnostic logging at each component boundary, recording what data enters and exits every layer. Run the system once to gather evidence showing exactly where the failure occurs, then investigate only that specific component instead of guessing across the whole stack.

When should I stop trying fixes and question the architecture?▼

Stop after three failed fix attempts. If each fix reveals a new problem elsewhere, requires massive refactoring, or creates new symptoms, the pattern itself is likely flawed. Discuss the architecture with your team before attempting a fourth fix.

Does systematic debugging apply to simple bugs or emergencies?▼

Yes, the process applies to every technical issue regardless of perceived simplicity or urgency. Simple bugs have root causes too, and systematic investigation is faster than guess-and-check thrashing, especially under time pressure.

Why do quick fixes without root cause analysis fail?▼

Quick patches treat symptoms rather than causes, so the underlying issue resurfaces and the patch often introduces new bugs. Data from debugging sessions shows systematic approaches achieve roughly 95% first-time fix rates versus 40% for random fixes.