# kotlin-skills

> Claude Code skills for Kotlin full-stack work: KMP structure, the shared wire contract, Ktor on the JVM and Kotlin/Native, Compose clients, testing, releases and conventions. Every rule names the defect it was written for.

Page: https://kotlin.website/kotlin-skills

## Why it exists

An agent writing Kotlin full-stack code makes the same structural decisions a person does — where a
class goes, what the wire contract holds, which tests belong in which suite — and makes them
differently every time unless something tells it. [kotlin-skills](https://github.com/youndie/kotlin-skills)
is that something, as Claude Code skills.

Two rules shape all of it. **A rule without a reason is not written down**, and where the reason is a
defect, the defect is described. And **each skill starts with a Step 0**: read the project, and let its
own conventions win over the skill. The skills are for repositories that have no convention yet, or
that are about to grow a second platform and want to know which rules pay off before that.

## Where the rules come from

The public source is [mani](https://kotlin.website/mani): a budget planner with Compose clients for Android, iOS, desktop
and the browser, one server compiled twice, and one contract module shared by all of them. Its code is
the reference for the two-build mechanics, the contract and the platform plumbing. The larger patterns
— use cases with typed errors, tenancy and role tiers, derived view-model state — come from production
code that is not public, and are described generically.

`native-service-bootstrap` was written from [katcher](https://kotlin.website/katcher), [metrik](https://kotlin.website/metrik), [tracy](https://kotlin.website/tracy)
and [shildik](https://kotlin.website/shildik), and now leans on [sborka](https://kotlin.website/sborka) and [kore](https://kotlin.website/kore) for what it used to spell
out. That split is deliberate: **a convention compels, a skill describes**, and where the two disagree
the convention is right.

## The skills

| Skill | Use it when |
|---|---|
| `product-brief` | turning an idea into a technical brief for [docs-bootstrap](https://kotlin.website/docs-bootstrap) and a designer brief that agree on every screen and state |
| `backlog-item` | advancing a docs-bootstrap backlog one item per run, under `/loop` |
| `kmp-project-structure` | starting a KMP project, adding a module or target, deciding where a class belongs |
| `kmp-shared-contract` | adding or changing an endpoint or a DTO |
| `ktor-server-feature` | a route, a validation rule, a storage port and its per-build implementations, auth, errors |
| `native-service-bootstrap` | standing up a **new** Kotlin/Native service, up to the first `/health` from the image |
| `compose-client-feature` | a screen or feature on the client: repository, use case, view model, navigation |
| `design-to-compose` | implementing a screen from a design canvas and proving it matches, with [viddik](https://kotlin.website/viddik)'s parity task |
| `kmp-testing` | writing or placing any test; why a green build missed a bug |
| `kmp-library-release` | releasing a KMP library or a Gradle plugin, and verifying it as a consumer with [proba](https://kotlin.website/proba) |
| `kotlin-native-cinterop` | binding a C or C-ABI Rust library into Kotlin/Native so that a consumer links |
| `kotlin-conventions` | naming, abstractions, comments, code review |

A second plugin, `research-method`, holds `measurement-study`: a time-boxed study or measurement run
so its verdicts survive review — a pre-registered brief, a pinned stand, positive controls, a verdict
per question with every number traceable to its log.

## Install

```bash
claude plugin marketplace add youndie/kotlin-skills
```

```bash
claude plugin install kotlin-fullstack@kotlin-skills
```

```bash
claude plugin install research-method@kotlin-skills
```

The skills appear as `/kotlin-fullstack:<skill>` and trigger on their own when a task matches. The
marketplace also lists [kompot](https://kotlin.website/kompot)'s own layout skill, which lives in kompot's repository next to
the code it describes.

## How it is kept honest

Every change to a plugin raises its version, because `claude plugin update` compares versions and
nothing else — a fix merged under the old number reaches no install. CI refuses the pull request
otherwise, and holds every skill to 400 lines, its description limit and every relative link inside it.
