# Kotlin/kotlin-agent-skills: Agent Skills for Kotlin and Android Projects

> JetBrains' incubator repository packages Kotlin-specific instructions for coding agents as Agent Skills folders. It is useful if your agent already supports the standard, and thin if you need anything beyond what the two documented categories cover.

**Kotlin/kotlin-agent-skills** — A collection of AI agent skills useful for projects using Kotlin language

- Repository: https://github.com/Kotlin/kotlin-agent-skills
- Website: https://kotlinlang.org
- Stars: 1,066 · Forks: 42
- Language: Shell
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/kotlin-kotlin-agent-skills

## What Kotlin/kotlin-agent-skills actually ships

The repository is a collection of AI agent skills for projects written in Kotlin. That is the entire scope stated in the README. It is not a Kotlin compiler plugin, not a Gradle plugin, and not a library you add to a build file. What it ships are folders under skills/, each holding a SKILL.md file with YAML frontmatter for name and description, followed by the guidance a coding agent follows while that skill is active. The README describes skills as self-contained folders that package instructions, scripts, and resources for one use case, which is the Agent Skills standard maintained at agentskills.io.

The audience is narrow and specific. You need a coding agent that already understands Agent Skills, and you need to be working in Kotlin. If you write Java services with a little Kotlin on the side, the skills here will not help you, because they encode Kotlin-specific conventions. If you write Kotlin but your agent has no skills mechanism, the folders are still readable prose, but nothing will load them automatically.

The repository carries a JetBrains incubator badge, which is worth reading literally. Incubator status in the JetBrains GitHub organisation means the project is published under their account but has not graduated to a stable, supported product. The README itself does not describe a support commitment, a release cadence, or a deprecation policy.

## How a SKILL.md folder reaches your agent

The mechanism is file-based and has no runtime. Each skill is a directory. Inside it, SKILL.md opens with YAML frontmatter carrying two fields, name and description, and the rest of the file is the guidance text. The README states that the description is what the agent uses to decide relevance, which means the frontmatter is not decoration: it is the routing layer. A skill with a vague description will not be selected, no matter how good the body is.

There is no server, no daemon, and no index file that the repository documents. Installation copies or links the folder into a directory your agent scans, for example .claude/skills/. The agent reads the folder at the point it needs it. That design has a consequence worth stating plainly: the skills are static text, so they cannot adapt to your project's Gradle version, your Kotlin version, or the structure of your modules. If a skill tells the agent to use an API that your project pins to an older release, the agent has no way to know from the skill alone.

Naming is enforced by convention rather than by tooling. Every skill must be named kotlin-<category>-<functional-name>, where the functional name is kebab-case. The README lists two categories: backend, for server-side work such as Spring and JPA used from Kotlin, and tooling, for build tooling. New categories require opening an issue. That is a deliberate bottleneck, and it tells you the maintainers would rather have a small set of well-scoped skills than a sprawl of overlapping ones.

## Installing kotlin-agent-skills with npx skills or a plugin marketplace

There are three documented install paths, and they are not equivalent in what they leave on disk.

The first uses the skills CLI. Run this from the root of the project where you want the skills available:

```bash
npx skills add Kotlin/kotlin-agent-skills
```

The README points to the vercel-labs/skills repository for additional options on that command. This is the shortest path and the one that does not tie you to a specific agent vendor.

Claude Code users install through the plugin marketplace instead. Two commands, in this order:

```sh
claude plugin marketplace add Kotlin/kotlin-agent-skills
```

```sh
claude plugin install kotlin-agent-skills@Kotlin
```

The first registers the repository as a marketplace source and the second installs the plugin named kotlin-agent-skills from the source named Kotlin. Note the capital K in the source name; it matches the GitHub organisation.

Codex users register the marketplace in the shell and then finish inside the interactive tool:

```shell
codex plugin marketplace add Kotlin/kotlin-agent-skills
```

After that, the README says to invoke /plugins inside codex, search for kotlin-agent-skills, press Enter, and select Install plugin. The install is not complete until you do that last step in the TUI.

If none of those fit, manual installation works and is the most transparent option. Copy the folder you want into your agent's skills directory:

```bash
cp -r skills/kotlin-tooling-agp9-migration .claude/skills/
```

That command copies a single skill rather than the whole repository, which is the right default if you only need one. The README does not document an uninstall or rollback procedure for any of these paths, so for the manual route you should know where you copied the folder.

## Where the collection is thinner than the name suggests

The gap between the repository name and its contents is the first thing to check before adopting it. The name says Kotlin agent skills. The README documents two categories, backend and tooling, and the only skill named anywhere in the README is kotlin-tooling-agp9-migration. If you arrived hoping for skills covering Kotlin Multiplatform, Compose, coroutines, or testing, the README does not claim to provide them, and the categories list is the place to look rather than the title.

The second limitation is the description field. Because selection depends on the frontmatter description, a skill competes with every other skill your agent has loaded. Adding this repository to an agent that already has general-purpose Kotlin knowledge does not guarantee the skill wins the routing decision. The README does not explain how conflicts between skills are resolved, and that silence is the honest answer: resolution is the agent's business, not the repository's.

