android-legacy-state
Integrate ViewModel state with Views using Coroutines and Lifecycle on Android. Use when managing state with repeatOnLifecycle or lifecycle-aware coroutines in Fragment/Activity.
64
77%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/android/android-legacy-state/SKILL.mdQuality
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 coroutine state management. It has an explicit 'Use when' clause with good trigger terms. The main weakness is that the 'what' portion could be more specific about the concrete actions performed (e.g., collecting flows, setting up lifecycle observers).
Suggestions
Add more specific concrete actions to the 'what' portion, e.g., 'Collect StateFlow/SharedFlow in lifecycle-aware scopes, set up repeatOnLifecycle blocks, manage UI state collection in Fragment/Activity.'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | It names the domain (Android ViewModel/View integration) and mentions some specific mechanisms (Coroutines, Lifecycle, repeatOnLifecycle), but doesn't list multiple concrete actions — it describes a general integration pattern rather than specific tasks like 'collect StateFlow', 'observe LiveData', 'launch coroutines in lifecycleScope'. | 2 / 3 |
Completeness | Clearly answers both 'what' (integrate ViewModel state with Views using Coroutines and Lifecycle on Android) and 'when' (Use when managing state with repeatOnLifecycle or lifecycle-aware coroutines in Fragment/Activity), with an explicit 'Use when...' clause. | 3 / 3 |
Trigger Term Quality | Includes strong natural keywords a developer would use: 'ViewModel', 'Coroutines', 'Lifecycle', 'repeatOnLifecycle', 'Fragment', 'Activity', 'lifecycle-aware coroutines', 'state'. These are terms Android developers naturally use when asking about this topic. | 3 / 3 |
Distinctiveness Conflict Risk | The combination of Android-specific terms (ViewModel, repeatOnLifecycle, Fragment/Activity, lifecycle-aware coroutines) creates a very clear niche that is unlikely to conflict with other skills. It's narrowly scoped to a specific Android architecture pattern. | 3 / 3 |
Total | 11 / 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 concise, well-structured skill that correctly assumes Claude's knowledge of Android concepts and avoids unnecessary explanation. Its main weaknesses are the lack of executable code examples (particularly the repeatOnLifecycle pattern) and a referenced file that doesn't exist in the bundle, which limits both actionability and progressive disclosure.
Suggestions
Add a concrete, executable code snippet showing the correct repeatOnLifecycle usage in a Fragment (e.g., viewLifecycleOwner.lifecycleScope.launch { repeatOnLifecycle(Lifecycle.State.STARTED) { viewModel.uiState.collect { ... } } })
Either provide the referenced 'references/implementation.md' bundle file or inline the essential template content directly in the skill
Add a brief before/after code comparison showing the deprecated launchWhenStarted pattern vs the correct repeatOnLifecycle pattern to make the anti-patterns section more actionable
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is lean and efficient. It states rules directly without explaining what StateFlow, LiveData, or repeatOnLifecycle are—correctly assuming Claude knows these concepts. Every line adds actionable value. | 3 / 3 |
Actionability | The skill provides clear rules and anti-patterns but lacks executable code examples. A concrete code snippet showing the correct repeatOnLifecycle pattern and the incorrect launchWhenStarted pattern would make this fully actionable and copy-paste ready. | 2 / 3 |
Workflow Clarity | The skill clearly states what to do and what to avoid, but there's no sequenced workflow for implementing state collection in a Fragment/Activity. For a skill about integrating ViewModel state with Views, a step-by-step implementation flow (e.g., setup ViewModel → collect in Fragment → handle lifecycle) would improve clarity. | 2 / 3 |
Progressive Disclosure | The reference to 'references/implementation.md' for a Flow Consumption Template is appropriate one-level-deep disclosure, but no bundle file exists to back it up. The main content is well-organized with clear sections, but the broken reference undermines navigation. | 2 / 3 |
Total | 9 / 12 Passed |
Validation
81%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 9 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
metadata_version | 'metadata.version' is missing | Warning |
metadata_field | 'metadata' should map string keys to string values | Warning |
Total | 9 / 11 Passed | |
- Repository
- HoangNguyen0403/agent-skills-standard
- Commit
3df717f
- 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.