android-architecture
Apply Clean Architecture layering, modularization, and Unidirectional Data Flow in Android projects. Use when setting up Android project structure, placing code in Clean Architecture layers, configuring feature/core modules, or implementing UDF patterns. (triggers: build.gradle.kts, settings.gradle.kts, clean-architecture, module, layers, domain, UDF, unidirectional, feature module, core module, presentation layer, data layer)
89
86%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
100%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 an excellent skill description that hits all the marks. It provides specific concrete actions, includes a comprehensive set of natural trigger terms that users would actually use, explicitly states both what the skill does and when to use it, and occupies a clearly distinct niche in Android Clean Architecture. The use of third person voice and concise structure further strengthen it.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: applying Clean Architecture layering, modularization, Unidirectional Data Flow, setting up project structure, placing code in layers, configuring feature/core modules, and implementing UDF patterns. | 3 / 3 |
Completeness | Clearly answers both 'what' (apply Clean Architecture layering, modularization, and UDF in Android projects) and 'when' (explicit 'Use when...' clause covering project structure setup, code placement, module configuration, and UDF implementation), plus explicit trigger terms. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural trigger terms including both technical terms users would actually use (build.gradle.kts, settings.gradle.kts, clean-architecture, module, domain, UDF) and conceptual terms (layers, unidirectional, feature module, core module, presentation layer, data layer). | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive with a clear niche: Android-specific Clean Architecture with UDF patterns. The combination of Android + Clean Architecture + modularization + specific file triggers (build.gradle.kts, settings.gradle.kts) makes it very unlikely to conflict with other skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
72%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a well-structured, concise architectural reference that effectively uses progressive disclosure to keep the main file lean while pointing to detailed references. Its main weakness is the lack of concrete, executable code examples or build configuration snippets in the skill itself—the actionable details are entirely deferred to reference files. Adding a minimal concrete example (e.g., a ViewModel UDF pattern or a build.gradle.kts module setup) would significantly improve actionability.
Suggestions
Add at least one concrete, executable code snippet inline (e.g., a minimal ViewModel with StateFlow<UiState> implementing UDF) so the skill is actionable without requiring reference file access.
Include a brief build.gradle.kts snippet showing module dependency configuration (e.g., how :feature:home depends on :core:network) to make the modularization guidance copy-paste ready.
Consider adding a brief workflow sequence for 'setting up a new feature module' with explicit steps, since the skill description mentions this as a trigger scenario.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Very lean and efficient. Every line conveys architectural decisions or constraints without explaining what Clean Architecture or UDF is conceptually. Assumes Claude already understands these patterns and just needs the project-specific rules. | 3 / 3 |
Actionability | Provides clear architectural rules and naming conventions (e.g., `:feature:home`, `:core:network`, `StateFlow<UiState>`), but lacks executable code examples or concrete build.gradle.kts snippets. The actual implementation details are deferred to reference files, so the skill itself is more directive than executable. | 2 / 3 |
Workflow Clarity | The sections are logically sequenced (layers → modules → data flow → compose → anti-patterns), but there's no explicit workflow for setting up a project, no validation checkpoints, and no step-by-step process for applying these standards to an existing or new project. | 2 / 3 |
Progressive Disclosure | Excellent progressive disclosure: the SKILL.md serves as a concise overview with clear, well-signaled one-level-deep references to implementation.md and compose-standards.md for detailed examples and configuration. | 3 / 3 |
Total | 10 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Repository
- HoangNguyen0403/agent-skills-standard
- Commit
19a1140
- 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.