skills.rest
richardcb
richardcbCOMMUNITY
Explore all skills by this author →
GitHub

debug-assistant

Diagnose software bugs through structured analysis and hypothesis testing.

15|3|Updated Jan 27, 2026
Search Tags:#testing#code analysis#debugging#troubleshooting#bug fixing#error resolution
One-click install
npx skills add https://github.com/richardcb/oh-my-gemini --skill debug-assistant-richardcb
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: debug-assistant
Source: https://github.com/richardcb/oh-my-gemini/tree/main/skills/debug-assistant
Command: npx skills add https://github.com/richardcb/oh-my-gemini --skill debug-assistant-richardcb

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you systematically identify, diagnose, and fix bugs in your code, reducing the time spent on troubleshooting and improving software reliability.

Core Features & Use Cases

  • Structured Debugging: Follows a methodical process from information gathering to root cause analysis.
  • Hypothesis Testing: Generates and tests potential causes for bugs.
  • Regression Prevention: Includes steps to add tests and prevent future occurrences.
  • Use Case: When your application crashes unexpectedly or a feature behaves erratically, activate this Skill to guide you through a robust debugging process.

Quick Start

Use the debug-assistant skill to help fix the 'TypeError: Cannot read properties of undefined' error in the user authentication module.

Frequently Asked Questions about debug-assistant

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

FAQPage Schema
How do I systematically debug unexpected software errors and erratic behavior?▼

Systematic debugging identifies and fixes software errors through structured information gathering, reproducing issues, forming hypotheses, investigating code and data flow, and isolating the root cause. This methodical process reduces troubleshooting time and improves software reliability.

What is the best way to troubleshoot mysterious bugs that are hard to reproduce?▼

Troubleshooting mysterious bugs requires gathering detailed information about the issue, attempting to reproduce the error, generating hypotheses, and investigating code and data flow. Complex issues can be integrated with persistence mechanisms to maintain context during extended investigations.

How do I fix a TypeError and prevent the same bug from happening again?▼

Fixing a TypeError involves isolating the bug through methodical testing and code analysis, implementing a verified fix, and adding regression tests. This structured approach ensures the error is resolved and prevents future occurrences of the same bug pattern.

Can I use structured hypothesis testing to resolve unexpected application crashes?▼

Hypothesis testing resolves unexpected application crashes by generating potential causes, investigating code and data flow, and methodically verifying each hypothesis. This structured approach isolates the bug accurately before implementing a verified fix to restore stability.

Does debugging require any specific testing frameworks or code analysis tools to work?▼

Debugging does not require specific external testing frameworks or code analysis tools as dependencies. The process relies on structured analysis, hypothesis generation, and methodical testing principles that can be applied directly to your existing codebase and environment.

Related Skills

Explore More Software Engineering Skills→
Ilenburg1993Ilenburg1993
3

reactive-bug-audit

Analyze stack traces and logs to identify root causes and apply minimal patches.

Community
Intermediate
first-flukefirst-fluke
218

debug-agent

Diagnose software bugs and propose minimal regression-tested fixes.

Official
Advanced
bostonaholicbostonaholic
8

test-driven-bug-fix

Reproduce, isolate, fix, and verify software defects using test-driven methodology.

Community
Advanced
mvillmowmvillmow
18

scan-vulnerabilities

Detect security vulnerabilities in code and dependencies with static analysis.

Community
Intermediate