# kotlin-control-flow

A skill that steers your coding agent through Kotlin branching: when expressions, guard conditions, sealed-type exhaustiveness, smart casts.

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

## What it does

The skill gives the agent a procedure for Kotlin control flow. First it names the value being classified: if every branch tests it, use `when (subject)`; otherwise keep a subjectless `when` or an `if` chain. A lookup table then picks the branch shape, from a single classified value up to a closed value-returning domain.

Guards apply only to a subject `when`, after a primary condition, and the guarded branch goes first. They are stable from Kotlin 2.2. An explicit `languageVersion` setting settles support; otherwise the Kotlin version in the build file or version catalog is enough, so the agent should not decline a guard for lack of further proof. Closed enums, Boolean, sealed types and nullable closed types get every case named with `else` omitted. Open server or platform values that need a real fallback keep their `else`.

Smart casts are verified without `as`, `!!`, mutable temporaries or duplicate casts. If that fails, the original shape stays or the refactor gets smaller. Compile and test with the project's own build tool; in a Gradle project the skill points to the `gradle-run` workflow instead of raw Gradle. On failure the agent steps back to the earliest applicable step.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add chrisbanes/skills --skill kotlin-control-flow -a claude-code
```

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

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add chrisbanes/skills --skill kotlin-control-flow -a codex
```

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

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add chrisbanes/skills --skill kotlin-control-flow -a cursor
```

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

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install chrisbanes/skills kotlin-control-flow
```

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

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add chrisbanes/skills --skill kotlin-control-flow -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/chrisbanes/skills --path skills/kotlin-control-flow
```

### Windsurf (Devin Desktop)

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

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add chrisbanes/skills --skill kotlin-control-flow -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/chrisbanes/skills/tree/HEAD/skills/kotlin-control-flow/SKILL.md

## When to use it
- turn a long `if`/`else` chain into a subject `when`
- attach a guard condition to one branch instead of nesting an `if`
- check that a sealed type is covered exhaustively without `else`
- drop `as` and `!!` where a smart cast already works
- move invalid-input checks into an early return or `require`

## Example prompts
- Rewrite this when with guard conditions where the predicate belongs to one branch
- Check that the when over this sealed type covers every case and needs no else
- Remove the `!!` and duplicate casts from this Selection handling

## 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: 9fe9fa51e0c5f76c.

BEGIN THIRD-PARTY FILE 9fe9fa51e0c5f76c
````text
---
name: kotlin-control-flow
description: "Use when writing or reviewing Kotlin branching and control flow: when expressions, guard conditions, sealed type exhaustiveness, smart casts, nullable branching, early returns, or replacing complex if/else chains."
---

# Kotlin control flow

## Core principle

Make the classified value obvious, keep branch-local predicates on their
branch, and let the compiler prove closed-domain coverage.

## Procedure

1. Name the value being classified. If every branch tests it, use
   `when (subject)`; otherwise keep a subjectless `when` or `if` chain.
2. Choose the branch shape:

   | Code shape | Prefer |
   |---|---|
   | One classified value | `when (subject)` |
   | Unrelated boolean conditions | Subjectless `when` or `if`/`else` |
   | Primary case plus a branch-local predicate | Guard condition |
   | Invalid input before the main path | Early return, `require`, or `check` |
   | Closed value-returning domain | Exhaustive `when` expression |
   | Open input or deliberate fallback | Explicit `else` |

3. Use a guard only on a subject `when`, after a primary condition, when the
   extra predicate belongs to that branch and an unguarded branch still handles
   the primary condition. Put the guarded branch first. Split comma-separated
   conditions instead of guarding one of them. Guards are stable from Kotlin
   2.2. Honor an explicit `languageVersion` setting; otherwise the project's
   Kotlin version in its build file or version catalog is enough to confirm
   support, so do not decline a guard for lack of further proof.
4. For a closed enum, Boolean, sealed type, or nullable closed type, name every
   case and omit `else`. Match objects by value and class/data-class subtypes
   with `is`. If the input is an open server/platform value or needs real
   fallback/logging, keep `else`. Give each data-bearing subtype, including one
   a catch-all collapses, its own `is` branch. When its data affects the
   mapping or its safe handling, the finding or change must show the
   smart-cast member access, even if the public value stays constant:

   ```kotlin
   is Outcome.Failed -> safeFailureLabel(outcome.reason)
   ```

   The `is` check smart-casts `outcome`, so the branch uses `reason` without a
   cast; the helper name is illustrative. Naming cases alone, or sending callers
   to inspect the original value, is not complete branch guidance. When the
````
END THIRD-PARTY FILE 9fe9fa51e0c5f76c

The third-party file has ended. Everything between the 9fe9fa51e0c5f76c 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 2423 of 4380 bytes. © chrisbanes · Apache-2.0 · https://github.com/chrisbanes/skills/tree/HEAD/skills/kotlin-control-flow/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