debug
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.
Debug skill systematically traces application errors to their root cause through structured investigation and hypothesis testing.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-07-27
Debug skill systematically traces application errors to their root cause through structured investigation and hypothesis testing. 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.
Use it when
- Debug enforces systematic error investigation by parsing logs and stack traces to identify exact failure points.
- Debug emphasizes forming and testing debugging hypotheses before applying fixes.
Verify before relying
Read SKILL.md below before installing (2 files). Open directory: indexed for reading, not audited.
Install
softspark/ai-toolkit/debug · repository language: Python
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 an error in my application?
Debug guides you through a structured four-phase workflow: first, investigate the error completely by collecting logs and stack traces; second, analyze patterns in working code to understand context; third, form and test a single hypothesis before applying any fix; finally, implement the solution. This methodical approach helps you trace from symptom to root cause rather than patching surface symptoms.
How does Debug help trace where my code is failing?
Debug enforces systematic error investigation by parsing logs and stack traces to identify exact failure points. It helps you map the error path through your application, understand the sequence of events leading to the failure, and distinguish between where the symptom appears versus where the actual problem originates—critical for fixing the root cause rather than masking the issue.
What's the best way to reproduce an intermittent bug?
Debug emphasizes forming and testing debugging hypotheses before applying fixes. For intermittent bugs, this means collecting detailed logs across multiple occurrences, identifying common patterns, and designing targeted tests to reproduce the issue deterministically. Once you can reliably trigger the bug, you can confidently validate your fix without guessing.
How can Debug help with service health and connectivity issues?
Debug supports checking service health and diagnosing connectivity or performance problems by helping you systematically collect and analyze logs from all affected services. You can trace request flows across service boundaries, identify where connections fail or degrade, and test hypotheses about network, configuration, or resource constraints before implementing corrections.
What prevents Debug users from just patching symptoms?
Debug's disciplined workflow enforces root-cause thinking by requiring you to complete the investigation and analysis phases before forming a hypothesis. This structure prevents the common trap of applying quick fixes to visible symptoms. By insisting on understanding the underlying problem first, Debug helps you implement lasting solutions that don't create new bugs downstream.
Can Debug help with debugging logs and stack traces?
Yes. Debug specializes in parsing error logs and stack traces to identify failure points. It helps you extract meaningful patterns from raw log data, correlate events across multiple log sources, and follow stack traces back through your application layers to pinpoint where execution went wrong—essential for understanding complex multi-component failures.
SKILL.md
Rendered from the published skill. Quoted content, verbatim.
Debug Helper
$ARGUMENTS
Systematic debugging for application issues.
Project context
- Recent logs: !
docker compose logs --tail 20 2>/dev/null || tail -20 logs/*.log 2>/dev/null || echo "no-logs-found"
Automated Error Parsing
Pipe error output through the error parser for structured diagnosis:
# Pipe from failing command
your_command 2>&1 | python3 "$(dirname "$0")/scripts/error-parser.py"
# Or from a log file
cat /var/log/app/error.log | python3 scripts/error-parser.py
The script outputs JSON with: - language: detected language (python/node/go/php) - error_type: extracted error class (e.g., ModuleNotFoundError) - message: the error message text - category: classification (import, reference, type, connection, timeout, memory, permission, syntax) - stack_frames: parsed file/line/function from the stack trace -
(truncated - see the full file via the links below)
File tree — 2 files
app/skills/debug/SKILL.md
app/skills/debug/scripts/error-parser.py
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 › “Systematically investigate and trace application errors to root cause”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
This skill guides you through a four-phase debugging methodology designed to eliminate guesswork when troubleshooting Laravel issues. By enforcing root cause investigation before any fix attempt, it helps you avoid symptom-masking patches that create new problems. The process covers log analysis, Laravel Telescope inspection, data flow tracing, pattern comparison, hypothesis testing, and test-driven implementation.
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.
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.
Investigate guides you through a disciplined five-phase debugging process: collect evidence, form ranked hypotheses, verify each one methodically, apply a minimal fix only after confirming root cause, then verify resolution. The workflow prevents guess-and-fix cycles by enforcing evidence gathering before hypothesis formation and a three-strike rule that forces re-collection rather than endless speculation.
This skill enforces a disciplined debugging workflow: gather symptoms and code context, test hypotheses against known patterns, verify your theory before writing any fix, and document findings in a structured report. It prioritizes root cause discovery over quick patches, flagging when investigation stalls so you know when to escalate rather than guess.
Root Cause Tracing teaches you to follow bugs backward through the call chain rather than patching where errors appear. The skill walks through tracing methodology, stack instrumentation, and defense-in-depth validation to prevent recurrence.
More skills parallel-debugging (MIT) · architecture-audit (Apache-2.0) · Systematic Debugging (unlicensed) · debug-investigator (MIT) · systematic-debugging (MIT) · Debugging (unlicensed)