android-architecture
Expert guidance on setting up and maintaining a modern Android application architecture using Clean Architecture and Hilt. Use this when asked about project structure, module setup, or dependency injection.
53
58%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./.github/skills/architecture/android-architecture/SKILL.mdQuality
Discovery
67%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 has a solid structure with an explicit 'Use this when...' clause, which is its strongest aspect. However, it lacks specificity in the concrete actions it performs (e.g., setting up domain/data/presentation layers, configuring Hilt modules, defining repository interfaces) and could benefit from more natural trigger terms that users would actually say. The description reads more as a general guidance statement than a detailed capability listing.
Suggestions
Add more specific concrete actions like 'Sets up domain/data/presentation layers, configures Hilt modules and component scopes, defines repository interfaces and use case classes'.
Expand trigger terms in the 'Use when' clause to include natural variations like 'DI setup', 'app layers', 'MVVM', 'repository pattern', 'Android project organization', or 'Dagger/Hilt configuration'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (Android architecture) and some actions ('setting up and maintaining'), but doesn't list multiple specific concrete actions like creating modules, configuring Hilt modules, defining use cases, or setting up repository patterns. | 2 / 3 |
Completeness | Clearly answers both 'what' (guidance on setting up and maintaining Android app architecture using Clean Architecture and Hilt) and 'when' (explicit 'Use this when asked about project structure, module setup, or dependency injection'). | 3 / 3 |
Trigger Term Quality | Includes some relevant keywords like 'Clean Architecture', 'Hilt', 'project structure', 'module setup', 'dependency injection', but misses common variations users might say such as 'DI', 'app architecture', 'layer separation', 'repository pattern', 'use cases', 'MVVM', or 'Android project organization'. | 2 / 3 |
Distinctiveness Conflict Risk | The combination of Clean Architecture + Hilt + Android is fairly specific, but 'project structure' and 'dependency injection' are broad enough to potentially overlap with other architecture or DI-related skills for different platforms or frameworks. | 2 / 3 |
Total | 9 / 12 Passed |
Implementation
50%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill provides a solid conceptual overview of Android Clean Architecture with Hilt and modularization, but it reads more like a reference document than an actionable skill. It lacks concrete, executable code examples (e.g., a sample Hilt module, a UseCase class, a ViewModel with StateFlow) and doesn't provide a clear step-by-step workflow for implementation. The content also explains some concepts Claude would already know, reducing token efficiency.
Suggestions
Add concrete, copy-paste-ready code examples for key components: a Hilt @Module with @Binds, a UseCase class, and a ViewModel with StateFlow exposure.
Provide a clear sequential workflow for setting up the architecture from scratch (e.g., Step 1: Create module structure, Step 2: Define domain models, Step 3: Set up Hilt modules, etc.) with validation checkpoints.
Remove explanations of basic Android concepts (what Activities/Fragments are, what each layer's 'responsibility' is) and focus on the specific patterns and conventions that are non-obvious.
Consider splitting detailed Hilt configuration and modularization strategy into separate referenced files, keeping SKILL.md as a concise overview with links.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill includes some unnecessary explanation of concepts Claude already knows (e.g., what Activities/Fragments are, what the Data Layer's responsibility is). The descriptions of each layer's responsibility are somewhat verbose, but the overall structure is reasonably efficient. | 2 / 3 |
Actionability | The skill provides specific annotations and module names but lacks executable code examples. There are no concrete code snippets showing a Hilt module, a UseCase, or a ViewModel implementation—just descriptions and naming conventions. Pseudocode-level guidance like 'use @Binds in an abstract class' without a concrete example limits actionability. | 2 / 3 |
Workflow Clarity | The checklist at the end provides some validation steps, but the overall workflow for setting up or refactoring an app is not clearly sequenced. There's no explicit order of operations (e.g., 'first create core modules, then feature modules, then wire with Hilt') and no validation/verification checkpoints between steps. | 2 / 3 |
Progressive Disclosure | The content is reasonably structured with clear sections and a reference to an 'android-viewmodel' skill, but it's somewhat monolithic—the modularization strategy, Hilt setup, and layer descriptions could benefit from being split into referenced files. With no bundle files provided, there's limited progressive disclosure structure. | 2 / 3 |
Total | 8 / 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.
- Commit
e5d0275
- 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.