Skip to main content
plugin

piomin-spring-boot-template — Claude Code plugin

piomin-spring-boot-template — a Claude Code plugin that adds Spring Boot 4.x and Java 21+ expertise. Six agents and eight skills guide Claude through REST APIs, JPA, security, testing, and Kubernetes—all following production conventions.

Apache-2.0 ★ 1,467 updated 2026-10-21

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add anthropics/claude-plugins-community
/plugin install piomin-spring-boot-template@claude-community
Open on GitHub

What piomin-spring-boot-template does

The plugin ships six agents: spring-boot-engineer builds layered Spring Boot applications, code-reviewer checks correctness and conventions, kubernetes-specialist handles K8s deployments with probes and ConfigMap/Secret, devops-engineer sets up CI/CD and Paketo Buildpacks, docker-expert optimizes multi-stage Dockerfiles, and security-engineer covers Spring Security and OWASP patterns.

Eight skills encode project rules: no Lombok, constructor injection only, RestClient for blocking HTTP, Testcontainers with @ServiceConnection, Jakarta Persistence, Maven groupId pl.piomin.services. The plugin covers Spring Cloud, OpenTelemetry OTLP, Java 21 virtual threads, Kubernetes mTLS with cert-manager, Config Tree for mounted secrets, Paketo Buildpacks, and Skaffold for local development loops.

After install, describe what you need—Claude picks the right agents and activates relevant skills on its own. You can also invoke skills or agents directly via slash commands or mentions.

What it helps with

  • Generate a REST API with PostgreSQL following Spring Boot conventions
  • Review code for Spring Security vulnerabilities and best practices
  • Deploy to Kubernetes with OpenTelemetry, ConfigMap, and graceful shutdown
  • Build a multi-stage Dockerfile using Paketo Buildpacks
  • Write integration tests with Testcontainers and MockMvc

Example prompts for the agent

  • Build a REST API for order management with PostgreSQL and JPA
  • /spring-boot-template:jpa-patterns — show me how to avoid N+1 queries and lazy loading issues
  • @agent-spring-boot-template:kubernetes-specialist — help me deploy this app to K8s with Prometheus and mTLS

How to install piomin-spring-boot-template

Plugin marketplace

/plugin marketplace add anthropics/claude-plugins-community
/plugin install piomin-spring-boot-template@claude-community

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about piomin-spring-boot-template

How do I install piomin-spring-boot-template in Claude Code?

Run /plugin marketplace add anthropics/claude-plugins-community, then /plugin install piomin-spring-boot-template@claude-community. Alternatively, clone the repository and launch Claude with --plugin-dir /path/to/claude-ai-spring-boot.

What does piomin-spring-boot-template do?

It equips Claude Code with knowledge of Spring Boot 4.x, Java 21+, modern patterns (JPA, testing, security), and cloud technologies (Kubernetes, OpenTelemetry, GraalVM). Six agents handle specific domains: architecture, code review, Kubernetes, CI/CD, Docker, and security.

What coding conventions does the plugin enforce?

The conventions skill mandates no Lombok, constructor injection, RestClient over RestTemplate, Testcontainers with @ServiceConnection, Jakarta Persistence, Maven with pl.piomin.services, and Docker Compose for local dependencies.

Source text

SKILL.md · Apache-2.0
# Spring Boot Plugin for Claude Code (v1.0)

A Claude Code plugin with production-ready skills and agents for building Spring Boot 4.x / Java 21+ applications. Install the plugin and start generating your app — the skills and agents guide Claude to follow best practices for REST APIs, JPA, security, testing, cloud-native deployment, and Kubernetes.

## Installation

Install from Anthropic marketplace

```bash
claude plugin install spring-boot-template@piomin
```

Or install directly from repository

``` 
claude plugin marketplace add https://github.com/piomin/claude-ai-spring-boot.git
claude plugin install spring-boot-template@piomin
```

To test locally during development:

```bash
claude --plugin-dir /path/to/claude-ai-spring-boot
```

## What's Included

### Agents (`agents/`)

Specialized agents that Claude Code can invoke for specific tasks:

| Agent | Purpose |
|-------|---------|
| `spring-boot-engineer` | Build Spring Boot 4.x apps with layered architecture |
| `code-reviewer` | Review code for correctness, security, Spring Boot conventions |
| `kubernetes-specialist` | K8s deployments, probes, ConfigMap/Secret, Prometheus, Skaffold |
| `devops-engineer` | CI/CD pipelines, Paketo Buildpacks, Skaffold |
| `docker-expert` | Multi-stage Dockerfiles, Paketo Buildpacks, image optimization |
| `security-engineer` | Spring Security, OWASP, input validation, SSL Bundles |

### Skills (`skills/`)

Reusable knowledge that Claude loads contextually:

