home / skills / shaul1991 / shaul-agents-plugin / backend-kotlin

backend-kotlin skill

safe

This skill helps you develop Kotlin-based backends using Spring Boot, Ktor, coroutines, and Exposed ORM with best practices.

npx playbooks add skill shaul1991/shaul-agents-plugin --skill backend-kotlin

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

578 B

---
name: backend-kotlin
description: Kotlin Developer Agent. Kotlin 기반 백엔드 개발을 담당합니다. Coroutines, Ktor, Spring Boot + Kotlin 전문.
allowed-tools: Read, Write, Edit, Glob, Grep, Bash
---

# Kotlin Developer Agent

## 역할
Kotlin 기반 백엔드 개발을 담당합니다.

## 전문 영역
- Kotlin + Spring Boot
- Coroutines, Flow
- Ktor
- Exposed ORM

## 트리거 키워드
kotlin, 코틀린, ktor, coroutine, 코루틴, flow, suspend

## Kotlin 특성
- Null Safety
- Data Class
- Extension Functions
- Scope Functions (let, apply, also, run)

Overview

This skill is a Kotlin Developer Agent focused on backend development using Kotlin-first frameworks and libraries. It specializes in building reactive and coroutine-based services with Ktor and Spring Boot, plus database access via Exposed ORM. The agent enforces Kotlin idioms like null safety, data classes, and extension functions to produce idiomatic, maintainable code.

How this skill works

The agent analyzes project goals and existing code to produce implementations, refactors, or code reviews that use coroutines, Flow, and structured concurrency. It scaffolds Ktor or Spring Boot modules, designs service layers with Exposed ORM mappings, and recommends patterns like suspend functions and reactive flows. It can generate unit and integration tests, sample endpoints, and migration guidance for Kotlin-specific features.

When to use it

Starting a new Kotlin backend service with Ktor or Spring Boot
Migrating Java services to Kotlin or introducing coroutines
Designing asynchronous APIs using coroutines and Flow
Implementing database access with Exposed ORM and idiomatic mappings
Reviewing or refactoring Kotlin backend code for concurrency correctness

Best practices

Prefer suspend functions and structured concurrency over raw threads or blocking calls
Use Flow for streams and backpressure-aware data flows; avoid converting to blocking types prematurely
Leverage data classes and sealed classes for DTOs and domain models
Isolate side effects in repository/service layers and keep controller code lightweight
Write tests for coroutine logic using runBlockingTest or appropriate test dispatchers

Example use cases

Create a Ktor REST API with coroutine-based request handlers and sample routes
Implement a Spring Boot service module using Kotlin coroutines and WebFlux-style non-blocking endpoints
Map database tables to Kotlin models with Exposed and implement transactional repository functions
Refactor blocking DAO code to suspend functions and Flow-based streams
Add coroutine-aware unit and integration tests with mocked repositories

FAQ

Can this agent convert existing Java Spring code to Kotlin?

Yes. It can translate idioms, suggest coroutine-based refactors, and convert DTOs and configuration to idiomatic Kotlin while preserving behavior.

Which frameworks does it prefer for new services?

For lightweight microservices it recommends Ktor; for feature-rich ecosystems it recommends Spring Boot with coroutine support. Choice depends on team needs and integration requirements.