trace-and-isolate
Applies systematic tracing and isolation techniques to pinpoint exactly where a bug originates in code. Use when a bug is hard to locate, code is not working as expected, an error or crash appears with unclear cause, a regression was introduced between recent commits, or you need to narrow down which component, function, or line is faulty. Covers binary search debugging, git bisect for regressions, strategic logging with [TRACE] patterns, data and control flow tracing, component isolation, minimal reproduction cases, conditional breakpoints, and watch expressions across TypeScript, SQL, and bash.
79
75%
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 ./packages/core/src/methodology/packs/debugging/trace-and-isolate/SKILL.mdQuality
Discovery
100%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 is an excellent skill description that clearly articulates what the skill does (systematic tracing and isolation for bug localization), when to use it (multiple explicit trigger scenarios), and how it works (specific techniques listed). It uses third-person voice throughout, includes natural trigger terms, and is distinctive enough to avoid conflicts with related but different skills.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions and techniques: binary search debugging, git bisect, strategic logging with [TRACE] patterns, data and control flow tracing, component isolation, minimal reproduction cases, conditional breakpoints, and watch expressions. Also specifies languages covered (TypeScript, SQL, bash). | 3 / 3 |
Completeness | Clearly answers both 'what' (systematic tracing and isolation techniques, with specific methods listed) and 'when' (explicit 'Use when...' clause covering multiple trigger scenarios like hard-to-locate bugs, unclear errors, regressions between commits, and narrowing down faulty components). | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms users would say: 'bug', 'not working as expected', 'error', 'crash', 'regression', 'narrow down', 'faulty', 'git bisect', 'debugging'. These are highly natural phrases a user would use when encountering hard-to-find bugs. | 3 / 3 |
Distinctiveness Conflict Risk | Occupies a clear niche focused specifically on bug localization and isolation techniques, distinct from general debugging, code review, or testing skills. The emphasis on tracing, bisecting, and isolation makes it unlikely to conflict with broader coding or fixing skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
50%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a solid reference skill that covers a broad range of debugging isolation techniques with reasonable structure and some concrete examples. Its main weaknesses are that it reads more like a reference catalog than an actionable workflow—there's no clear decision tree guiding which technique to apply when, and several examples are illustrative rather than executable. The content could be tightened by removing explanations of concepts Claude already understands and splitting detailed sections into separate files.
Suggestions
Add a top-level decision workflow or flowchart that guides technique selection based on the bug scenario, creating a clear 'start here → try this → if not resolved, try that' sequence.
Make the binary search debugging section more concrete with actual executable code rather than prose pseudocode (e.g., a script that systematically comments out code blocks).
Split detailed technique sections (isolation patterns, breakpoint strategies) into separate referenced files to improve progressive disclosure and reduce the monolithic feel.
Add explicit feedback loops: what to do when a technique doesn't yield results, how to pivot between techniques, and validation steps to confirm you've found the actual root cause.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is reasonably efficient but includes some unnecessary verbosity. The data flow tracing ASCII diagram and some of the explanatory text (e.g., 'Strip away everything non-essential') describe things Claude already knows. The quick reference table is efficient, but several sections could be tightened. | 2 / 3 |
Actionability | Provides concrete code examples for logging, git bisect, and isolation patterns, but many examples are illustrative rather than truly executable (e.g., the binary search debugging is pseudocode/prose, breakpoint strategies use comments rather than actual debugger commands). The code path binary search section is particularly abstract. | 2 / 3 |
Workflow Clarity | The binary search debugging has a clear sequence, and git bisect steps are well-ordered. However, there's no overarching workflow tying the techniques together (e.g., 'start here, then try this if that doesn't work'). The isolation checklist is good but lacks explicit feedback loops for when isolation fails or results are ambiguous. | 2 / 3 |
Progressive Disclosure | The content is well-structured with clear headers and a useful quick reference table at the top. However, at ~180 lines it's a long monolithic document that could benefit from splitting detailed technique sections (e.g., isolation patterns, breakpoint strategies) into separate referenced files. | 2 / 3 |
Total | 8 / 12 Passed |
Validation
90%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 10 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 10 / 11 Passed | |
- Repository
- rohitg00/skillkit
- Commit
dfa8d12
- 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.