android-compose-state-effects
Manage Compose state, remember APIs, side effects, snapshots, and lifecycle-aware collection without leaks or loops.
46
33%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./.github/skills/android-compose-state-effects/SKILL.mdQuality
Discovery
32%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 identifies a specific technical domain (Compose/Jetpack Compose state management) and lists relevant concepts, but it lacks concrete action verbs describing what the skill actually does and completely omits a 'Use when...' clause. The trigger terms are moderately relevant but miss common variations and the full framework name, reducing discoverability.
Suggestions
Add an explicit 'Use when...' clause, e.g., 'Use when the user asks about Jetpack Compose state management, recomposition issues, side effects like LaunchedEffect or DisposableEffect, or lifecycle-aware state collection in Android.'
Replace vague verbs like 'manage' and 'remember' with concrete actions, e.g., 'Guides correct usage of remember/rememberSaveable, implements side effects (LaunchedEffect, DisposableEffect), prevents recomposition loops, and configures lifecycle-aware Flow collection.'
Include the full framework name 'Jetpack Compose' and platform 'Android' to improve trigger matching and distinctiveness from other UI framework skills.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description names a specific domain (Jetpack Compose) and lists several relevant concepts (state, APIs, side effects, snapshots, lifecycle-aware collection), but the actions are vague — 'manage' and 'remember' are not concrete actions like 'extract', 'create', or 'generate'. It reads more like a topic list than a list of concrete capabilities. | 2 / 3 |
Completeness | The description addresses 'what' at a high level but completely lacks a 'Use when...' clause or any explicit trigger guidance for when Claude should select this skill. Per the rubric, a missing 'Use when...' clause caps completeness at 2, and since the 'what' is also somewhat weak, this scores a 1. | 1 / 3 |
Trigger Term Quality | Includes some relevant keywords a developer might use ('Compose state', 'side effects', 'snapshots', 'lifecycle-aware collection'), but misses common natural variations like 'Jetpack Compose', 'recomposition', 'remember', 'LaunchedEffect', 'collectAsStateWithLifecycle', or 'Android UI state'. The terms 'leaks or loops' are somewhat niche and may not match typical user queries. | 2 / 3 |
Distinctiveness Conflict Risk | The mention of 'Compose state', 'side effects', 'snapshots', and 'lifecycle-aware collection' narrows the domain to Jetpack Compose development, which is fairly specific. However, without the explicit 'Jetpack Compose' or 'Android' qualifier, it could potentially overlap with other state management or UI framework skills. | 2 / 3 |
Total | 7 / 12 Passed |
Implementation
35%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill reads more like a conceptual checklist than an actionable guide. It correctly identifies the right Compose primitives and anti-patterns, and the workflow/handoff boundaries are well-defined. However, the critical weakness is the complete absence of executable code examples showing how to actually use `collectAsStateWithLifecycle`, `rememberUpdatedState`, `LaunchedEffect` with proper keys, etc.—which is exactly what would make this skill valuable.
Suggestions
Add concrete Kotlin/Compose code snippets for each major primitive (e.g., `collectAsStateWithLifecycle`, `LaunchedEffect` with proper keys, `rememberUpdatedState` pattern) showing correct vs incorrect usage.
Replace the gradle-command-only examples with inline code examples that demonstrate the happy path (lifecycle-aware collection), edge case (recomposition with multiple state changes), and the anti-pattern corrections.
Add a validation/verification step to the workflow, such as 'Verify effect keys by checking that recomposition logs show expected restart behavior' or a concrete debugging approach.
Consider creating a companion file (e.g., PATTERNS.md) with detailed before/after code examples for each anti-pattern listed, and reference it from the main skill.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is reasonably efficient and doesn't over-explain basic concepts, but some sections like 'When To Use' and 'Review Focus' contain guidance that Claude could infer. The anti-patterns and guardrails sections add value but could be slightly tighter. | 2 / 3 |
Actionability | The skill provides no executable code examples, no concrete Kotlin/Compose snippets, and no copy-paste ready patterns. It describes concepts and lists API names but never shows how to actually use them. The 'Examples' section only provides gradle commands, not actual code demonstrating the primitives. | 1 / 3 |
Workflow Clarity | The workflow section provides a reasonable sequence (classify → pick primitive → separate state/events → stabilize keys → hand off), but lacks validation checkpoints or feedback loops. For a skill dealing with subtle runtime behavior like effect restarts and stale captures, there's no concrete verification step. | 2 / 3 |
Progressive Disclosure | The content is well-structured with clear sections and references to handoff skills, but it's essentially a single flat document with no references to deeper companion files for detailed patterns or API usage. The official references are external links only. Content that could benefit from separate detailed examples files is absent. | 2 / 3 |
Total | 7 / 12 Passed |
Validation
90%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 10 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
metadata_field | 'metadata' should map string keys to string values | Warning |
Total | 10 / 11 Passed | |
- Repository
- krutikJain/android-agent-skills
- Commit
c5bf673
- 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.