root-cause-tracing
Systematically trace bugs backward through call stack to find original trigger. Use when errors occur deep in execution and you need to trace back to find the original trigger.
62
72%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/root-cause-tracing/skills/root-cause-tracing/SKILL.mdQuality
Discovery
67%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
The description has good structural completeness with both 'what' and 'when' clauses clearly stated, and uses proper third-person voice. However, it lacks specificity in concrete actions and misses several natural trigger terms users would employ when encountering this type of problem. The description is somewhat repetitive, with the 'when' clause largely restating the 'what' clause.
Suggestions
Add more specific concrete actions such as 'analyze stack traces, inspect variable state at each frame, identify the originating function call' to improve specificity.
Include additional natural trigger terms like 'stack trace', 'exception', 'traceback', 'root cause', 'crash', 'debugging' to improve discoverability.
Differentiate the 'when' clause from the 'what' clause by adding distinct trigger scenarios, e.g., 'Use when encountering stack traces, unexpected exceptions, or when a bug manifests far from its origin in the code.'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (debugging/bug tracing) and describes one core action (trace bugs backward through call stack), but doesn't list multiple concrete actions like setting breakpoints, analyzing stack frames, or identifying root causes in specific ways. | 2 / 3 |
Completeness | Clearly answers both 'what' (systematically trace bugs backward through call stack to find original trigger) and 'when' (use when errors occur deep in execution and you need to trace back to find the original trigger) with an explicit 'Use when' clause. | 3 / 3 |
Trigger Term Quality | Includes some relevant terms like 'bugs', 'call stack', 'errors', and 'trace back', but misses common user variations like 'stack trace', 'exception', 'crash', 'root cause analysis', 'debugging', or 'traceback'. | 2 / 3 |
Distinctiveness Conflict Risk | The focus on call stack tracing provides some distinctiveness, but could overlap with general debugging skills, error handling skills, or logging/diagnostics skills. The description doesn't carve out a sufficiently unique niche. | 2 / 3 |
Total | 9 / 12 Passed |
Implementation
77%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, actionable skill that teaches a clear debugging methodology with concrete examples and well-sequenced steps. Its main weakness is some redundancy between the abstract tracing process and the concrete example (which walk through the same scenario), and a few sections that add bulk without proportional value. The executable code examples and clear workflow make it practically useful.
Suggestions
Consolidate the 'Tracing Process' walkthrough and 'Real Example' sections since they cover the same scenario — use the concrete example as the primary walkthrough to eliminate redundancy.
Remove or trim the 'Real-World Impact' section as the metrics are context-specific and don't add instructional value.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Generally efficient but includes some unnecessary sections like 'Real-World Impact' with self-congratulatory metrics ('1847 tests passed') and some redundancy between the tracing process walkthrough and the 'Real Example' section which covers the same scenario. The 'When to Use' section is somewhat obvious. | 2 / 3 |
Actionability | Provides concrete, executable code examples throughout — instrumentation with console.error, stack trace capture, bash commands for test isolation, and specific TypeScript examples showing the tracing process. The guidance is specific and directly usable. | 3 / 3 |
Workflow Clarity | The 5-step tracing process is clearly sequenced with numbered steps, each building on the previous. The workflow naturally includes validation (step 4 'Keep Tracing Up' verifies the value, step 5 finds the original trigger). The defense-in-depth layers provide a clear verification/prevention framework. | 3 / 3 |
Progressive Disclosure | Content is well-structured with clear headers and sections, but it's somewhat monolithic — the real example and the tracing process walkthrough cover the same scenario and could be consolidated. No bundle files exist, which is fine for this scope, but the inline content could be more tightly organized. | 2 / 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
- secondsky/claude-skills
- Commit
5e92b71
- 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.