android-coroutines-flow
Use coroutines, Flow, structured concurrency, dispatchers, and cancellation-safe Android async pipelines.
60
51%
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 ./skills/android-coroutines-flow/SKILL.mdQuality
Discovery
64%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 excels at naming specific, concrete technical capabilities and uses natural trigger terms that Android/Kotlin developers would recognize. However, it critically lacks a 'Use when...' clause, which means Claude has no explicit guidance on when to select this skill over others. Adding trigger guidance would significantly improve its effectiveness in a multi-skill selection scenario.
Suggestions
Add a 'Use when...' clause such as 'Use when the user asks about Kotlin coroutines, async programming on Android, Flow streams, coroutine scopes, or managing concurrency in Android apps.'
Consider mentioning file types or frameworks (e.g., 'Kotlin', 'ViewModel', 'LiveData integration') to further clarify the context and improve trigger matching.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete concepts: coroutines, Flow, structured concurrency, dispatchers, and cancellation-safe async pipelines. These are distinct, actionable technical capabilities rather than vague abstractions. | 3 / 3 |
Completeness | The description answers 'what' (coroutines, Flow, structured concurrency, etc.) 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 'when' is entirely absent, this scores a 1. | 1 / 3 |
Trigger Term Quality | Includes strong natural keywords a developer would use: 'coroutines', 'Flow', 'structured concurrency', 'dispatchers', 'cancellation', 'async', and 'Android'. These are the exact terms developers search for and mention when working with Kotlin coroutines on Android. | 3 / 3 |
Distinctiveness Conflict Risk | The combination of Android-specific async concepts (coroutines, Flow, structured concurrency, dispatchers, cancellation) creates a very clear niche. It is unlikely to conflict with other skills due to the specificity of the Kotlin/Android coroutines domain. | 3 / 3 |
Total | 10 / 12 Passed |
Implementation
37%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
The skill provides useful concrete code examples for dispatcher injection, lifecycle-aware collection, and cancellation handling, which are its strongest elements. However, the workflow and guardrails sections are generic software engineering advice rather than coroutine-specific guidance, and the workflow lacks concrete validation steps or feedback loops. The skill would benefit from replacing abstract process steps with specific, actionable coroutine/Flow workflows.
Suggestions
Replace the generic 5-step workflow with a concrete coroutine-specific workflow, e.g.: 1. Identify the scope (viewModelScope vs lifecycleScope), 2. Choose the dispatcher, 3. Implement with cancellation safety, 4. Validate with specific test commands.
Add validation checkpoints to the workflow, such as verifying structured concurrency compliance or checking for leaked coroutine scopes, with concrete commands or code to run.
Remove or tighten the Guardrails and Anti-Patterns sections—much of this is general engineering advice Claude already knows. Focus on coroutine-specific pitfalls like GlobalScope usage, collecting in wrong lifecycle state, or swallowing CancellationException.
Expand the Examples section with actual input/output pairs showing before/after code transformations rather than just test commands.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is reasonably efficient but includes some sections that are more process-oriented boilerplate than actionable content (e.g., the generic Workflow and Guardrails sections contain advice Claude already knows about software engineering). The remediation examples are well-targeted and concise. | 2 / 3 |
Actionability | The three remediation code examples are concrete and executable, which is good. However, the Workflow section is vague ('Map the request to the current Android stack', 'Validate the result against the relevant showcase app path') and the Examples section provides test commands but not actual input/output demonstrations of the skill in action. | 2 / 3 |
Workflow Clarity | The workflow steps are abstract and non-specific ('Map the request', 'Inspect the existing implementation', 'Apply the smallest change'). There are no validation checkpoints, no feedback loops for error recovery, and no concrete sequencing of coroutine-specific operations. For a skill involving async pipelines and lifecycle-aware collection, missing validation steps is a significant gap. | 1 / 3 |
Progressive Disclosure | The content is reasonably well-structured with clear section headers and references to handoff skills and official documentation. However, there are no references to deeper companion files for advanced topics (e.g., testing strategies, migration guides), and some content like anti-patterns could be more tightly integrated or split out. | 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.