Integrate State with Views using Coroutines and Lifecycle on Android. Use when managing state with ViewModels and Lifecycle-aware coroutines in Android. (triggers: **/*Fragment.kt, **/*Activity.kt, repeatOnLifecycle, launchWhenStarted)
85
81%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
89%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 a solid skill description that clearly identifies its niche in Android lifecycle-aware state management with coroutines. It excels at trigger terms and completeness by including both a 'Use when' clause and explicit file pattern triggers. The main weakness is that the 'what' portion could be more specific about the concrete actions performed (e.g., collecting StateFlows, setting up lifecycle observers, migrating from launchWhenStarted to repeatOnLifecycle).
Suggestions
Expand the capability description with more specific concrete actions, e.g., 'Collects StateFlows and SharedFlows in lifecycle-aware scopes, sets up repeatOnLifecycle blocks, migrates from deprecated launchWhenStarted patterns.'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description names the domain (Android state management with ViewModels, Coroutines, Lifecycle) and a general action ('Integrate State with Views'), but does not list multiple specific concrete actions like collecting flows, observing LiveData, setting up lifecycle-aware coroutine scopes, etc. | 2 / 3 |
Completeness | Clearly answers both 'what' (integrate state with views using coroutines and lifecycle on Android) and 'when' (explicit 'Use when managing state with ViewModels and Lifecycle-aware coroutines in Android' plus file pattern triggers). The triggers clause provides additional explicit guidance. | 3 / 3 |
Trigger Term Quality | Includes strong natural keywords users would encounter or type: 'Fragment.kt', 'Activity.kt', 'repeatOnLifecycle', 'launchWhenStarted', 'ViewModels', 'Lifecycle-aware coroutines', 'Android'. These are terms developers naturally use when working in this area. | 3 / 3 |
Distinctiveness Conflict Risk | Highly specific niche: Android lifecycle-aware coroutine state management with explicit file patterns (*Fragment.kt, *Activity.kt) and specific API references (repeatOnLifecycle, launchWhenStarted). Unlikely to conflict with other skills. | 3 / 3 |
Total | 11 / 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 skill is well-structured and concise, effectively communicating Android state management rules without unnecessary verbosity. Its main weakness is the lack of concrete, executable code examples—the rules are stated clearly but a developer (or Claude) would benefit from seeing the actual repeatOnLifecycle boilerplate pattern inline rather than only in a referenced file. The anti-patterns section is a strong addition.
Suggestions
Add a concrete, copy-paste ready code snippet showing the correct repeatOnLifecycle pattern in a Fragment (e.g., viewLifecycleOwner.lifecycleScope.launch { repeatOnLifecycle(Lifecycle.State.STARTED) { viewModel.uiState.collect { ... } } })
Include a brief 'wrong vs right' code comparison for the launchWhenStarted anti-pattern to make the guidance immediately actionable
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Very lean and efficient. Every line adds value—no explanation of what Flows or LiveData are, no unnecessary context. The 'Why' annotations are brief and justify the rules without over-explaining. | 3 / 3 |
Actionability | Provides clear rules and anti-patterns but lacks concrete executable code examples. There's no copy-paste ready snippet showing the correct repeatOnLifecycle pattern or StateFlow collection in a Fragment/Activity, which would significantly improve actionability. | 2 / 3 |
Workflow Clarity | For a relatively simple skill, the rules are clear, but there's no sequenced workflow showing how to set up state collection step-by-step. The anti-patterns section helps but a concrete before/after or step-by-step implementation pattern would improve clarity. | 2 / 3 |
Progressive Disclosure | Clean structure with a concise overview and a single well-signaled reference to an implementation template. One level deep, clearly organized sections, and appropriate content split for a skill of this size. | 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.