Skip to content
Skills Library
Programming · Analysis

debugger

/debugger

Systematic debugging methodology for diagnosing failures and root cause analysis. Triggers on: 2+ failed fix attempts, 'ultradebug', 'uld', debugging in circles, complex system failures, intermittent bugs.

Licence
MIT
Last repository change
13.07.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 13.07.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Systematic debugging methodology for diagnosing failures and root cause analysis. Triggers on: 2+ failed fix attempts, 'ultradebug', 'uld', debugging in circles, complex system failures, intermittent bugs.

Triggers from the description

ultradebuguld
Original author description

Systematic debugging methodology for diagnosing failures and root cause analysis. Triggers on: 2+ failed fix attempts, 'ultradebug', 'uld', debugging in circles, complex system failures, intermittent bugs.

How it works

  1. When to Apply This Guidance
  2. Structured Analysis Framework
  3. Reasoning Principles
  4. Decision Framework
  5. Effort Estimation
  6. Common Failure Patterns
  7. Traps to Avoid
  8. Output Template
Original SKILL.md headings · 117 lines, 584 words
SKILL.md preview
---
name: debugger
description: "Systematic debugging methodology for diagnosing failures and root cause analysis. Triggers on: 2+ failed fix attempts, 'ultradebug', 'uld', debugging in circles, complex system failures, intermittent bugs."
---

# Debugger Skill

Systematic debugging methodology for diagnosing failures and root cause analysis.

## When to Apply This Guidance

- 2+ failed fix attempts on the same issue
- Debugging that's gone in circles
- Complex system behavior you don't understand
- Multi-system integration problems
- Intermittent failures (Heisenbugs)

## Structured Analysis Framework

### Step 1: Restate the Problem

Before investigating, articulate:
- What is the actual vs expected behavior?
- What assumptions might be wrong?
- What could cause the specific symptoms described?
- Are there hidden dependencies or side effects?

### Step 2: Generate Ranked Hypotheses

Always generate multiple hypotheses, ranked by likelihood:

**Most Likely:**
- Evidence: What supports this theory?
- Test: How to verify quickly?

**Possible:**
- Evidence: What partially supports this?
- Test: How to confirm or eliminate?

**Unlikely but worth checking:**
- Evidence: Limited, but possible
- Test: Quick check to rule out

### Step 3: Systematic Verification

Test hypotheses in order. For each:
1. State what you're testing
2. Describe the expected outcome if hypothesis is correct
3. Execute the test
4. Document actual results
5. Update hypothesis ranking based on findings

## Reasoning Principles

1. **Challenge assumptions** - The "obvious" cause is often wrong after 2+ failures
2. **Follow the data** - What do logs/errors actually say vs what's assumed?
3. **Consider timing** - Race conditions, async issues, initialization order
4. **Check boundaries** - Module interfaces, API contracts, type conversions
5. **Question the environment** - Config, dependencies, network, state

## Decision Framework

When choosing between approaches:

| Factor | Weight | Considerations |
|--------|--------|----------------|
| Correctness | Critical | Does it actually solve the problem? |
| Simplicity | High | Prefer boring solutions over clever ones |
| Leverage | High | Use existing patterns/libraries/code |
| Developer Experience | Medium | How hard is it to debug/maintain? |
| Performance | Low* | *Unless performance IS the problem |

## Effort Estimation

Tag recommendations by effort:

| Tag | Meaning | Example |
|-----|---------|---------|
| **[Quick]** | <30 min | Add logging, check config |
| **[Short]** | 30min-2hr | Refactor function, add test |
| **[Medium]** | 2hr-1day | New component, integration |
| **[Large]** | >1 day | Architecture change |

## Common Failure Patterns

| Pattern | Signal | Investigation Focus |
|---------|--------|---------------------|
| Fix-break cycle | Each fix causes new problem | Root cause analysis - treating symptoms not cause |
| Confusion | "I don't understand why X happens" | Add logging, trace execution path |
| Tradeoff paralysis | Multiple valid approaches | Use decision framework above |
| Integration hell | System A + B don't work together | Interface contracts, data formats |
| Heisenbug | Works sometimes, fails randomly | Timing, state, race conditions |

## Traps to Avoid

- **Premature fixing** - Understand before changing
- **Single hypothesis** - Always consider alternatives
- **Assuming correctness** - Verify each component independently
- **Ignoring evidence** - If data contradicts theory, update theory
- **Scope creep** - Fix the bug, not everything around it

## Output Template

When debugging, structure findings as:

```
## Problem Understanding
{Restate in own words. Challenge framing if wrong.}

## Hypotheses (Ranked)
1. Most Likely: {hypothesis} - Evidence: {support} - Test: {verification}
2. Possible: {hypothesis} - Evidence: {support} - Test: {verification}
3. Unlikely: {hypothesis} - Evidence: {limited} - Test: {quick check}

## Recommended Approach
{Specific next steps. Be prescriptive.}

## Traps to Avoid
{What NOT to do for this specific problem.}
```

Versions

RepositoryScoreLicence
This page · TechDufus/oh-my-claude100MIT
filipe-campos/walph100MIT
agentic-swe/agentic-swe100MIT
darrenhinde/OpenAgentsControl100MIT
claude-world/director-mode-lite100MIT
Algoza-Solutions/spider-protocol100MIT
zhaono1/agent-playbook100MIT
charlieviettq/awesome-agent-skill100MIT

Database snapshot: 13.11.2026 · package version 554a4a21f72f (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100debug-systematic
    Systematic 4-phase debugging methodology for complex, intermittent, or mysterious issues. Use when investigating bugs, race conditions, or unexplained failures.
  • 100systematic-debugging
    Root cause investigation methodology for bugs and failures. Use when encountering test failures, unexpected behavior, or errors during research or implement phases. Find the cause before attempting fixes.
  • 100code-showcase-systematic-debugging
    Four-phase debugging methodology with root cause analysis. Use when investigating bugs, fixing test failures, or troubleshooting unexpected behavior. Emphasizes NO FIXES WITHOUT ROOT CAUSE FIRST.
  • 100code-showcase-systematic-debugging
    Four-phase debugging methodology with root cause analysis. Use when investigating bugs, fixing test failures, or troubleshooting unexpected behavior. Emphasizes NO FIXES WITHOUT ROOT CAUSE FIRST.
  • 100issue-debugging
    Systematic methodology for issue debugging including root cause analysis, impact mapping, tiered validation plans, and confidence assessment. Use when analyzing bugs, fixing issues, or validating fixes.
  • 100systematic-debugging
    4-phase systematic debugging methodology with root cause analysis and evidence-based verification. Use when debugging complex issues.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.