debugging

Debugging techniques and tools for IntelliJ development. Use when debugging IDE issues or investigating failures.

Quality

75%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

—

The risk profile of this skill

Fix and improve this skill with Tessl

tessl review fix ./.agents/skills/debugging/SKILL.md

Quality

Content

75%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

A tight, mostly actionable skill that concentrates on IntelliJ-specific knowledge (log category abbreviations, log levels) Claude would not know, with concrete grep examples and a sequenced debugging workflow. The main gaps are the generic End-to-End guidance and documentation links that point outside the skill bundle rather than to bundled reference files.

Suggestions

Move the three external doc links into a references/ directory inside the skill bundle (or inline the essential content) so the references resolve wherever the skill is installed.

Make the End-to-End Behavior steps concrete for this codebase — e.g., how to trace an entry point (specific classes, run configurations, or debugger attach steps) instead of generic advice.

Add a short feedback-loop line to the End-to-End workflow (what to do when verification at the entry point still fails) to complete the fix-retry cycle.

Dimension	Reasoning	Score
Conciseness	The body is lean: the log-level mapping ("FINE = debug level") and category abbreviation format ("#c.i.o.w.i.s.IdeStatusBarImpl") are IntelliJ-specific knowledge Claude does not already have, delivered with no padding. The "End-to-End Behavior" bullets are generic debugging wisdom that could be trimmed, matching anchor 4 (minor instances of over-explanation) rather than 5.	4 / 5
Actionability	"grep \"FINE - #c.i.o.w.i.s.IdeStatusBarImpl\" idea.log" gives copy-paste-ready commands with a worked example of the category abbreviation. The End-to-End section ("Trace the full execution chain") is high-level direction without commands, keeping it at anchor 4 rather than 5's fully executable coverage of common cases.	4 / 5
Workflow Clarity	The End-to-End section is a clearly sequenced 4-step list with an explicit checkpoint ("Verify the fix at the entry point the user actually invokes, not just at the layer you modified"). It is not 5 because there is no fix-retry feedback loop, and not 3 because a verification checkpoint is explicitly present.	4 / 5
Progressive Disclosure	Sections are clear and well-organized (Documentation, Searching idea.log, End-to-End Behavior) with one-level-deep, clearly labeled doc links — good structure per anchor 4. It is not 5 because the three links point outside the skill bundle via "../../../../docs/" and do not resolve in the environment, with no in-bundle reference files.	4 / 5
	Total	16 / 20 Passed

Description

65%Weight 40%Scale 1-5

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 clear, explicit trigger clause and a well-scoped niche, but the capability statement is generic — it says "techniques and tools" without naming any concrete action the skill performs. Adding 2-3 specific capabilities (log searching, exception analysis, freeze investigation) and richer trigger synonyms would lift it substantially.

Suggestions

Name concrete capabilities in the description, e.g., "Search idea.log by class and log level, analyze exceptions, and investigate IDE freezes" — this mirrors what the body actually teaches.

Add natural trigger synonyms such as "troubleshooting", "errors", or "exceptions" to the "Use when" clause to improve trigger coverage.

Tighten the what/when pairing by mentioning the key artifact users would reference, e.g., "Use when debugging or troubleshooting IntelliJ Platform issues, reading idea.log, or investigating IDE freezes."

Dimension	Reasoning	Score
Specificity	"Debugging techniques and tools for IntelliJ development" names the domain, but "techniques and tools" is generic phrasing with no concrete actions named (e.g., nothing like "search idea.log" or "analyze exceptions"). It fits anchor 2 (domain named, actions minimal/generic) rather than 3, which requires 1-2 concrete actions.	2 / 5
Completeness	Both halves are present: the "what" ("Debugging techniques and tools for IntelliJ development") and an explicit "Use when debugging IDE issues or investigating failures" trigger clause. It is not 3 because the when-clause is explicit rather than weakly implied; not 5 because the "what" lacks concrete capability statements and the triggers could be richer.	4 / 5
Trigger Term Quality	"debugging", "IDE issues", and "investigating failures" are natural phrases a user would say when they need this skill. A few common variations are missing ("troubleshooting", "errors", "exceptions", "logs"), matching anchor 4 rather than 5's comprehensive synonym coverage.	4 / 5
Distinctiveness Conflict Risk	"IntelliJ development" scopes a fairly distinct niche, and the trigger is IDE-specific, so it is mostly distinct. It is not 5 because "debugging IDE issues" still overlaps generic debugging/troubleshooting skills, matching anchor 4's "minor overlap risk with closely related skills".	4 / 5
	Total	14 / 20 Passed

Validation

93%

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 — 15 / 16 Passed

Validation for skill structure

Criteria	Description	Result
relative_links	Relative link issues: 3 suspicious	Warning

	Total	15 / 16 Passed

Repository: JetBrains/MPS
Path: .agents/skills/debugging/SKILL.md
Commit: e2a6605

Reviewed: 14 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.