The third is staleness in a different sense. The last push to the repository was on 2026-08-24. The content is mostly prose about framework conventions, and framework conventions move. A skill describing how to use Spring or JPA from Kotlin is only as current as the last time someone edited it. There is no versioned release in the repository, so there is no changelog to check against your Spring or Kotlin version. You are reading main.

## Skills folders compared with a rules file or a plugin

The obvious alternative is the rules file your agent already supports: CLAUDE.md, AGENTS.md, or whatever your tool calls it. The difference is scope and loading. A rules file is loaded for every session regardless of what you are doing, so anything you put in it costs context on every task. A skill folder is selected by its frontmatter description and pulled in only when relevant. If you have three paragraphs of Kotlin backend conventions, a rules file is simpler. If you have a migration procedure with scripts and reference material attached, the folder structure is the better fit, because the resources travel with the skill instead of bloating a file that loads unconditionally.

The second alternative is a general-purpose agent plugin that bundles commands, hooks, and configuration alongside instructions. The README does not define the boundary between an agent skill and a plugin, and the repository ships both .claude-plugin/ and .codex-plugin/ directories at the top level, so the two concepts coexist here rather than replacing each other. What can be said from the layout is that plugins/ and skills/ are separate top-level directories, and the skills themselves are portable folders that the plugin mechanism happens to distribute.

The third alternative is doing nothing and writing your own SKILL.md. The format is small enough that this is realistic. The repository's value is then not the standard but the Kotlin-specific content, and you should judge it on that basis alone.

## Licence and the cost of keeping skills current

The repository is Apache-2.0. That permits commercial use, modification, and redistribution, and it includes an explicit patent grant, which matters more for a corporate coding environment than for a hobby project. Apache-2.0 also requires that you preserve the licence and notice files when you redistribute, so if you fork the skills into an internal repository and ship them to your teams, keep LICENSE intact. This is a description of the licence text, not legal advice; get your own review if the skills end up inside a product you distribute.

The upgrade cost is low in the mechanical sense. Skills are text files, so updating means pulling the repository again or re-running the install command. There is no compiled artifact and no dependency graph to reconcile. The cost that is not low is review. Every upstream change to a SKILL.md is a change to instructions your agent will follow, and it arrives without a release note to read, because no releases are published. If you vendor the folders manually, you own the diff. If you install through a plugin marketplace, you are tracking whatever is on main at the moment you update.

A practical middle path the repository supports is copying individual skill folders. The manual install example copies one skill, not the whole tree, which lets you pin the content you have reviewed and ignore the rest.

## Conclusion

Adopt it if your coding agent already reads Agent Skills folders and you work in Kotlin or Android, because the install path is one command and the content is versioned in git rather than pasted into a prompt. Do not adopt it if your agent has no skills mechanism, or if you need skills outside the backend and tooling categories the README lists. Before relying on it, open skills/kotlin-tooling-agp9-migration/SKILL.md and read the frontmatter and body yourself: that file is the whole contract for how a skill is written, and the README does not document rollback or uninstall.

## FAQ

### What are Android agentic skills?

In this repository the term maps to Agent Skills folders that carry Kotlin-specific instructions for a coding agent. Each folder contains a SKILL.md with YAML frontmatter for name and description plus the guidance the agent follows while the skill is active. The README lists backend and tooling as the current categories, and Android work falls under the conventions those skills encode rather than under a separate Android category.

### What is the difference between agent skills and plugins in Kotlin/kotlin-agent-skills?

The README does not define that boundary. What the repository layout shows is that skills/ and plugins/ are separate top-level directories, and that .claude-plugin/ and .codex-plugin/ exist alongside them. Skills are self-contained folders following the Agent Skills standard, while the plugin directories are how Claude Code and Codex register and install them.

### How do I install Kotlin/kotlin-agent-skills?

The README gives three routes. The skills CLI uses npx skills add Kotlin/kotlin-agent-skills, Claude Code uses claude plugin marketplace add followed by claude plugin install kotlin-agent-skills@Kotlin, and Codex registers the marketplace in the shell and then installs through /plugins. Manual installation copies a skill folder into your agent's skills directory.

### Which skills are included in Kotlin/kotlin-agent-skills?

The README names one skill, kotlin-tooling-agp9-migration, in its manual installation example. It defines two categories, backend for server-side frameworks such as Spring and JPA used with Kotlin, and tooling for build tooling. The full list lives in the skills/ directory, which the README points to as the location of all skills.

### What naming convention do skills in Kotlin/kotlin-agent-skills follow?

Every skill must be named kotlin-<category>-<functional-name>, with the functional name in kebab-case. The category must be one of the predefined ones, currently backend or tooling. Adding a new category requires opening an issue.

## Sources

- [Issues](https://github.com/Kotlin/kotlin-agent-skills/issues)
- [Kotlin/kotlin-agent-skills on GitHub](https://github.com/Kotlin/kotlin-agent-skills)
- [License: Apache-2.0](https://github.com/Kotlin/kotlin-agent-skills/blob/main/LICENSE)
- [Project website](https://kotlinlang.org)
- [README](https://github.com/Kotlin/kotlin-agent-skills/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/kotlin-kotlin-agent-skills