If a member is annotated, it must be either a constructor or a static method. If a class is annotated, then a private constructor is generated with all fields as arguments (as if @AllArgsConstructor(AccessLevel.PRIVATE) is present on the class), and it is as if this constructor has been annotated with @Builder instead.

The effect of @Builder is that an inner class is generated named TBuilder, with a private constructor. Instances of TBuilder are made with the static method named builder() which is also generated for you in the class itself (not in the builder class).

The TBuilder class contains 1 method for each parameter of the annotated constructor / static method (each field, when annotating a class), which returns the builder itself. The builder also has a build() method which returns a completed instance of the original type, created by passing all parameters as set via the various other methods in the builder to the constructor or static method that was annotated with @Builder. The return type of this method will be the same as the relevant class, unless a static method has been annotated, in which case it'll be equal to the return type of that method.

Complete documentation is found at the project lombok features page for @Builder.

Before:

 @Builder
 class Example {
        private int foo;
        private final String bar;
 }
 

 class Example<T> {
        private T foo;
        private final String bar;
        
        private Example(T foo, String bar) {
                this.foo = foo;
                this.bar = bar;
        }
        
        public static <T> ExampleBuilder<T> builder() {
                return new ExampleBuilder<T>();
        }
        
        public static class ExampleBuilder<T> {
                private T foo;
                private String bar;
                
                private ExampleBuilder() {}
                
                public ExampleBuilder foo(T foo) {
                        this.foo = foo;
                        return this;
                }
                
                public ExampleBuilder bar(String bar) {
                        this.bar = bar;
                        return this;
                }
                
                @java.lang.Override public String toString() {
                        return "ExampleBuilder(foo = " + foo + ", bar = " + bar + ")";
                }
                
                public Example build() {
                        return new Example(foo, bar);
                }
        }
 }