tdg-personal/kotlin-coroutines-flows
Kotlin Coroutines and Flow patterns for Android and KMP — structured concurrency, Flow operators, StateFlow, error handling, and testing.
67
67%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
54%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 effectively identifies a clear technical niche with strong trigger terms that developers would naturally use, making it distinctive among skills. However, it reads more like a topic list than a skill description — it lacks concrete action verbs describing what the skill does and entirely omits a 'Use when...' clause to guide skill selection.
Suggestions
Add a 'Use when...' clause, e.g., 'Use when the user asks about coroutine patterns, Flow pipelines, StateFlow management, or concurrency issues in Kotlin/Android/KMP projects.'
Replace the topic list with concrete action descriptions, e.g., 'Generates and reviews Kotlin Coroutine and Flow code, implements structured concurrency patterns, converts callbacks to Flow, and sets up coroutine testing.'
Use active third-person verbs to describe capabilities (e.g., 'Implements', 'Debugs', 'Refactors') rather than listing noun phrases.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (Kotlin Coroutines and Flow) and lists several specific topics (structured concurrency, Flow operators, StateFlow, error handling, testing), but these are more like topic areas than concrete actions. It doesn't describe what actions the skill performs (e.g., 'generates coroutine code', 'debugs Flow pipelines'). | 2 / 3 |
Completeness | Describes the 'what' at a topic level but completely lacks a 'Use when...' clause or any explicit trigger guidance for when Claude should select this skill. Per the rubric, a missing 'Use when...' clause caps completeness at 2, and the 'what' itself is more of a topic list than a clear capability statement, warranting a 1. | 1 / 3 |
Trigger Term Quality | Includes strong natural keywords users would say: 'Kotlin Coroutines', 'Flow', 'StateFlow', 'structured concurrency', 'Android', 'KMP', 'Flow operators', 'error handling', 'testing'. These are terms developers naturally use when seeking help with coroutine patterns. | 3 / 3 |
Distinctiveness Conflict Risk | The combination of Kotlin Coroutines, Flow, StateFlow, Android, and KMP creates a very specific niche that is unlikely to conflict with other skills. These are highly distinctive technical terms that clearly delineate this skill's domain. | 3 / 3 |
Total | 9 / 12 Passed |
Implementation
64%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a solid, actionable reference skill with excellent executable Kotlin code examples covering the breadth of coroutines and Flow patterns. Its main weaknesses are moderate verbosity (some explanations of concepts Claude already knows) and a monolithic structure that could benefit from splitting into a concise overview with linked detail files. The lack of explicit workflow sequences or validation steps is understandable for a pattern-reference skill but prevents top scores in workflow clarity.
Suggestions
Trim explanatory prose that Claude already knows (e.g., what dispatchers do, what WhileSubscribed means) — keep only the non-obvious guidance like the KMP dispatcher caveat.
Consider splitting into a lean SKILL.md overview with links to separate files for Flow patterns, testing patterns, and anti-patterns to improve progressive disclosure.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Generally efficient with good code examples, but includes some explanatory text Claude already knows (e.g., explaining what WhileSubscribed(5_000) does, what dispatchers are for, basic concepts like cooperative cancellation). The scope hierarchy ASCII diagram and some inline comments are helpful, but the overall document could be tightened by ~20%. | 2 / 3 |
Actionability | Excellent executable code examples throughout — every pattern has copy-paste ready Kotlin code covering ViewModels, Flow operators, testing with Turbine, faking Flows, parallel decomposition, and error handling. The anti-patterns section provides concrete do/don't guidance. | 3 / 3 |
Workflow Clarity | The skill covers many patterns but presents them as independent recipes rather than sequenced workflows. There are no explicit validation checkpoints or feedback loops — for example, no guidance on verifying that structured concurrency is correctly set up, or steps to debug when Flows aren't emitting as expected. For a reference-style skill this is acceptable but not exemplary. | 2 / 3 |
Progressive Disclosure | The content is well-organized with clear section headers and references to other skills at the bottom. However, at ~200 lines it's a substantial document that could benefit from splitting detailed patterns (e.g., testing, Flow operators) into separate files with links from a leaner overview. The references section is minimal but appropriately one-level deep. | 2 / 3 |
Total | 9 / 12 Passed |
Validation
90%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 10 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 10 / 11 Passed | |
Reviewed
Table of Contents