One-click install
npx skills add https://github.com/lukebaze/forex-rebate-bot --skill debugging-lukebaze
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Debugging
Source: https://github.com/lukebaze/forex-rebate-bot/tree/main/.opencode/skill/debugging
Command: npx skills add https://github.com/lukebaze/forex-rebate-bot --skill debugging-lukebaze

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

Debugging can be time-consuming and error-prone when issues span multiple components; this Skill provides a disciplined, four-phase framework to identify root causes before fixes, reducing wasted effort and preventing symptom-focused interventions.

Core Features & Use Cases

  • Systematic Debugging: Four-phase framework guiding root-cause investigation (Phase 1: Root Cause Investigation, Phase 2: Pattern Analysis, Phase 3: Hypothesis and Testing, Phase 4: Implementation).
  • Root Cause Tracing: Trace data backward through call stacks to locate the original trigger, with instrumentation guidelines.
  • Defense-in-Depth: Validate data at entry, business logic, environment guards, and debug instrumentation to make bugs structurally unlikely.
  • Verification: Run fresh verification steps to confirm outcomes before closing a fix.

Use Cases: Resolve test failures, unexpected behavior, performance issues, or integration problems by following the methodical process.

Quick Start

Begin by reproducing the issue, gathering evidence across components, and applying Phase 1 root-cause investigation before attempting fixes.

Frequently Asked Questions about Debugging

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

FAQPage Schema
What is systematic debugging and how does root-cause analysis work?

Systematic debugging is a structured investigation workflow that traces data backward through call stacks to locate the original trigger. It enforces root-cause analysis before fixes, preventing symptom-focused interventions across multi-component systems.

How do I debug test failures and regressions in multi-component systems?

Debug test failures and regressions by following a four-phase framework: root cause investigation, pattern analysis, hypothesis testing, and implementation. Begin by reproducing the issue and gathering evidence across components before attempting any fixes.

What's the best way to trace a root cause through call stacks?

The best way to trace a root cause is applying Phase 1 root-cause investigation, which traces data backward through call stacks to locate the original trigger. This uses instrumentation guidelines to gather evidence before forming hypotheses.

Can I use defense-in-depth validation for performance issues and unexpected behavior?

Yes, defense-in-depth validation applies to performance issues and unexpected behavior by validating data at entry, business logic, environment guards, and debug instrumentation. This makes bugs structurally unlikely across multi-component systems.

How do I verify a bug fix before closing it?

Verify a bug fix by running fresh verification steps in Phase 4 to confirm outcomes before completion. This ensures the root-cause fix resolves the original issue without introducing regressions across the system.

When should I not use a systematic debugging framework?

Avoid using a systematic debugging framework for trivial, single-component issues where the root cause is immediately obvious. The four-phase investigation process is designed for complex bugs spanning multiple components where symptom-focused fixes risk wasted effort.