CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

kotlin-coroutines-expert

Expert patterns for Kotlin Coroutines and Flow, covering structured concurrency, error handling, and testing.

Quality

73%

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

Fix and improve this skill with Tessl

tessl review fix ./skills/kotlin-coroutines-expert/SKILL.md
SKILL.md
Quality
Evals
Security

Quality

Content

75%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 well-structured, code-heavy reference with executable Kotlin patterns, clear decision rules, and a troubleshooting feedback loop. The main gaps are a missing testing code example despite testing being a claimed use case, slight redundancy in the Overview, and a "Step-by-Step" framing that mislabels independent topics.

Suggestions

Add a short `runTest`/`TestScope` code example in a Testing section to back the claimed use case "writing unit tests for suspending functions or Flows" and close the actionability gap.

Trim the Overview paragraph, which restates the frontmatter description, and remove best-practice bullets that restate standard coroutine knowledge Claude already has.

Rename "Step-by-Step Guide" to something like "Core Patterns" since its three sections are independent topics rather than a sequence, and either add a second example or drop the "Example 1" numbering.

DimensionReasoningScore

Conciseness

The body is mostly lean, directive prose ("Always launch coroutines within a defined CoroutineScope"; "Use `StateFlow` for state that needs to be retained, and `SharedFlow` for events") plus executable code with useful annotations ("// If task2 fails, task1 is NOT cancelled because of supervisorScope"). Minor trimmable content keeps it below anchor 5: the Overview paragraph ("A guide to mastering asynchronous programming...") is redundant framing and a few best-practice bullets ("Use `Dispatchers.IO` for blocking I/O"; "Don't: Use `GlobalScope`") restate knowledge Claude already has — but there is no padded section or concept teaching, so it is above anchor 3.

4 / 5

Actionability

Four concrete, syntactically valid Kotlin code blocks (coroutineScope/async parallelization, CoroutineExceptionHandler, debounce/flatMapLatest Flow, supervisorScope) provide mostly copy-paste-adaptable executable guidance. It falls short of anchor 5's "specific examples cover the common cases" because testing — claimed in "When to Use" ("writing unit tests for suspending functions or Flows") — has no code example, and the snippets depend on placeholder dependencies (userRepo, api, viewModelScope).

4 / 5

Workflow Clarity

Guidance is clearly organized into unambiguous topics with decision rules (StateFlow vs SharedFlow) and an error-recovery loop in Troubleshooting ("Problem: Coroutine test hangs... Solution: Ensure you are using `runTest` and injecting `TestDispatcher`"). It misses anchor 5 because the "Step-by-Step Guide" heading presents three independent topics as a nominal sequence with no verification checkpoints, though none are strictly required for non-destructive pattern guidance — still above anchor 3's implicit-checkpoint standard.

4 / 5

Progressive Disclosure

The ~93-line body is well-sectioned (Overview, When to Use, guide topics, Examples, Best Practices, Troubleshooting) and appropriately self-contained with no external references needed. It does not reach anchor 5: the under-50-lines exception for section-only skills does not apply at this length, and minor gaps exist — the "Examples" section contains only "Example 1", and the Overview duplicates the frontmatter description — matching anchor 4 ("Good structure; most content is appropriately placed; minor organization gaps").

4 / 5

Total

16

/

20

Passed

Description

61%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.

The description names a specific, distinctive niche with good natural trigger keywords, but it lists topics rather than concrete actions and entirely lacks a 'Use when...' clause, capping completeness at 3. Adding explicit trigger guidance and action-oriented phrasing would lift the two 3-scores.

Suggestions

Add an explicit trigger clause, e.g. "Use when implementing async operations in Kotlin, working with coroutines, Flow, or suspending functions, or debugging coroutine cancellation or exceptions" — this addresses the completeness cap.

Rewrite topic coverage as concrete actions, e.g. "Implements structured concurrency with coroutineScope/supervisorScope, handles coroutine exceptions and cancellation, and builds reactive streams with StateFlow/SharedFlow" — this raises specificity.

Include a few more natural trigger terms users actually say, such as "suspending functions", "async/await", and "cancellation", to improve trigger coverage from good to comprehensive.

DimensionReasoningScore

Specificity

The description names a specific domain ("Kotlin Coroutines and Flow") and lists three coverage areas ("structured concurrency, error handling, and testing"), but these are topics rather than concrete actions — no action verbs appear — and coverage has gaps (e.g., Flow transformations and cancellation, which the body emphasizes, are absent). It is above anchor 2 ("actions are minimal or generic" — the listed areas are specific) but below anchor 4 ("Lists several specific actions"), so it sits at anchor 3.

3 / 5

Completeness

The 'what' is clearly stated ("Expert patterns for Kotlin Coroutines and Flow, covering structured concurrency, error handling, and testing") but there is no 'Use when...' clause or equivalent explicit trigger guidance, which caps completeness at 3 per the judging guidelines. This matches anchor 3 ("Has a clear 'what' but 'when' is missing or only weakly implied") and cannot reach anchor 4, which requires both 'what' and 'when'.

3 / 5

Trigger Term Quality

Includes strong natural keywords users would say: "Kotlin Coroutines", "Flow", "structured concurrency", "error handling", and "testing" — a user asking about coroutine errors or testing coroutines would naturally use these. A few natural terms are missing ("suspending functions", "cancellation", "async/await", "reactive streams"), so it matches anchor 4 ("Good keyword coverage; a few natural terms missing") rather than anchor 5's comprehensive synonym coverage.

4 / 5

Distinctiveness Conflict Risk

"Kotlin Coroutines and Flow" carves out a clear, distinctive niche, but the trailing unqualified terms "error handling, and testing" could pull in general Kotlin error-handling or testing queries unrelated to coroutines. This matches anchor 4 ("Mostly distinct; minor overlap risk with closely related skills") — anchor 5's "minimal conflict risk" is not quite met, while anchor 3's broader overlap is too pessimistic.

4 / 5

Total

14

/

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

administrakt0r/AI-Agents-Safe-Coding-Skills

Path

skills/kotlin-coroutines-expert/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.