spring-boot-3 — Claude Code skill: Spring Boot 3 patterns
Rules an AI agent follows when it writes or refactors a Spring Boot 3 service: configuration, dependency injection and the web layer.
MIT 143 installs ★ 678 updated 2026-03-28
npx skills add Gentleman-Programming/Gentleman-Skills --skill spring-boot-3 -a claude-codeWhat spring-boot-3 does
The skill pins down how beans are wired and where transactions sit. Constructor injection for every service, typed properties records with bean validation, @Transactional on service methods rather than on controllers. Two habits get flagged as wrong: field injection and scattered @Value lookups.
Samples show a controller that takes a request record and hands a command object to the service. Validation uses jakarta.validation, so that library has to be on the classpath for @NotBlank to compile. Property scanning comes from @ConfigurationPropertiesScan on the application class.
Install is a single npx skills add run, and SKILL.md lands in the platform's skills directory. After that the agent picks it up on its own once you ask for a new endpoint or a cleanup.
What it helps with
- replace scattered
@Valuefields with one validated properties record - move services to constructor injection
- keep
@Transactionalon service methods, out of controllers - add a REST controller with request and response records
- catch field injection during a refactor
Example prompts for the agent
- Add a
PaymentPropertiesrecord with@ConfigurationProperties(prefix = "payment")and@NotBlankon the fields. - Refactor
OrderServiceto constructor injection and put@TransactionalonplaceOrder. - Review the controllers and services for field injection.
How to install spring-boot-3
1Skills CLI (Vercel)
npx skills add Gentleman-Programming/Gentleman-Skills --skill spring-boot-3 -a claude-code2Manually: put the files in place
~/.claude/skills/spring-boot-3/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/spring-boot-3/
1Skills CLI (Vercel)
npx skills add Gentleman-Programming/Gentleman-Skills --skill spring-boot-3 -a codex2Manually: put the files in place
.agents/skills/spring-boot-3/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add Gentleman-Programming/Gentleman-Skills --skill spring-boot-3 -a cursor2Manually: put the files in place
.cursor/skills/spring-boot-3/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install Gentleman-Programming/Gentleman-Skills community/spring-boot-3/SKILL.md2Manually: put the files in place
.github/skills/spring-boot-3/SKILL.md1Skills CLI (Vercel)
npx skills add Gentleman-Programming/Gentleman-Skills --skill spring-boot-3 -a gemini-cli2Platform CLI
gemini skills install https://github.com/Gentleman-Programming/Gentleman-Skills --path community/spring-boot-3Manually: put the files in place
.devin/skills/spring-boot-3/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add Gentleman-Programming/Gentleman-Skills --skill spring-boot-3 -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about spring-boot-3
How to install spring-boot-3 in Claude Code?
Run npx skills add Gentleman-Programming/Gentleman-Skills --skill spring-boot-3 -a claude-code. The skill file then sits at ~/.claude/skills/spring-boot-3/SKILL.md.
What does spring-boot-3 do?
It gives the agent Spring Boot 3 conventions to follow: constructor injection, validated properties records, transaction boundaries on services, and thin controllers built on DTO records.
Which Spring Boot version does it target?
Services on 3.3 and newer. The samples rely on records, jakarta.validation and @ConfigurationPropertiesScan.
Source text
SKILL.md · MIT
---
name: spring-boot-3
description: >
Spring Boot 3 patterns for configuration, DI, and web services.
Trigger: When building or refactoring Spring Boot 3 applications.
metadata:
author: diegnghrmr
version: "1.0"
---
## When to Use
Load this skill when:
- Building a Spring Boot 3.3+ service or API
- Wiring beans with dependency injection
- Defining configuration properties and validation
- Implementing REST controllers and service layers
## Critical Patterns
### Pattern 1: Constructor injection only
Always use constructor injection; avoid field injection.
### Pattern 2: Typed configuration properties
Use @ConfigurationProperties with validation, not scattered @Value.
### Pattern 3: Transaction boundaries at service layer
Apply @Transactional on application services, not controllers.
## Code Examples
### Example 1: Configuration properties with validation
```java
package com.acme.config;
import jakarta.validation.constraints.NotBlank;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.validation.annotation.Validated;
@Validated
@ConfigurationProperties(prefix = "payment")
public record PaymentProperties(
@NotBlank String provider,
@NotBlank String apiKey
) { }
```
```java
package com.acme;
import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@ConfigurationPropertiesScan
public class Application { }
```
### Example 2: Service with constructor injection + transaction
```java
package com.acme.order.application;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public final class OrderService {
private final OrderRepository repository;
public OrderService(OrderRepository repository) {
this.repository = repository;
}
@Transactional
public void placeOrder(OrderCommand command) {
repository.save(command.toEntity());
}
}
```
### Example 3: REST controller with DTO records
```java
package com.acme.order.api;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/orders")
public final class OrderController {
private final OrderService service;
public OrderController(OrderService service) {
this.service = service;
}
@PostMapping
public ResponseEntity<OrderResponse> place(@RequestBody OrderRequest request) {
service.placeOrder(request.toCommand());
return ResponseEntity.ok(new OrderResponse("ok"));
}
public record OrderRequest(String sku, int qty) {
public OrderCommand toCommand() { return new OrderCommand(sku, qty); }
}
public record OrderResponse(String status) { }
}
```
## Anti-Patterns
### Don't: Use field injection
```java
// BAD: field injection
@Service
public class OrderService {
@org.springframework.beans.factory.annotation.Autowired
private OrderRepository repository;
}
```
### Don't: Scatter configuration with @Value
```java
// BAD: hard to validate and test
@Service
public class PaymentService {
@org.springframework.beans.factory.annotation.Value("${payment.apiKey}")
private String apiKey;
}
```
## Quick Reference
| Task | Pattern |
|------|---------|
| Inject dependencies | Constructor injection only |
| Read config | @ConfigurationProperties + @Validated |
| Transactions | @Transactional on services |
## Resources
- Spring Boot Reference: https://docs.spring.io/spring-boot/docs/current/reference/html/
- Spring Framework Reference: https://docs.spring.io/spring-framework/reference/
© diegnghrmr · MIT · Gentleman-Programming/Gentleman-Skills