125-java-concurrency
Use when you need to apply Java concurrency best practices — including thread safety fundamentals, ExecutorService thread pool management, concurrent design patterns like Producer-Consumer, asynchronous programming with CompletableFuture, immutability and safe publication, deadlock avoidance, virtual threads, scoped values, backpressure, cancellation discipline, and observability for concurrent systems. This should trigger for requests such as Review Java code for concurrency. Part of cursor-rules-java project
82
77%
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/125-java-concurrency/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 niche in Java concurrency best practices with extensive specific capabilities listed. It includes explicit 'Use when' guidance and natural trigger terms that Java developers would use. The only minor weakness is that it reads somewhat as a keyword list rather than organized capability groups, and the trailing 'Part of cursor-rules-java project' adds little selection value.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description lists many specific concrete actions and concepts: thread safety fundamentals, ExecutorService thread pool management, Producer-Consumer pattern, CompletableFuture, immutability, deadlock avoidance, virtual threads, scoped values, backpressure, cancellation discipline, and observability. These are highly specific capabilities. | 3 / 3 |
Completeness | The description explicitly answers both 'what' (apply Java concurrency best practices across many specific areas) and 'when' (opens with 'Use when you need to apply Java concurrency best practices' and includes an explicit trigger example 'Review Java code for concurrency'). Both are clearly stated. | 3 / 3 |
Trigger Term Quality | Includes many natural keywords a Java developer would use: 'thread safety', 'ExecutorService', 'thread pool', 'CompletableFuture', 'deadlock', 'virtual threads', 'concurrency', 'Producer-Consumer', 'backpressure'. The example trigger 'Review Java code for concurrency' is also natural. Good coverage of terms users would actually say. | 3 / 3 |
Distinctiveness Conflict Risk | The description is narrowly scoped to Java concurrency specifically, with highly distinctive trigger terms like 'ExecutorService', 'CompletableFuture', 'virtual threads', and 'deadlock avoidance'. This is unlikely to conflict with general Java skills or concurrency skills in other languages. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
54%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
The skill has a well-structured workflow with proper validation checkpoints and good progressive disclosure to a reference file. However, it is significantly weakened by verbose introductory content that lists concepts Claude already understands, and it lacks any concrete code examples in the body itself, making it more of a pointer than an actionable skill.
Suggestions
Remove or drastically shorten the 'What is covered' bullet list — Claude doesn't need a catalog of concurrency concepts it already knows. Replace with 1-2 sentences summarizing scope.
Add at least one or two concrete, executable code examples of the most common patterns (e.g., proper ExecutorService shutdown, CompletableFuture composition) directly in the skill body so it provides immediate value without requiring the reference file.
Remove the introductory sentence that explains what concurrency best practices are — this is knowledge Claude already has.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The 'What is covered' section is an extensive bullet list that essentially serves as a table of contents for concepts Claude already knows. The introductory sentence explains what concurrency best practices are, which is unnecessary. Much of this content is verbose padding that doesn't add actionable value. | 1 / 3 |
Actionability | The workflow provides concrete commands (./mvnw compile, ./mvnw clean verify) and references a detailed file, but the skill itself contains no executable code examples, no concrete patterns, and no copy-paste ready snippets. All actual guidance is deferred to the reference file. | 2 / 3 |
Workflow Clarity | The workflow is clearly sequenced with four explicit steps, includes a blocking validation checkpoint (compile before changes), a verification step after changes, and an explicit stop condition on failure. This is a well-structured feedback loop for a potentially destructive operation. | 3 / 3 |
Progressive Disclosure | The skill provides a clear overview and defers detailed examples and patterns to a single, well-signaled reference file (references/125-java-concurrency.md). Navigation is one level deep and clearly indicated. For a skill that delegates to a reference, this is appropriate structure. | 3 / 3 |
Total | 9 / 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
- jabrena/cursor-rules-java
- Commit
762cb86
- 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.