agentleFS
emvnuelemvnuel/skills/lombok-patterns/SKILL.md

lombok-patterns

Skill2 starsChanged 11 months agoMITView on GitHub

Lombok annotations and best practices for Java 21+ projects. Use when reducing boilerplate, configuring builders, or choosing between Lombok and Records.

The file

We split this skill into the rules it gives an agent

5 rules. About 0 are common, 1 is distinctive, and 4 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈1

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 4

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    @Slf4j: No Java equivalent for logger generation

    line 32
  2. Distinctive:

    Use Java Records for simple value objects and DTOs

    line 156
  3. Very specific:

    Use @RequiredArgsConstructor with final fields for dependency injection

    line 157
  4. Very specific:

    Use @Slf4j for logging instead of manual logger creation

    line 158
  5. Very specific:

    Use @Builder for classes with many optional fields

    line 159

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Lombok Patterns

This skill provides guidance on using Project Lombok to reduce boilerplate code in Java applications, covering annotations, best practices, and integration patterns.

Note: This guide targets Java 21+ projects. Some Lombok features are now obsolete due to modern Java features (Records, var, try-with-resources). See Java 21+ Considerations below.

Overview

Lombok is a Java library that automatically generates common code like getters, setters, constructors, builders, and more during compilation. It helps create cleaner, more maintainable code.

Java 21+ Considerations

Some Lombok features are now redundant with modern Java:

Lombok FeatureJava AlternativeRecommendation
val/varvar (Java 10+)Use Java var
@Valuerecord (Java 16+)Prefer records for simple value objects
@Datarecord (Java 16+)Prefer records for simple DTOs
@Cleanuptry-with-resources (Java 7+)Use try-with-resources
@Withrecord wither methodsRecords can define wither methods

When Lombok Still Adds Value

  • JPA Entities: Records don't work with JPA (need no-arg constructor, mutable state)
  • @Builder: Records don't have built-in builder support
  • @Slf4j: No Java equivalent for logger generation
  • @RequiredArgsConstructor: Useful for Spring dependency injection
  • Inheritance: Records can't extend classes

Annotation Categories

Core Annotations (Still Valuable)

AnnotationPurposeUse Case
@Getter/@SetterAccessor methodsJPA entities, mutable classes
@NoArgsConstructorNo-argument constructorJPA entities, serialization
@AllArgsConstructorAll-fields constructorDependency injection
@RequiredArgsConstructorConstructor for final/@NonNull fieldsSpring services
@BuilderBuilder pattern implementationComplex object construction

Consider Java Records Instead

LombokUse Java Record When
@ValueSimple immutable data carriers
@DataSimple DTOs without inheritance
// ✅ Prefer Java Record for simple value objects
public record Money(BigDecimal amount, String currency) {}

// ✅ Prefer Java Record for simple DTOs
public record CustomerDTO(String name, String email) {}

// ✅ Use Lombok for JPA entities (records don't work with JPA)
@Entity
@Getter
@Setter
@NoArgsConstructor
public class Customer {
    @Id private Long id;
    private String name;
}

Logging Annotations

AnnotationLogger Type
@Slf4jSLF4J (recommended)
@Log4j2Log4j 2
@Logjava.util.logging
@CommonsLogApache Commons Logging

Field & Method Annotations

AnnotationPurpose
@NonNullNull checks on parameters/fields
@WithImmutable setters (creates new instance)
@SneakyThrowsThrow checked exceptions without declaration
@SynchronizedThread-safe method synchronization
@ToStringCustomizable toString() generation
@EqualsAndHashCodeCustomizable equals/hashCode

Quick Reference

JPA Entities (Lombok Recommended)

@Entity
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(onlyExplicitlyIncluded = true)
public class Product {
    @Id
    @EqualsAndHashCode.Include
    private Long id;

    private String name;
    private BigDecimal price;
}

Spring Services

@Service
@RequiredArgsConstructor
@Slf4j
public class OrderService {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;

    public Order process(Order order) {
        log.info("Processing order: {}", order.getId());
        return orderRepository.save(order);
    }
}

Builder Pattern (Lombok Adds Value)

// Records don't have builder support - use Lombok
@Builder
public record Email(
    String to,
    String subject,
    String body,
    @Singular List<String> attachments
) {}

// Usage
Email email = Email.builder()
    .to("user@example.com")
    .subject("Hello")
    .body("Content")
    .attachment("file1.pdf")
    .build();

Best Practices

✅ Do

  • Use Java Records for simple value objects and DTOs
  • Use @RequiredArgsConstructor with final fields for dependency injection
  • Use @Slf4j for logging instead of manual logger creation
  • Use @Builder for classes with many optional fields
  • Be explicit with @EqualsAndHashCode on JPA entities

❌ Avoid

  • Using @Data or @Value when a Java Record would suffice
  • Using @Data on JPA entities (use individual annotations)
  • Using @EqualsAndHashCode with lazy-loaded JPA relationships
  • Overusing @SneakyThrows (makes exception handling unclear)

Common Pitfalls

PitfallProblemSolution
@Data on entitiesIncludes mutable setters, problematic equals/hashCodeUse @Getter, @Setter, explicit @EqualsAndHashCode
Missing @NoArgsConstructorJPA/Jackson need no-arg constructorAlways add with @AllArgsConstructor
Circular @ToStringStackOverflow with bidirectional relationshipsUse @ToString.Exclude on one side
Using Lombok for simple DTOsAdds unnecessary dependencyUse Java Records instead

Cookbook Index

Core Annotations

  • data-annotation - @Data (consider Records instead)
  • value-annotation - @Value (consider Records instead)
  • getter-setter - @Getter and @Setter
  • constructor-annotations - Constructor generation
  • builder-annotation - Builder pattern with @Builder
  • logging-annotations - Logger generation

Field & Method Annotations

  • non-null - Null checking with @NonNull
  • with-annotation - Immutable setters with @With
  • sneaky-throws - Checked exception handling
  • synchronized-annotation - Thread safety

Integration Patterns

  • entity-patterns - JPA/Hibernate best practices
  • equals-hashcode-jpa - Entity identity
  • dependency-injection - Spring constructor injection
  • configuration-properties - Spring Boot configuration

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.