121-java-object-oriented-design
Use when reviewing, improving, or refactoring Java object-oriented design, including applying SOLID, DRY, or YAGNI; improving classes and interfaces; correcting encapsulation, inheritance, or polymorphism; resolving God Class, Feature Envy, or Data Clumps; and improving object creation, methods, or…
Install / Use
npx skills add jabrena/plinth --skill 121-java-object-oriented-designInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
LegalSupported Platforms
Our assessment of 121-java-object-oriented-design
121-java-object-oriented-design scores 81/100 on our quality scale, 186th of 210 Legal skills we index.
Its SKILL.md is 8.2 KB long, split into 5 sections and no code examples: a thorough specification that gives an agent plenty to work with.
It has 441 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so 121-java-object-oriented-design is actively maintained.
- Our last check on 2026-11-08 found the source still online.
- It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-26. Automated pattern scan on 2026-10-26. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
121-java-object-oriented-design compared with similar skills
All 4 of these similar skills score higher than 121-java-object-oriented-design; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| 121-java-object-oriented-design (this skill)by jabrena | 81 | 441 | 2mo ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 118.3k | 10d ago | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 40.1k | 9d ago | CLAUDE.md |
| algorithmic-artby anthropics | 100 | 177.9k | 57d ago | SKILL.md |
| pptxby anthropics | 100 | 177.9k | 57d ago | SKILL.md |
Frequently asked questions
- How do I install 121-java-object-oriented-design?
- Run
npx skills add jabrena/plinth --skill 121-java-object-oriented-design. The install tabs above show the steps for each supported agent. - Which AI agents does 121-java-object-oriented-design work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is 121-java-object-oriented-design safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is 121-java-object-oriented-design still maintained?
- The repository was last updated about 2 months ago, so 121-java-object-oriented-design is actively maintained.
Skill content
View source on GitHubname: 121-java-object-oriented-design description: Use when reviewing, improving, or refactoring Java object-oriented design, including applying SOLID, DRY, or YAGNI; improving classes and interfaces; correcting encapsulation, inheritance, or polymorphism; resolving God Class, Feature Envy, or Data Clumps; and improving object creation, methods, or exception contracts. Triggers include review Java OOD, refactor Java OOD, improve Java OOD, fix OOP misuse, and identify Java code smells. Part of Plinth Toolkit license: Apache-2.0 metadata: author: Juan Antonio Breña Moral version: 0.19.0
Java Object-Oriented Design Guidelines
Review and improve Java code using focused object-oriented design references selected after assessing the request and affected code.
What is covered in this Skill?
- Fundamental design principles (SOLID, DRY, YAGNI)
- Class and interface design: composition over inheritance, immutability, accessibility minimization, accessor methods
- Core OOP concepts: encapsulation, inheritance, polymorphism
- Object creation patterns: static factory methods, Builder, Singleton, dependency injection, avoiding unnecessary objects
- OOD code smells: God Class, Feature Envy, Inappropriate Intimacy, Refused Bequest, Shotgun Surgery, Data Clumps
- Method design: parameter validation, defensive copies, careful signatures, empty collections over nulls, Optional usage
- Exception handling: checked vs. runtime exceptions, standard exceptions, failure-capture messages, no silent ignoring
Scope: Classify the applicable OOD concerns first, then load only the focused references needed for those concerns. Load multiple references when a refactoring crosses concern boundaries.
Constraints
Before applying any OOD changes, ensure the project compiles. If compilation fails, stop immediately — do not proceed until resolved. After applying improvements, run full verification.
- MANDATORY: Run
./mvnw compileormvn compilebefore applying any change - SAFETY: If compilation fails, stop immediately and do not proceed — compilation failure is a blocking condition
- VERIFY: Run
./mvnw clean verifyormvn clean verifyafter applying improvements - PROGRESSIVE DISCLOSURE: Classify the applicable OOD concerns before reading references, then read only the references mapped to those concerns
- MULTI-CONCERN CHANGES: Read multiple focused references only when the request or diagnosed code problems cross concern boundaries
- PRESERVE BEHAVIOR: Apply focused, incremental refactorings without changing observable business behavior
- INCREMENTAL SAFETY: Compile after each significant refactoring and keep changes easy to revert if validation reveals a regression
- DEPENDENCY SAFETY: Confirm refactoring does not break imports, dependencies, class relationships, or established contracts
- ADJACENT SKILLS: Use skill 122 for dedicated type-design work and skill 126 for dedicated exception-handling work; use the overlapping skill 121 references only when those topics are part of a broader OOD review
- EDGE CASE: If request scope is ambiguous, stop and ask a clarifying question before applying changes
- EDGE CASE: If required inputs, files, or tooling are missing, report what is missing and ask whether to proceed with setup guidance
When to use this skill
- Review Java code for object-oriented design
- Refactor Java code for object-oriented design
- Improve Java code for object-oriented design
- Fix OOP concept misuse in Java code
- Identify and resolve code smells in Java code
- Improve object creation patterns in Java code
- Improve method design in Java code
- Improve exception handling in Java code
Workflow
- Compile project before OOD changes
Run ./mvnw compile or mvn compile and stop immediately if compilation fails.
- Assess code and classify OOD concerns
Analyze the request and affected Java code before reading implementation guidance. Classify each relevant problem into one or more concerns:
- Fundamental principles: SOLID, DRY, or YAGNI violations.
- Core OOP concepts: encapsulation, inheritance, or polymorphism misuse.
- Code smells: God Class, Feature Envy, Inappropriate Intimacy, Refused Bequest, Shotgun Surgery, or Data Clumps.
- Object creation: factories, builders, singletons, dependency injection, or unnecessary object creation.
- Classes and interfaces: accessibility, public fields, mutability, composition, or inheritance design.
- Enums and annotations: int constants, ordinals, bit fields, ordinal indexing, or missing
@Override. - Methods: parameter validation, defensive copies, signatures, null collections, or
Optional. - Exceptions: exception contracts that are part of the broader OOD review.
If the request is dedicated type-design work, use skill 122. If it is dedicated exception-handling work, use skill 126.
- Read only applicable OOD references
Map the classified concerns to focused references:
- For SOLID, DRY, or YAGNI, read
references/121-java-object-oriented-design-principles.md. - For encapsulation, inheritance, or polymorphism, read
references/121-java-object-oriented-design-oop-concepts.md. - For object-oriented code smells, read
references/121-java-object-oriented-design-code-smells.md. - For factories, builders, singletons, dependency injection, or unnecessary objects, read
references/121-java-object-oriented-design-object-creation.md. - For class and interface boundaries, accessibility, mutability, composition, or inheritance design, read
references/121-java-object-oriented-design-classes-interfaces.md. - For enums, ordinals, bit fields, enum lookup, or
@Override, readreferences/121-java-object-oriented-design-enums-annotations.md. - For method contracts, validation, defensive copies, signatures, collection returns, or
Optional, readreferences/121-java-object-oriented-design-methods.md. - For exception contracts within a broader OOD review, read
references/121-java-object-oriented-design-exceptions.md.
Read every reference required by a cross-concern refactoring, but do not read unrelated references.
- Apply focused refactorings
Prioritize findings by impact: CRITICAL, MAINTAINABILITY, FLEXIBILITY, or CODE_QUALITY. Apply the smallest suitable refactoring for each diagnosed concern while preserving observable behavior:
- Extract classes or methods to restore focused responsibilities.
- Introduce or refine abstractions for extension, interface segregation, and dependency inversion.
- Correct inheritance hierarchies to preserve substitutability, or replace inheritance with composition.
- Move behavior to eliminate Feature Envy and improve encapsulation.
- Introduce cohesive value or parameter objects for Data Clumps.
- Hide exposed state and reduce unnecessary coupling.
Apply changes incrementally and compile after each significant refactoring.
- Verify with full build
Run ./mvnw clean verify or mvn clean verify after applying improvements.
- Report applied OOD improvements
Report findings by impact and concern, focused references used, refactorings applied, maintainability/flexibility/testability benefits, behavior-preservation evidence, and the final compilation and test result.
Reference
For detailed guidance, examples, and constraints, see:
- references/121-java-object-oriented-design-principles.md
- references/121-java-object-oriented-design-oop-concepts.md
- references/121-java-object-oriented-design-code-smells.md
- references/121-java-object-oriented-design-object-creation.md
- references/121-java-object-oriented-design-classes-interfaces.md
- references/121-java-object-oriented-design-enums-annotations.md
- references/121-java-object-oriented-design-methods.md
- references/121-java-object-oriented-design-exceptions.md
Related Skills
taste-skill
118.3kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
Claude-Code-Game-Studios
40.1kTurn Claude Code into a full game dev studio — 49 AI agents, 75 workflow skills, and a complete coordination system mirroring real studio hierarchy.
algorithmic-art
177.9kCreating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems.
pptx
177.9kUse this skill any time a .pptx or .potx file is involved in any way — as input, output, or both. This includes: creating slide decks, pitch decks, or presentations; reading, parsing, or extracting text from any .pptx or .potx file (even if the extracted content will be used elsewhere, like in an em…
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
