android-legacy-state

Integrate ViewModel state with XML Views using Coroutines and Lifecycle on Android. Use when managing state with repeatOnLifecycle or lifecycle-aware coroutines in Fragment/Activity; defer Compose state and generic Flow design to their specific skills.

Quality

81%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Quality

Content

72%Weight 40%Scale 1-3

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

The body is a tight, standards-oriented skill that assumes competence and avoids padding, with a well-structured single-level reference. Its weakness is actionability and workflow clarity: concrete runnable code and any sequencing/validation checkpoint are absent from the body itself, both being deferred to or omitted relative to the reference file.

Suggestions

Add a short inline Kotlin snippet in the body (e.g. the repeatOnLifecycle collection block) so guidance is copy-paste ready without opening the reference.

Sequence the rules into a small numbered workflow (collect via repeatOnLifecycle -> choose StateFlow vs LiveData -> observe with viewLifecycleOwner) so the order of application is explicit.

Include a brief validation checkpoint, such as confirming collection is tied to viewLifecycleOwner and that no launchWhenStarted calls remain, to catch lifecycle-leak regressions.

Dimension	Reasoning	Score
Conciseness	Quotes 'ALWAYS use repeatOnLifecycle(Lifecycle.State.STARTED) to collect flows in Views' and the brief 'Why' line are lean, assume Claude knows coroutines/lifecycle, and avoid padding. Not below 3 because no token is wasted explaining known concepts.	3 / 3
Actionability	Quotes concrete API guidance like 'repeatOnLifecycle(Lifecycle.State.STARTED)' and 'observe with viewLifecycleOwner (Fragment), NOT this', but the body itself contains no inline executable code block — the runnable example lives only in the reference file. Not 3 because it is not copy-paste ready inline; not 1 because the named APIs are specific and actionable.	2 / 3
Workflow Clarity	Quotes clear directives ('ALWAYS use...', 'NOT this') but the rules are presented as a flat list with no sequencing or validation checkpoints. Not 1 because the single actions are unambiguous; not 3 because there is no explicit sequence or verification step tying the rules together.	2 / 3
Progressive Disclosure	Quotes '[Flow Consumption Template](references/implementation.md)' as a single, clearly signaled reference one level deep, and the referenced file exists and is appropriately split from the overview. Not 2 because the overview is concise and the reference is exactly one level deep with easy navigation.	3 / 3
	Total	10 / 12 Passed

Description

90%Weight 40%Scale 1-3

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 is well-crafted: it states a concrete domain action, provides explicit 'Use when' triggers with natural Android terminology, and clearly differentiates itself from Compose and generic Flow skills. The only mild weakness is that it lists a single integrate action rather than enumerating multiple specific capabilities.

Dimension	Reasoning	Score
Specificity	Quotes 'Integrate ViewModel state with XML Views using Coroutines and Lifecycle on Android' name the domain and one main action, but only a single integrate action is listed rather than multiple concrete actions. Not 3 because it lacks a list of several specific actions; not 1 because the action is concrete and domain-specific.	2 / 3
Completeness	Quotes 'Integrate ViewModel state with XML Views...' answer what, and 'Use when managing state with repeatOnLifecycle or lifecycle-aware coroutines in Fragment/Activity' gives an explicit when clause. Not 2 because the 'Use when' trigger is explicit, not merely implied.	3 / 3
Trigger Term Quality	Quotes 'repeatOnLifecycle', 'lifecycle-aware coroutines', 'Fragment/Activity', and 'ViewModel' are exactly the natural terms an Android developer would say when needing this skill. Not below 3 because coverage of common developer phrasings is strong rather than partial.	3 / 3
Distinctiveness Conflict Risk	Quotes 'defer Compose state and generic Flow design to their specific skills' carve out a clear legacy-XML-View niche with distinct triggers, making conflicts unlikely. Not 2 because it explicitly disambiguates from adjacent Compose/Flow skills.	3 / 3
	Total	11 / 12 Passed

Validation

87%

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 — 14 / 16 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	14 / 16 Passed

Repository: HoangNguyen0403/agent-skills-standard
Path: skills/android/android-legacy-state/SKILL.md
Commit: 9f695e8

Reviewed: 6 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.