debugging
Systematic debugging that applies the scientific method to failures. Use when the user says "debug this", "why is this failing", "help me find the bug", "this doesn't work", "track down the issue", or is stuck on a problem and thrashing without progress.
80
76%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/debugging/SKILL.mdQuality
Discovery
82%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This description excels at trigger term coverage and completeness, with a strong 'Use when...' clause containing natural user phrases. Its main weaknesses are the lack of specific concrete actions (what does 'scientific method debugging' actually entail?) and moderate overlap risk with other debugging or coding assistance skills. Adding specific actions and narrowing the scope would strengthen it.
Suggestions
Add specific concrete actions to improve specificity, e.g., 'Reproduces failures, forms hypotheses, isolates variables, and tests fixes systematically'
Differentiate from general coding help by clarifying what makes this distinct, e.g., 'for complex or elusive bugs where simple inspection isn't enough' to reduce conflict risk with basic code assistance skills
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description names the domain ('systematic debugging') and mentions 'applies the scientific method to failures', but does not list multiple specific concrete actions like 'reproduce the error, isolate variables, form hypotheses, test fixes'. The actual capabilities are described abstractly rather than as concrete steps. | 2 / 3 |
Completeness | Clearly answers both 'what' (systematic debugging applying the scientific method to failures) and 'when' (explicit 'Use when...' clause with multiple specific trigger phrases and a situational trigger). Both components are explicitly stated. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural trigger terms users would actually say: 'debug this', 'why is this failing', 'help me find the bug', 'this doesn't work', 'track down the issue', and the behavioral trigger 'stuck on a problem and thrashing without progress'. These are highly natural phrases. | 3 / 3 |
Distinctiveness Conflict Risk | While the 'scientific method' approach is somewhat distinctive, 'debugging' is a broad domain that could overlap with language-specific debugging skills, testing skills, or general coding assistance skills. The trigger terms like 'this doesn't work' are quite generic and could match many skills. | 2 / 3 |
Total | 10 / 12 Passed |
Implementation
70%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a well-structured debugging methodology skill with excellent workflow clarity and progressive disclosure. Its main weakness is the lack of concrete, executable examples — it teaches a process abstractly rather than showing specific debugging commands, code patterns, or tool usage. Some content explains concepts Claude already knows (anti-patterns descriptions, basic debugging philosophy).
Suggestions
Add concrete executable examples: show specific debugging commands (e.g., git bisect workflow, strategic logging patterns, debugger usage) rather than just describing the methodology abstractly.
Trim the anti-patterns section — Claude already understands these concepts. A brief bullet list of names would suffice as reminders without the explanations.
Add a concrete worked example showing the scientific debugging loop applied to a specific bug (e.g., a failing test case), demonstrating the observe→hypothesize→predict→test→conclude cycle with actual code/commands.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Generally efficient but includes some content Claude already knows well (e.g., explaining what shotgun debugging is, explaining that human intuition about bugs is often wrong). The anti-patterns section describes concepts Claude would already understand. However, the structured rules and workflow are reasonably tight. | 2 / 3 |
Actionability | Provides a clear methodology and structured templates, but lacks concrete executable examples. No actual code showing debugging techniques (e.g., using a debugger, adding strategic print statements, bisecting with git). The guidance is procedural rather than executable — it describes what to do conceptually but doesn't show how with specific commands or code. | 2 / 3 |
Workflow Clarity | The scientific debugging loop is clearly sequenced with explicit steps. The workflow section provides a well-ordered 5-step process with clear validation checkpoints (form hypotheses before testing, define pass/fail criteria before running experiments, verify the fix addresses root cause). The feedback loop is explicit: 'repeat from step 2 if refuted.' | 3 / 3 |
Progressive Disclosure | Well-structured with a clear overview, then progressively detailed sections. References are one level deep and clearly signaled (references/nine-rules.md, related skills). The document is appropriately sized for a SKILL.md with good cross-references to related skills and a recipe file. | 3 / 3 |
Total | 10 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Repository
- tslateman/duet
- Commit
c3b1fc2
- Reviewed
Table of Contents
Is this your skill?
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.