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.

Quality

62%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Optimize this skill with Tessl

npx tessl skill review --optimize ./skills/android/android-legacy-state/SKILL.md

Quality

Content

35%

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

This skill identifies the right rules and anti-patterns for lifecycle-aware state collection on Android, but critically lacks any executable code examples—the core pattern (repeatOnLifecycle in a Fragment) is never shown. The referenced implementation template doesn't exist in the bundle, leaving the skill without actionable guidance. The content is reasonably concise but trades too much substance for brevity.

Suggestions

Add a concrete, copy-paste-ready code example showing `repeatOnLifecycle(Lifecycle.State.STARTED)` collecting a StateFlow in a Fragment's `onViewCreated`.

Include the referenced `references/implementation.md` bundle file or inline the template if it's short enough.

Add a brief before/after anti-pattern code snippet showing the deprecated `launchWhenStarted` replaced by `repeatOnLifecycle` to make the anti-patterns section actionable.

Remove the 'Priority: P1' header as it adds no instructional value for Claude.

Dimension	Reasoning	Score
Conciseness	Mostly efficient but includes some unnecessary elements like the 'Why' explanation for repeatOnLifecycle (Claude knows why lifecycle-aware collection matters) and the Priority header adds no instructional value. The 'LiveData vs Flow' section is reasonably tight.	2 / 3
Actionability	No executable code examples are provided anywhere in the body. The skill describes rules ('ALWAYS use repeatOnLifecycle') but never shows the actual code pattern, making it vague direction rather than concrete guidance. The implementation template is referenced but the bundle file doesn't exist.	1 / 3
Workflow Clarity	The skill clearly states what to do and what not to do (anti-patterns), 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 pattern showing the setup would improve clarity.	2 / 3
Progressive Disclosure	There is a reference to 'references/implementation.md' for the Flow Consumption Template, which is appropriate progressive disclosure. However, the bundle file doesn't exist (no bundle files provided), so the reference is broken, and the main content lacks enough substance to stand on its own without it.	2 / 3
	Total	7 / 12 Passed

Description

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 excellent trigger terms and a clear 'Use when' clause. 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 like 'collect StateFlow/SharedFlow in UI, set up lifecycleScope launches, bridge ViewModel emissions to UI updates' to improve specificity.

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 task rather than specific operations 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' (explicit 'Use when managing state with repeatOnLifecycle or lifecycle-aware coroutines in Fragment/Activity').	3 / 3
Trigger Term Quality	Includes strong natural keywords a developer would use: 'ViewModel', 'Coroutines', 'Lifecycle', 'repeatOnLifecycle', 'lifecycle-aware coroutines', 'Fragment', 'Activity'. These are terms Android developers naturally use when seeking help with this pattern.	3 / 3
Distinctiveness Conflict Risk	The combination of ViewModel + Coroutines + Lifecycle + repeatOnLifecycle + Fragment/Activity creates a very specific niche that is unlikely to conflict with other skills. This targets a well-defined Android architecture pattern.	3 / 3
	Total	11 / 12 Passed

Validation

81%

Warnings & errors only

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: de793e9

Reviewed: 3 days ago

Table of Contents

Discovery Implementation Validation

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.