root-cause-tracing

Use when errors occur deep in execution and you need to trace back to find the original trigger - systematically traces bugs backward through call stack, adding instrumentation when needed, to identify source of invalid data or incorrect behavior

Quality

72%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Fix and improve this skill with Tessl

tessl review fix ./plugins/kaizen/skills/root-cause-tracing/SKILL.md

Quality

Content

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 specific debugging methodology with concrete examples and clear workflow steps. Its main strengths are the well-sequenced tracing process and real-world example with specific code. Weaknesses include the Graphviz diagrams (which aren't renderable in Claude's typical operating context and consume tokens), slightly verbose presentation, and a referenced bundle file that doesn't exist.

Suggestions

Remove or simplify the Graphviz dot diagrams - they aren't renderable in Claude's context and consume tokens; replace with simple bullet lists or ASCII flow

Ensure the referenced @find-polluter.sh bundle file actually exists, or inline its key logic if it's short

Dimension	Reasoning	Score
Conciseness	The content is mostly efficient but includes some unnecessary elements. The Graphviz diagrams add visual noise without being renderable in most contexts Claude operates in. The 'When to Use' section could be tighter. The real example is useful but slightly verbose. However, it generally avoids explaining concepts Claude already knows.	2 / 3
Actionability	The skill provides concrete, executable code examples throughout - TypeScript instrumentation code, bash commands for capturing output, specific debugging patterns with console.error() and stack traces. The tracing process is illustrated with a real, specific example showing exact values and call chains.	3 / 3
Workflow Clarity	The 5-step tracing process is clearly sequenced (Observe → Find Immediate Cause → Ask What Called This → Keep Tracing Up → Find Original Trigger). The defense-in-depth layers provide validation checkpoints. The feedback loop is implicit but clear: keep tracing until you find the source, then add validation at each layer.	3 / 3
Progressive Disclosure	The skill references a bundle file (@find-polluter.sh) for the bisection script, which is good progressive disclosure, but no bundle files were provided so we can't verify it exists. The content is somewhat long (~120 lines of substantive content) and could benefit from splitting the real example and stack trace tips into separate reference files. The Graphviz diagrams take up space that could be better used.	2 / 3
	Total	10 / 12 Passed

Description

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 a solid structure with explicit 'Use when' guidance and a clear explanation of what the skill does, earning strong completeness marks. However, it could benefit from more specific concrete actions (e.g., 'adds logging statements, inspects stack frames, bisects code paths') and broader trigger term coverage to help users find it with natural language queries. The distinctiveness could be improved by more clearly differentiating this from general debugging skills.

Suggestions

Add more natural trigger terms users would say, such as 'stack trace,' 'root cause analysis,' 'debugging,' 'exception,' 'traceback,' 'crash,' or 'unexpected value'.

List more specific concrete actions beyond 'traces backward' and 'adding instrumentation' - e.g., 'inspects stack frames, adds logging/print statements, identifies where data becomes invalid, bisects execution paths'.

Dimension	Reasoning	Score
Specificity	The description names the domain (debugging/tracing) and describes some actions like 'traces bugs backward through call stack' and 'adding instrumentation,' but it reads more like a general approach description than a list of multiple concrete, distinct actions.	2 / 3
Completeness	The description explicitly answers both 'what' (systematically traces bugs backward through call stack, adding instrumentation to identify source of invalid data or incorrect behavior) and 'when' ('Use when errors occur deep in execution and you need to trace back to find the original trigger').	3 / 3
Trigger Term Quality	Includes some relevant terms like 'errors,' 'call stack,' 'bugs,' 'invalid data,' and 'incorrect behavior,' but misses common user-facing variations like 'stack trace,' 'debugging,' 'root cause,' 'exception,' 'crash,' or 'traceback' that users would naturally say.	2 / 3
Distinctiveness Conflict Risk	The focus on backward tracing through call stacks is somewhat distinctive, but it could overlap with general debugging skills, error handling skills, or logging/instrumentation skills. The niche of 'reverse debugging' is implied but not sharply delineated.	2 / 3
	Total	9 / 12 Passed

Validation

100%

Warnings & errors only

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: NeoLabHQ/context-engineering-kit
Commit: 3711edf

Reviewed: 20 days ago

Table of Contents

Discovery Implementation Validation

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.