failure-oriented-instrumentation

Selectively instruments code to capture runtime data for debugging failures and bugs. Use when investigating crashes, exceptions, unexpected behavior, test failures, or performance issues. Analyzes stack traces and error messages to identify suspicious code regions, then adds targeted logging, tracing, and assertions to capture variable values, execution paths, timing, and conditional branches. Supports Python, JavaScript/TypeScript, Java, and C/C++.

1.10x

Quality

92%

Does it follow best practices?

Impact

66%

1.10x

Average score across 3 eval scenarios

Securityby

Passed

No known issues

Quality

Content

85%

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 skill with strong actionability and excellent progressive disclosure. The workflow is clear with appropriate decision points for different failure types. The main weakness is some verbosity in the guidelines sections that could be tightened without losing clarity.

Suggestions

Condense the 'What to Instrument' and 'What NOT to Instrument' sections into a single concise table or bullet list with fewer items

Remove or shorten the 'Instrumentation Best Practices' section as most points (use appropriate log levels, avoid side effects) are standard knowledge Claude already has

Dimension	Reasoning	Score
Conciseness	The skill is reasonably efficient but includes some unnecessary explanation (e.g., the 'What to Instrument' priority lists are somewhat verbose, and some guidelines repeat common knowledge). The workflow section could be tightened.	2 / 3
Actionability	Provides fully executable code examples in Java, Python, and JavaScript with specific instrumentation patterns. The examples are copy-paste ready and demonstrate exactly what to add and where.	3 / 3
Workflow Clarity	Clear 6-step workflow with explicit progression from minimal to expanded instrumentation. The 'Start small, expand as needed' principle provides a feedback loop, and steps are well-sequenced with clear decision points.	3 / 3
Progressive Disclosure	Excellent structure with a clear overview, quick start examples inline, and language-specific details appropriately delegated to separate reference files (references/python.md, etc.). Navigation is clear and one-level deep.	3 / 3
	Total	11 / 12 Passed

Description

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 (instruments code with logging, tracing, and assertions to capture runtime data) and when to use it (debugging crashes, exceptions, test failures, etc.). It uses third person voice correctly, includes comprehensive trigger terms that developers would naturally use, and is specific enough to avoid conflicts with other debugging-related skills.

Dimension	Reasoning	Score
Specificity	Lists multiple specific concrete actions: 'instruments code', 'capture runtime data', 'analyzes stack traces and error messages', 'adds targeted logging, tracing, and assertions', 'capture variable values, execution paths, timing, and conditional branches'. Also specifies supported languages.	3 / 3
Completeness	Clearly answers both what ('instruments code to capture runtime data', 'adds targeted logging, tracing, and assertions') AND when ('Use when investigating crashes, exceptions, unexpected behavior, test failures, or performance issues') with explicit trigger guidance.	3 / 3
Trigger Term Quality	Excellent coverage of natural terms users would say: 'debugging', 'failures', 'bugs', 'crashes', 'exceptions', 'unexpected behavior', 'test failures', 'performance issues', 'stack traces', 'error messages', 'logging', 'tracing'. These are terms developers naturally use when seeking debugging help.	3 / 3
Distinctiveness Conflict Risk	Clear niche focused on runtime instrumentation for debugging. The specific focus on adding logging/tracing to capture runtime data distinguishes it from general debugging skills, code review skills, or static analysis tools. The explicit language support further narrows the scope.	3 / 3
	Total	12 / 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: ArabelaTso/Skills-4-SE
Commit: 0f00a4f

Reviewed: 4 months 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.