| Skill | What it teaches |
|-------|-----------------|
| `conventions` | Mandatory project rules: No Lombok, constructor injection, RestClient, testing standards |
| `spring-boot` | Core Spring Boot development with 5 reference guides (web, data, security, cloud, testing) |
| `code-quality` | Clean code principles, API contracts, null safety, exception handling |
| `design-patterns` | Classic patterns (Factory, Builder, Strategy) + enterprise (Saga, Outbox, CQRS) |
| `testing-patterns` | JUnit 5, Mockito, MockMvc, RestTestClient, Testcontainers with @ServiceConnection |
| `java-modern` | Java 21+ features: records, sealed classes, pattern matching, virtual threads |
| `jpa-patterns` | JPA/Hibernate pitfalls (N+1, lazy loading), Hibernate 6/7, optimistic locking |
| `logging-patterns` | Structured JSON logging, SLF4J, MDC, AI-friendly formats |

### Key Conventions

The plugin enforces these rules via the `conventions` skill:

- **No Lombok** — explicit constructors, getters/setters, `LoggerFactory.getLogger()`
- **Constructor injection** — no `@Autowired` on fields
- **RestClient** over RestTemplate/WebClient for blocking HTTP calls
- **RestTestClient** with `@AutoConfigureRestTestClient` for integration tests
- **Testcontainers** with `@ServiceConnection` (not `@DynamicPropertySource`)
- **Jakarta Persistence** (not `javax.persistence`)
- **Maven** with `pl.piomin.services` group ID
- **CI pipeline** — auto-detected from existing project config
- **Docker Compose** for local dependencies

### Cloud-Native Coverage

The `cloud.md` reference covers:

- Spring Cloud (Config Server, Eureka, Gateway, Resilience4j, LoadBalancer)
- Distributed tracing with OpenTelemetry (OTLP) and Micrometer Observation API
- Virtual Threads, HTTP Interface Clients (`@HttpExchange`), GraalVM Native Image
- Kubernetes: ConfigMap/Secret with `envFrom`, Prometheus annotations, startup/liveness/readiness probes, `preStop` hook, graceful shutdown
- TLS: cert-manager (Ingress TLS + pod-level mTLS), SSL Bundles with hot reload
- Config Tree for reading mounted secrets from files
- Paketo Buildpacks via `spring-boot:build-image`
- Skaffold for local K8s development loop

## Usage

After installing, describe what you want to build — Claude will use the skills and agents automatically:

```bash
cd my-project
claude
> "Build a REST API for managing orders with PostgreSQL"
```

You can also invoke skills and agents directly:

```bash
# Invoke a skill
> /spring-boot-template:jpa-patterns

# Use an agent
> @agent-spring-boot-template:code-reviewer
```

## Directory Structure

```
.
├── .claude-plugin/
│   └── plugin.json
├── agents/
│   ├── code-reviewer.md
│   ├── devops-engineer.md
│   ├── docker-expert.md
│   ├── kubernetes-specialist.md
│   ├── security-engineer.md
│   └── spring-boot-engineer.md
├── skills/
│   ├── conventions/SKILL.md
│   ├── code-quality/SKILL.md
│   ├── design-patterns/SKILL.md
│   ├── java-modern/SKILL.md
│   ├── jpa-patterns/SKILL.md
│   ├── logging-patterns/SKILL.md
│   ├── spring-boot/
│   │   ├── SKILL.md
│   │   └── references/
│   │       ├── cloud.md
│   │       ├── data.md
│   │       ├── security.md
│   │       ├── testing.md
│   │       └── web.md
│   └── testing-patterns/SKILL.md
├── README.md
└── LICENSE
```

## Blog Post

You can find a detailed explanation of this plugin in the post: [Claude Code Template for Spring Boot](https://piotrminkowski.com/2026/03/24/claude-code-template-for-spring-boot/).

## License

Apache License 2.0

© piomin · Apache-2.0 · piomin/claude-ai-spring-boot

Similar plugins

All plugins for Backend and APIs →
spring-boot-engineer https://github.com/Jeffallan spring-boot-engineer generates Spring Boot 3.x code, JPA repositories, REST controllers, and Spring Security 6 configurations. Useful when writing Java microservices and reactive endpoints. CX Codex +1 8,900installs spring-boot-patterns decebals spring-boot-patterns — a skill that hands your agent the package layout and templates for Spring Boot controllers, services and repositories. Useful when new code gets written or reviewed. CX Codex +1 375installs spring-boot-crud-patterns giuseppe-trisciuoglio spring-boot-crud-patterns — a skill that builds the whole CRUD layer for Spring Boot 3 services: aggregates, JPA repositories, DTOs and REST controllers in a feature-based layout. CX Codex +1 4,100installs spring-boot-development manutej spring-boot-development — a skill that gives your coding agent a Spring Boot reference: auto-configuration, dependency injection, REST controllers, Spring Data and Spring Security. CX Codex +1 537installs spring-boot-backend-development-expert Giuseppe Trisciuoglio spring-boot-backend-development-expert — a Claude subagent for Spring Boot work: implements REST endpoints, JPA layers and JWT security, and writes the matching tests. CX Codex ★ 372repo stars java-spring-boot pluginagentmarketplace java-spring-boot generates production-grade Spring Boot 3.x code, covering REST controllers, Spring Security with JWT, Spring Data JPA repositories, and Actuator metrics. CX Codex +1 11,800installs

Project sponsors

Companies that keep this analytics open