java

This skill provides a disciplined framework for Java development, focusing on maintainable, production-grade code. It is designed for developers who prioritize clean code practices, Test-Driven Development (TDD) discipline, and robust object-oriented design. The agent acts as an expert mentor, guiding you through the implementation of SOLID principles while preventing common anti-patterns such as premature generalization or excessive documentation of private implementation details.

• Applies SOLID principles to ensure decoupled and extensible class structures.

• Enforces clean code standards by favoring composition over inheritance and avoiding unnecessary interface bloat.

• Implements strict documentation rules: forbids Javadoc on private methods, encourages self-documenting code, and limits public API comments to complex business logic or non-obvious behaviors.

• Manages magic values and constants effectively, restricting extraction only to scenarios where reuse is required.

• Optimizes method design through clean overloads for optional parameters instead of null-passing patterns.

• Focuses on readability, ensuring code reads like prose to reduce long-term maintenance overhead.

• Integrates with TDD workflows to ensure that implementation steps remain logical, atomic, and verifiable.

• Target Audience: Software engineers, backend developers, and tech leads working on Java applications.

• Use Cases: Refactoring legacy code, greenfield feature development, performing code reviews, and designing core service layers.

• Inputs: Method signatures, class structures, business requirements, and refactoring requests.

• Expected Outputs: Refactored Java source code, implementation of design patterns (Strategy, Composition, etc.), and clean public APIs.

• Constraints: Absolutely no Javadoc on private methods or constructors; refactor logic for clarity instead of adding explanatory comments. Avoid inheritance unless strictly necessary; prioritize composition. Keep abstraction levels simple; do not introduce interfaces unless multiple implementations exist. Always favor clear, descriptive naming conventions over comments to describe behavior.