Standards for Coroutines, Flow, and Threading. Use when writing suspend functions, choosing coroutine scopes, switching between StateFlow and SharedFlow, injecting Dispatchers for testability, or debugging threading issues in Android. (triggers: **/*ViewModel.kt, **/*UseCase.kt, **/*Repository.kt, suspend, viewModelScope, lifecycleScope, Flow, coroutine, Dispatcher, DispatcherProvider, GlobalScope)
89
86%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
100%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is an excellent skill description that clearly defines its scope around Kotlin coroutines and threading in Android development. It provides specific concrete actions, comprehensive trigger terms including both natural language keywords and file patterns, and explicitly states when to use the skill. The description is concise yet thorough, making it easy for Claude to select this skill appropriately.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: writing suspend functions, choosing coroutine scopes, switching between StateFlow and SharedFlow, injecting Dispatchers for testability, debugging threading issues. These are all concrete, actionable capabilities. | 3 / 3 |
Completeness | Clearly answers both 'what' (standards for coroutines, Flow, and threading) and 'when' (explicit 'Use when...' clause with specific scenarios plus a comprehensive triggers list covering file patterns and keywords). | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural keywords users would say: suspend, viewModelScope, lifecycleScope, Flow, coroutine, Dispatcher, GlobalScope, plus file pattern triggers like *ViewModel.kt and *Repository.kt. These are terms developers naturally use when working with Kotlin coroutines. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive niche focused specifically on Kotlin coroutines, Flow, and threading in Android. The combination of domain-specific terms (viewModelScope, StateFlow, SharedFlow, Dispatchers) and file patterns makes it very unlikely to conflict with other skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
72%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a concise, well-structured standards document that efficiently communicates Android concurrency rules without over-explaining. Its main weakness is the lack of concrete code examples — a DispatcherProvider snippet, a Flow collection example, or a StateFlow vs SharedFlow comparison would significantly improve actionability. The reference structure is clean but the single reference file may not cover enough of the topics mentioned.
Suggestions
Add executable code examples for key patterns: a DispatcherProvider interface/implementation, a ViewModel using viewModelScope with injected dispatchers, and Flow collection with collectAsStateWithLifecycle().
Add a brief decision guide or example distinguishing when to use StateFlow vs SharedFlow (e.g., state holder vs one-shot events) with concrete code snippets.
Include a short example showing the correct async/await pattern for parallel calls to clarify when async is appropriate.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Very lean and efficient. Every line provides actionable guidance without explaining what coroutines or flows are. Assumes Claude's competence with Kotlin/Android concepts. | 3 / 3 |
Actionability | Provides clear directives (use viewModelScope, inject Dispatchers, use collectAsStateWithLifecycle) but lacks executable code examples. No concrete DispatcherProvider implementation, no example of proper Flow collection, no copy-paste ready snippets. | 2 / 3 |
Workflow Clarity | For a standards/guidelines skill, the rules are clearly stated but there's no decision workflow (e.g., when to choose StateFlow vs SharedFlow, when async is appropriate for parallel calls). The guidance is declarative rather than sequenced, which is partially appropriate for a standards doc but misses decision checkpoints. | 2 / 3 |
Progressive Disclosure | Clean overview structure with a single-level reference to implementation details. Content is appropriately brief in the main file with a clear pointer to references/implementation.md for the Dispatcher pattern. | 3 / 3 |
Total | 10 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
19a1140
Table of Contents
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.