Debugging Protocol
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.
Debugging Protocol provides a structured 4-phase method to investigate and fix code failures by understanding root causes before attempting solutions.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-07-05
Debugging Protocol provides a structured 4-phase method to investigate and fix code failures by understanding root causes before attempting solutions. 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.
Use it when
- Debugging Protocol teaches a repeatable methodology with four distinct phases: first, isolate and reproduce the problem consistently.
- Debugging Protocol emphasizes the Iron Law—investigate first, act second—and the Three Strikes Rule.
Install
jwilger/agent-skills/debugging-protocol · repository language: Shell
generated, unverified - the skill's exact subdirectory could not be determined; check the repository on GitHub
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
What is a debugging protocol?
Debugging Protocol is a disciplined four-phase investigation process that enforces root cause analysis before any code change. It prevents 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 across your team.
How do I debug code using this structured approach?
Debugging Protocol teaches a repeatable methodology with four distinct phases: first, isolate and reproduce the problem consistently; second, gather evidence through logs and system state; third, form and test hypotheses about root causes; fourth, implement and verify the fix. This sequence ensures you understand the problem before changing code.
What are the best practices for systematic debugging?
Debugging Protocol emphasizes the Iron Law—investigate first, act second—and the Three Strikes Rule, which escalates issues after three failed attempts. These principles prevent wasted effort on guesses and keep teams focused on evidence-based diagnosis rather than trial-and-error fixes.
How can I establish a debugging protocol for my team?
Debugging Protocol provides a framework to standardize your team's problem-solving approach. By adopting its four-phase process and core rules (Iron Law and Three Strikes), you create a repeatable protocol that all team members follow, reducing inconsistency and improving time-to-resolution across debugging efforts.
How do I debug efficiently and reduce resolution time?
Debugging Protocol improves efficiency by eliminating guesswork through its structured phases and escalation rules. The Three Strikes Rule prevents endless failed attempts, while the Iron Law ensures investigation happens upfront. This systematic approach reduces wasted effort and accelerates root cause discovery.
What debugging techniques and strategies does this protocol teach?
Debugging Protocol covers systematic problem diagnosis through evidence gathering, hypothesis formation, and methodical testing. Its techniques include isolating reproduction steps, analyzing logs and system state, forming testable theories about root causes, and verifying fixes. The framework applies across code and application debugging scenarios.
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 › “Learn a structured approach to debugging code and applications”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
Investigate guides you through structured debugging in five phases, from evidence collection to verified fix. It enforces the Iron Law principle—never fix without a confirmed root cause—using pattern analysis, hypothesis testing with a 3-strike escalation rule, and regression coverage. Output includes a machine-readable debug report with the full evidence chain.
CI Integration enforces push-and-wait discipline to prevent pushing code while prior runs are pending, then classifies failures into five categories—test, lint, build, flaky, or infrastructure—each with its own fix strategy. Mechanical failures like formatting issues auto-heal; test failures route to debugging; flaky tests get flagged and tracked. Every interaction produces structured evidence packets for pipeline consumption.
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.
Investigate walks you through a structured methodology to pinpoint what's causing bugs, test failures, build errors, and unexpected behavior. It cycles through characterization, isolation, hypothesis generation, and targeted testing—with escalation to deeper analysis when needed—to diagnose the root cause without applying fixes.
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.
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.
More skills systematic-debugging (MIT) · Systematic Debugging (unlicensed)