CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

kotlin-development

This skill should be used when the user asks to "write Kotlin code", "create a Kotlin class", "set up a Kotlin project", "review Kotlin code", "refactor Kotlin", "use Kotlin coroutines", "fix Kotlin style", "set up Detekt", "configure ktlint", "add static analysis to a Kotlin project", "set up Kotlin linting (Detekt, ktlint)", or when generating any Kotlin source code. Provides modern Kotlin 2.1+ best practices covering null safety, coroutines, data modeling, error handling, idiomatic patterns, and static analysis (Detekt, ktlint). Covers the language and stdlib only; the one framework-specific part is an optional Android/Compose lint section. For Android app code (Compose UI, lifecycle, platform APIs) use google-app-development alongside it.

74

Quality

93%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Passed

No findings from the security scan

SKILL.md
Quality
Evals
Security

Quality

Content

86%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

A strong, well-structured body: executable examples, opinionated rules that go beyond common knowledge (runCatching caveats, CancellationException rethrow, BigDecimal for money), and clean progressive disclosure matched to a real bundle of five reference files. The gaps are minor: some standard-convention restatement could be trimmed, and an explicit lint-verification step would complete the feedback loop.

Suggestions

Trim or compress the Naming Conventions table and the basic safe-call/elvis example, which restate conventions Claude already applies by default, keeping only project-specific deviations (e.g., backing-property and boolean-prefix rules).

Add one explicit validation step to the body (e.g., after writing or refactoring, run the Detekt/ktlint setup from references/static-analysis.md and fix violations before finishing) to close the verify-fix loop.

DimensionReasoningScore

Conciseness

The body is dense and rule-driven with little prose padding, but a few sections restate knowledge Claude already has: the naming-conventions table (PascalCase classes, camelCase functions, UPPER_SNAKE constants) and the basic safe-call/elvis snippets ('val length = name?.length ?: 0'). These could be trimmed for token efficiency, matching the 'minor instances of over-explanation' anchor rather than the fully lean anchor.

4 / 5

Actionability

Nearly every section carries copy-paste-ready Kotlin (sealed Result hierarchy, value class with init validation, exception hierarchy, coroutineScope example, project layout tree) plus prescriptive rules with concrete thresholds ('Detekt LongMethod fires at 60 lines'). The common cases are covered; only trivial fragments like '{ ... }' are placeholders, fitting the 'fully executable' anchor.

5 / 5

Workflow Clarity

This is a reference/style skill with no multi-step process to sequence, and its rules are unambiguous, but the natural validation loop — running the configured linters to verify adherence — is only implied via thresholds and deferred to references/static-analysis.md rather than stated as a step in the body. That minor checkpoint gap fits anchor 4; it is not anchor 5 since no explicit verify/recover sequence exists, and not anchor 3 since nothing destructive or batch-oriented lacks validation.

4 / 5

Progressive Disclosure

Verified against the actual bundle: all five files listed under 'Reference Files' exist in references/ and each gets a one-line scope summary; the body defers detail at the right granularity ('For Flow, Channels, exception handling... see references/coroutines.md'). References are one level deep with only lateral peer pointers (patterns.md to coroutines.md), matching the 'clear overview with well-signaled one-level-deep references' anchor.

5 / 5

Total

18

/

20

Passed

Description

100%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

An exemplary description: explicit third-person what/when with a dozen natural trigger phrases, named tools, and explicit scope boundaries including a handoff to a sibling skill for Android work. Every dimension sits at the top anchor with no padding or over-claims.

DimensionReasoningScore

Specificity

The what-clause 'Provides modern Kotlin 2.1+ best practices covering null safety, coroutines, data modeling, error handling, idiomatic patterns, and static analysis (Detekt, ktlint)' enumerates six concrete coverage areas with named tools, and explicitly bounds scope ('Covers the language and stdlib only'). This matches the comprehensive anchor; not the 4 anchor since there are no coverage gaps within its stated scope.

5 / 5

Completeness

Both questions are explicitly answered: what ('best practices covering null safety, coroutines, data modeling, error handling, idiomatic patterns, and static analysis') and when ('This skill should be used when the user asks to...'). Concrete trigger phrases accompany both, matching the anchor-5 example structure exactly.

5 / 5

Trigger Term Quality

Twelve natural quoted trigger phrases ('write Kotlin code', 'refactor Kotlin', 'set up Detekt', 'configure ktlint', 'fix Kotlin style') plus a catch-all ('when generating any Kotlin source code') give comprehensive coverage with synonyms (linting/static analysis/style). Only the '.kt' extension is absent, which for a language skill users rarely invoke; this fits the top anchor rather than the 'a few natural terms missing' anchor.

5 / 5

Distinctiveness Conflict Risk

Clear niche (Kotlin language/stdlib) with distinctive tool triggers (Detekt, ktlint) and explicit deconfliction: 'For Android app code (Compose UI, lifecycle, platform APIs) use google-app-development alongside it.' Minimal conflict risk, matching the top anchor.

5 / 5

Total

20

/

20

Passed

Validation

93%

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 15 / 16 Passed

Validation for skill structure

CriteriaDescriptionResult

frontmatter_unknown_keys

Unknown frontmatter key(s) found; consider removing or moving to metadata

Warning

Total

15

/

16

Passed

Repository

provectus/awos-recruitment

Path

registry/skills/kotlin-development/SKILL.md

Reviewed

Table of Contents

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.