Debugging
Debugging provides a four-phase framework for investigating issues methodically rather than applying random fixes. It combines root cause tracing through call stacks, defense-in-depth validation across system layers, and verification protocols to confirm fixes work before claiming success.
Debugging teaches systematic investigation and root cause analysis to identify and fix runtime errors correctly.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2025-12-09
Debugging teaches systematic investigation and root cause analysis to identify and fix runtime errors correctly. Debugging provides a four-phase framework for investigating issues methodically rather than applying random fixes. It combines root cause tracing through call stacks, defense-in-depth validation across system layers, and verification protocols to confirm fixes work before claiming success.
Use it when
- Debugging emphasizes systematic investigation over guesswork.
- Debugging tools let you pause execution at breakpoints, then advance through code using step-over (skip function calls).
Install
samhvw8/dot-claude/debugging · repository language: Python
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
How do I debug my code effectively?
Debugging provides a methodical four-phase framework for investigating issues rather than applying random fixes. Start by reproducing the problem consistently, then trace root causes through call stacks and logs. Use breakpoints to pause execution at suspect points, inspect variable states, and step through code line-by-line. Validate fixes across system layers before confirming success—this defense-in-depth approach prevents masked errors from resurging in production.
What are the key debugging techniques and best practices?
Debugging emphasizes systematic investigation over guesswork. Core techniques include setting breakpoints at suspected failure points, using watchpoints to monitor variable changes, stepping through execution flow, and inspecting variable values during runtime. Best practices involve reproducing issues reliably first, checking assumptions at each layer, logging strategically to trace execution, and verifying that your fix actually resolves the root cause rather than just the symptom.
How do I step through code with a debugger?
Debugging tools let you pause execution at breakpoints, then advance through code using step-over (skip function calls), step-into (enter function calls), or step-out (exit current function) commands. Set breakpoints at lines where you suspect problems, run your application, and when execution pauses, inspect variable states in the debugger's watch window. This controlled stepping reveals exactly where logic diverges from expectations.
How can I find bugs in my application systematically?
Debugging's verification protocol starts by reliably reproducing the issue, then narrows the problem scope using binary search—disabling half your code, testing, then focusing on whichever half still fails. Trace execution flow through logs and call stacks, inspect variables at each step, and validate assumptions about data types and values. Once you identify the root cause, apply a targeted fix and verify it works across all affected code paths.
What's the difference between logging and debugging?
Debugging uses interactive tools like breakpoints and watchpoints to pause and inspect live execution, giving you real-time visibility into variable states and call stacks. Logging writes timestamped messages to files or streams, letting you trace execution asynchronously after the fact. Debugging excels at pinpointing exact failure moments; logging works better for production monitoring and tracing distributed systems where pausing isn't feasible.
How do I troubleshoot runtime errors using debugging?
Debugging addresses runtime errors through root cause tracing and defense-in-depth validation. When an error occurs, use stack traces to identify which function failed and why. Set breakpoints just before the failure point, inspect variable values, and verify they match your expectations. Check assumptions at each system layer—input validation, business logic, and output formatting. Once fixed, test across edge cases to confirm the error won't resurface.
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 how to debug code and identify runtime errors”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
vc-debug guides you through structured investigation before any fix, combining root cause tracing, defense-in-depth validation, and verification protocols. Handle code bugs, system failures, CI/CD issues, and performance degradation with frameworks for each scenario—from call stack analysis to log inspection to frontend verification.
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.
Systematic Debugging teaches a disciplined 4-phase approach: root cause investigation, pattern analysis, hypothesis testing, and implementation. Rather than attempting quick fixes, this skill enforces tracing issues back to their source through careful error analysis, data flow tracking, and minimal testing before any code change.
This skill teaches you to trace bugs backward through the call chain rather than fixing where errors appear. By working systematically up the stack—identifying what called each function and what values were passed—you locate the original trigger and fix the root cause. Includes instrumentation techniques, stack trace analysis, and real examples of finding pollution across test suites.
This skill systematically investigates why problems occur by separating genuine causal relationships from correlations and symptoms. It guides you through defining effects, generating competing hypotheses, building causal models, testing causality rigorously, and documenting findings with confidence levels. Apply it to incident investigations, metric changes, policy evaluation, or debugging.
Debug Investigator replaces ad-hoc troubleshooting with structured investigation: capture symptoms, build a reproducible feedback loop, analyze evidence from stacktraces and logs, generate ranked hypotheses, and design bisection strategies. Use it for non-obvious bugs—intermittent failures, performance regressions, or issues requiring systematic root cause analysis—where native debugging falls short.
More skills systematic-debugging (MIT) · Systematic Debugging (unlicensed) · debug (Apache-2.0)