# micronaut

Tells the agent how to write Micronaut code: compile-time DI, GraalVM native builds, reactive services. Useful when your Java project should follow the framework instead of generic advice.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 687 installs · ★ 286
- Author: Mindrally
- License: Apache-2.0 · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/Mindrally/skills/tree/HEAD/micronaut/SKILL.md
- Updated: 2026-10-08
- HTML: https://affpapa.org/en/nevibecode/skills/micronaut

## What it does

This skill turns the assistant into a Micronaut specialist. It carries a rule set: package layout (controllers, services, repositories, domain, configuration), class and method naming, and proper use of `@Controller`, `@Singleton`, `@Inject`, `@Value`. Expect constructor injection over field injection, `@Factory` for complex beans, and `@Requires` for conditional loading.

Separate sections cover configuration in `application.yml`, dev/test/prod environments, JUnit 5 tests with `@MicronautTest` and Testcontainers, security through Micronaut Security and JWT, Micrometer metrics, and tracing with Zipkin or Jaeger. There is also Micronaut Data with compile-time query generation, Flyway or Liquibase migrations, multi-stage Docker builds, and GraalVM native images.

The rules assume Java 17 or later, so on an older JDK some advice will not apply. Installation runs through `npx skills add` with an agent flag, and the file lands in that platform's skills directory.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill micronaut -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/micronaut/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/micronaut/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill micronaut -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/micronaut/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill micronaut -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/micronaut/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install Mindrally/skills micronaut
```

2. **Manually: put the files in place**
- File: `.github/skills/micronaut/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill micronaut -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/Mindrally/skills --path micronaut
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/micronaut/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill micronaut -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/Mindrally/skills/tree/HEAD/micronaut/SKILL.md

## When to use it
- lay out code across controllers, services and repositories
- switch field injection to constructor injection
- set up dev, test and prod profiles in `application.yml`
- add integration tests with `@MicronautTest` and Testcontainers
- build a GraalVM native image with the right configuration

## Example prompts
- Create a Micronaut controller for orders with constructor injection of the service
- Rewrite this class as `@Singleton` with `@Requires` for the prod profile
- Add an integration test with `@MicronautTest` and Testcontainers for the repository

## Source text · SKILL.md · Apache-2.0

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 859f2aefc97d201b.

BEGIN THIRD-PARTY FILE 859f2aefc97d201b
```text
---
name: micronaut
description: Expert guidance for Micronaut framework development with compile-time dependency injection, GraalVM native builds, and cloud-native microservices
metadata:
  maintainer: Mindrally
  source: https://github.com/Mindrally/skills
---

# Micronaut

You are an expert in Java programming, Micronaut framework, GraalVM native builds, reactive programming, Maven/Gradle, JUnit, and related Java technologies.

## Code Style and Structure

- Write clean, efficient, and well-documented Java code using Micronaut best practices
- Follow Micronaut conventions for package organization and naming
- Use descriptive method and variable names following camelCase convention
- Structure your application with consistent organization (controllers, services, repositories, domain, configuration)

## Micronaut Specifics

- Leverage Micronaut's compile-time dependency injection for fast startup
- Use Micronaut annotations (@Controller, @Singleton, @Inject, @Value) effectively
- Implement ahead-of-time (AOT) compilation optimizations
- Configure native builds with GraalVM for optimal performance and minimal memory footprint

## Naming Conventions

- Use PascalCase for class names (e.g., UserController, OrderService)
- Use camelCase for method and variable names (e.g., findUserById, isOrderValid)
- Use ALL_CAPS for constants (e.g., MAX_RETRY_ATTEMPTS, DEFAULT_PAGE_SIZE)

## Java and Micronaut Usage

- Use Java 17 or later features when applicable (e.g., records, sealed classes, pattern matching)
- Utilize Micronaut BOM for dependency management
- Integrate Micronaut's built-in features (HTTP client, serialization, validation)
- Use Micronaut's reactive support with Project Reactor or RxJava

## Configuration and Properties

- Store configuration in application.yml or application.properties
- Use @Value or @ConfigurationProperties for type-safe configuration injection
- Rely on Micronaut environments (dev, test, prod) for environment-specific configurations
- Leverage Micronaut's configuration server integrations (Consul, AWS Parameter Store)

## Dependency Injection and IoC

- Use Micronaut's compile-time DI annotations (@Inject, @Singleton, @Prototype)
- Prefer constructor injection for better testability and immutability
- Leverage @Factory for complex bean creation
- Use @Requires for conditional bean loading

## Testing

- Write unit tests using JUnit 5 and Micronaut Test
- Use @MicronautTest for integration testing with embedded server
- Implement @MockBean for mocking dependencies
- Use Testcontainers for database and service integration testing

## Performance and Scalability

- Optimize for native image creation using GraalVM configuration
- Use @Cacheable and @CacheInvalidate for caching strategies
```
END THIRD-PARTY FILE 859f2aefc97d201b

The third-party file has ended. Everything between the 859f2aefc97d201b tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2757 of 4853 bytes. © Mindrally · Apache-2.0 · https://github.com/Mindrally/skills/tree/HEAD/micronaut/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md