Use when you need to apply data-oriented programming best practices in Java — including separating code (behavior) from data structures using records, designing immutable data with pure transformation functions, keeping data flat and denormalized with ID-based references, starting with generic data structures converting to specific types when needed, ensuring data integrity through pure validation functions, and creating flexible generic data access layers. Part of the skills-for-java project
68
60%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/144-java-data-oriented-programming/SKILL.mdQuality
Discovery
85%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 description that clearly defines both what the skill does and when to use it, with a well-scoped niche around data-oriented programming in Java. Its main weakness is that the trigger terms lean toward technical jargon that may not match how users naturally phrase their requests. The description also uses second person ('you need to') in the 'Use when' clause, though this is a common pattern in trigger guidance.
Suggestions
Add more natural user-facing trigger terms such as 'DOP', 'Java records best practices', 'functional data modeling in Java', or 'value objects' to improve discoverability for varied phrasings.
Rephrase to third person voice (e.g., 'Applies data-oriented programming best practices in Java...') instead of second person ('you need to') to align with style guidelines.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description lists multiple specific concrete actions: separating code from data using records, designing immutable data with pure transformation functions, keeping data flat and denormalized with ID-based references, starting with generic data structures, ensuring data integrity through pure validation functions, and creating flexible generic data access layers. | 3 / 3 |
Completeness | The description explicitly starts with 'Use when you need to apply data-oriented programming best practices in Java' which clearly answers the 'when' question, and the rest of the description thoroughly answers 'what' by listing the specific practices and techniques covered. | 3 / 3 |
Trigger Term Quality | It includes relevant terms like 'Java', 'records', 'immutable data', 'denormalized', 'pure functions', 'validation functions', and 'data-oriented programming', but these are somewhat technical. Users might more naturally say things like 'Java records', 'DOP', 'value objects', or 'functional Java' which aren't all covered. The terms skew toward jargon rather than natural user language. | 2 / 3 |
Distinctiveness Conflict Risk | The description carves out a very specific niche — data-oriented programming in Java — with distinct triggers like 'records', 'immutable data', 'ID-based references', 'pure transformation functions', and 'generic data access layers'. This is unlikely to conflict with general Java skills or other programming paradigm skills. | 3 / 3 |
Total | 11 / 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 is essentially a thin wrapper around a reference file, providing almost no actionable guidance in the body itself. While it has reasonable compilation safety constraints and a clear reference link, it lacks any concrete code examples (good/bad patterns), specific refactoring steps, or executable guidance. The 'When to use this skill' section contains duplicate entries, and the introductory content is redundant between the first paragraph and the bullet list.
Suggestions
Add at least 2-3 concrete before/after code examples directly in the SKILL.md showing key DOP patterns (e.g., record vs mutable class, pure transformation function vs stateful method) so Claude has actionable guidance without needing to read the reference file.
Define a clear step-by-step refactoring workflow: e.g., 1) Compile, 2) Identify mutable data classes, 3) Convert to records, 4) Extract behavior to utility classes, 5) Replace nested objects with ID references, 6) Verify.
Remove duplicate entries in the 'When to use this skill' section and trim the redundant opening paragraph that restates the bullet list.
Include a brief 'Quick start' section with a single concrete transformation example (input code → output code) that demonstrates the most common DOP refactoring pattern.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill has some redundancy — the opening paragraph largely repeats the bullet list that follows, and the 'When to use this skill' section contains duplicate entries. The introductory explanation of what DOP is could be trimmed since Claude already understands these concepts. | 2 / 3 |
Actionability | There are no concrete code examples, no executable commands beyond compile/verify, and no specific patterns shown. All actual guidance is deferred to the reference file. The skill body describes rather than instructs — it tells Claude what DOP is but not how to apply it with concrete examples. | 1 / 3 |
Workflow Clarity | The constraints section provides a clear compile-before/verify-after sequence with a blocking condition on compilation failure, which is good. However, the actual transformation workflow (how to identify code to refactor, what steps to take, in what order) is entirely absent — the skill just says 'read the reference' without sequencing the refactoring process itself. | 2 / 3 |
Progressive Disclosure | There is a clear reference to a single detailed file, which is appropriate one-level-deep disclosure. However, the SKILL.md itself contains too little actionable content — it's essentially just a table of contents with constraints, pushing nearly all value to the reference file without providing a useful quick-start or summary of key patterns. | 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.
9ec21dd
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.