Use when you need to analyze Java profiling data collected during the detection phase — including interpreting flamegraphs, memory allocation patterns, CPU hotspots, threading issues, systematic problem categorization, evidence documentation with profiling-problem-analysis and profiling-solutions markdown files, or prioritizing fixes using Impact/Effort scoring. This should trigger for requests such as Analyze JFR profile; Analyze the profile; Analyze the performance; Analyze the memory. Part of cursor-rules-java project
59
67%
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 ./skills/162-java-profiling-analyze/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 a strong skill description that clearly defines its scope (Java profiling data analysis), lists specific concrete capabilities, and provides explicit trigger guidance with example phrases. It effectively combines a 'Use when' clause with natural trigger terms and domain-specific terminology that makes it highly distinguishable from other skills.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: interpreting flamegraphs, memory allocation patterns, CPU hotspots, threading issues, systematic problem categorization, evidence documentation with specific markdown files, and prioritizing fixes using Impact/Effort scoring. | 3 / 3 |
Completeness | Clearly answers both 'what' (analyze Java profiling data including flamegraphs, memory patterns, CPU hotspots, threading issues, documentation, prioritization) and 'when' (explicit 'Use when' clause at the start plus 'This should trigger for requests such as' with concrete examples). | 3 / 3 |
Trigger Term Quality | Includes strong natural trigger terms users would say: 'Analyze JFR profile', 'Analyze the profile', 'Analyze the performance', 'Analyze the memory', plus domain terms like 'flamegraphs', 'CPU hotspots', 'threading issues', 'memory allocation patterns'. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive with a clear niche: Java profiling analysis specifically from a detection phase, with unique identifiers like JFR profiles, flamegraphs, Impact/Effort scoring, and specific markdown file outputs. Unlikely to conflict with other skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
35%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill provides a reasonable structural overview of Java profiling analysis but lacks the concrete, executable guidance needed to be truly actionable — no code snippets, no specific commands for parsing JFR files or flamegraphs, no example output formats. It relies almost entirely on a reference file for actual instructions, making the SKILL.md body more of a table of contents than a working guide. There is also notable redundancy between the intro paragraph, the 'What is covered' section, the constraints, and the workflow.
Suggestions
Add concrete, executable examples: show a specific command to parse a JFR file (e.g., `jfr print --events jdk.ObjectAllocationSample recording.jfr`), how to identify a hotspot in a flamegraph, or a grep/search pattern for GC log analysis.
Include a concrete example of the Impact/Effort scoring table or a snippet from the expected profiling-problem-analysis-YYYYMMDD.md template so Claude knows the exact output format.
Add a validation checkpoint between steps 3 and 4 — e.g., 'Verify at least 2 profiling sources corroborate each finding before documenting it as confirmed.'
Eliminate redundancy: the intro paragraph, 'What is covered' section, and constraints all repeat the same points (validate realistic load, cross-reference, document assumptions). Consolidate into one concise section.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill has some redundancy — the constraints section repeats points already made in the intro paragraph (validate realistic load, cross-reference multiple files, document assumptions). The 'What is covered' section and the workflow overlap significantly. However, it's not excessively verbose and doesn't explain concepts Claude already knows. | 2 / 3 |
Actionability | The skill provides no concrete code, commands, or executable examples. The workflow steps are abstract directions ('Analyze memory/CPU/threading findings', 'inventory profiling artifacts') without showing how to actually parse a JFR file, read a flamegraph SVG, or extract metrics. All real guidance is deferred to the reference file, making the skill body itself vague. | 1 / 3 |
Workflow Clarity | The four workflow steps provide a reasonable sequence (read reference → validate → analyze → document), but they lack validation checkpoints, feedback loops, and concrete details. Step 2 says 'confirm datasets represent realistic load' but doesn't explain how to validate this. There's no error recovery or explicit checkpoint between analysis and documentation. | 2 / 3 |
Progressive Disclosure | The skill correctly references a single detailed file (references/162-java-profiling-analyze.md) and mentions output file paths. However, since no bundle files were provided, we can't verify the reference exists. The skill itself contains too much repeated summary content that could be trimmed, and the reference is mentioned both in constraints ('Read the reference for problem analysis') and in the Reference section, creating slight confusion about when to consult it. | 2 / 3 |
Total | 7 / 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.
26e9744
Table of Contents
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.