compose:debug

Diagnose bugs and test failures through a four-phase root cause investigation workflow.

Updated Jun 27, 2026
One-click install
npx skills add https://github.com/HKUST-QUANT-SOCIETY/quantcode --skill compose-debug-hkust-quant-society
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: compose:debug
Source: https://github.com/HKUST-QUANT-SOCIETY/quantcode/tree/main/.opencode/meta-skills/debug
Command: npx skills add https://github.com/HKUST-QUANT-SOCIETY/quantcode --skill compose-debug-hkust-quant-society

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Random fixes and guess-and-check patching waste time, mask underlying issues, and introduce new bugs. This Skill enforces a systematic debugging discipline that finds the root cause before any fix is attempted. ## Core Features & Use Cases - Four-Phase Process: Root cause investigation, pattern analysis, hypothesis testing, and verified implementation, each gated before the next begins. - Multi-Component Evidence Gathering: Add diagnostic instrumentation at component boundaries (CI, build, signing, services) to locate exactly where a system breaks. - Architectural Escalation: After three failed fixes, stop and question the architecture instead of attempting a fourth patch. - Use Case: A CI signing pipeline fails intermittently. Instead of retrying random config changes, instrument each layer (workflow secrets, build script environment, keychain state, codesign) to identify the exact failing boundary, then fix at the source. ## Quick Start Use the debug skill to investigate why the test suite fails after the latest commit before proposing any fix.

Frequently Asked Questions about compose:debug

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

FAQPage Schema
How do I debug a test failure systematically?

Start by reading the full error message and stack trace, then reproduce the failure consistently and check recent changes via git diff. Form a single hypothesis, test it with the smallest possible change, and only implement a fix after confirming the root cause.

How to find root cause in multi-component systems?

Add diagnostic logging at each component boundary, recording what data enters and exits every layer. Run the system once to gather evidence showing exactly which boundary fails, then investigate only that component instead of guessing across the whole stack.

When should I stop trying fixes and question the architecture?

Stop after three failed fix attempts. If each fix reveals a new problem in a different place or requires massive refactoring, the pattern itself is likely flawed and needs architectural review rather than another patch.

Why do quick fixes cause more bugs?

Quick fixes address symptoms rather than root causes, so the underlying issue persists and resurfaces elsewhere. Bundling multiple changes at once also makes it impossible to isolate what worked, frequently introducing new defects.

What should I do when a bug is not reproducible?

Do not guess. Gather more data through logging and instrumentation until the failure can be triggered reliably, since an unreproducible bug cannot be verified as fixed.