
Android Design Guidelines
Apply Material Design 3 and Android platform rules when building or reviewing Jetpack Compose and XML UI so apps feel native and pass accessibility expectations.
Overview
android-design-guidelines is an agent skill most often used in Build (also Ship) that encodes Material Design 3 and Android UI rules with prioritized never-do constraints for Compose and XML.
Install
npx skills add https://github.com/ehmo/platform-design-skills --skill android-design-guidelinesWhat is this skill?
- Full SKILL.md rules plus indexed `rules/_sections.md` for quick lookup
- CRITICAL, HIGH, and MEDIUM priority tiers for enforcement during review
- Material You / dynamic color via `MaterialTheme.colorScheme`—no hardcoded hex
- Compose and View guidance: BackHandler, predictive back, 48dp touch targets, single FAB
- Never-do list covers permissions, dark theme surfaces, nav bar labels, and dialog vs Snackbar
- Three priority tiers: CRITICAL, HIGH, and MEDIUM
- Documented never-do list with nine explicit anti-patterns in catalog excerpt
Adoption & trust: 845 installs on skills.sh; 387 GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your Android UI drifts from Material 3 and platform conventions, creating accessibility failures and store-review friction.
Who is it for?
Indie Android developers using agents to implement or review Compose/XML who want enforced Material 3 and accessibility guardrails.
Skip if: iOS-only or cross-platform projects where Flutter/React Native design systems are the source of truth, or greenfield brand exploration with no Android ship target.
When should I use this skill?
Building or reviewing Android UI, implementing Material You, designing navigation or components, or auditing accessibility and platform compliance.
What do I get? / Deliverables
Generated or reviewed screens follow themed color roles, correct typography units, predictive back, and navigation patterns that match Google’s Android design expectations.
- UI code aligned to SKILL.md rules and section index
- Review notes flagged by CRITICAL vs HIGH vs MEDIUM severity
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
UI implementation is the canonical shelf for Material You, navigation, and component work on Android. Frontend mobile UI is where Compose layouts, touch targets, and theme tokens are applied daily.
Where it fits
Implement a settings screen with correct color roles, sp text, and a single FAB for the primary action.
Wire bottom navigation with required labels instead of icon-only items.
Run a CRITICAL/HIGH rule pass before cutting a Play Store release build.
How it compares
Use as a prioritized Android/Material rulepack for agents, not as a replacement for your own brand system or Play Store listing copy skills.
Common Questions / FAQ
Who is android-design-guidelines for?
Solo builders and small teams writing Jetpack Compose or View-based Android UI who want agents to respect Material Design 3 and platform accessibility rules.
When should I use android-design-guidelines?
During build while implementing layouts and theming, and at ship during review before release when auditing navigation, touch targets, and dark theme surfaces.
Is android-design-guidelines safe to install?
It is documentation and rules for UI code; check this page’s Security Audits panel like any third-party skill and avoid piping proprietary design assets you cannot share into the agent.
SKILL.md
READMESKILL.md - Android Design Guidelines
# Android Design Skill Material Design 3 guidelines and Android platform conventions for Jetpack Compose and XML layouts. ## Structure - `SKILL.md` — Full guideline rules with code examples - `rules/_sections.md` — Indexed section breakdown for quick lookup - `metadata.json` — Version and reference metadata ## Usage Apply these guidelines when: - Building or reviewing Android UI code - Implementing Material You / dynamic color - Designing navigation, layout, or component architecture - Auditing accessibility or platform compliance ## Priority Rules marked **CRITICAL** must never be violated. Rules marked **HIGH** should be followed unless there is a documented reason. Rules marked **MEDIUM** are recommended best practices. ## Never Do - Never hardcode color hex values — always use `MaterialTheme.colorScheme` color roles - Never use `dp` for text sizes — use `sp` so user font scaling applies - Never override `onBackPressed()` — use `BackHandler` (Compose) or `OnBackInvokedCallback` (View-based) for predictive back - Never place touch targets below 48x48dp — accessibility violation - Never request permissions at app launch — request in context with a rationale - Never use pure black (#000000) for dark theme backgrounds — use Material surface roles - Never put icon-only items in the navigation bar — labels are required - Never use a dialog for non-critical information — prefer Snackbar or Bottom Sheet - Never use more than one FAB on a screen — one FAB for the single primary action - Never show full-width content on tablet layouts — use list-detail or max-width containers --- name: android-design-guidelines description: Material Design 3 and Android platform guidelines. Use when building Android apps with Jetpack Compose or XML layouts, implementing Material You, navigation, or accessibility. Triggers on tasks involving Android UI, Compose components, dynamic color, or Material Design compliance. license: MIT metadata: author: platform-design-skills version: "1.0.0" --- # Android Platform Design Guidelines — Material Design 3 ## 1. Material You & Theming [CRITICAL] ### 1.1 Dynamic Color Enable dynamic color derived from the user's wallpaper. Dynamic color is the default on Android 12+ and should be the primary theming strategy. ```kotlin // Compose: Dynamic color theme @Composable fun AppTheme( darkTheme: Boolean = isSystemInDarkTheme(), dynamicColor: Boolean = true, content: @Composable () -> Unit ) { val colorScheme = when { dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> { val context = LocalContext.current if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context) } darkTheme -> darkColorScheme() else -> lightColorScheme() } MaterialTheme( colorScheme = colorScheme, typography = AppTypography, content = content ) } ``` ```xml <!-- XML: Dynamic color in themes.xml --> <style name="Theme.App" parent="Theme.Material3.DayNight.NoActionBar"> <item name="dynamicColorThemeOverlay">@style/ThemeOverlay.Material3.DynamicColors.DayNight</item> </style> ``` **Rules:** - R1.1: Always provide a fallback static color scheme for devices below Android 12. - R1.2: Never hardcode color hex values in components. Always reference color roles from the theme. - R1.3: Test with at least 3 different wallpapers to verify dynamic color harmony. ### 1.2 Color Roles Material 3 defines a structured set of color roles. Use them semantically, not aesthetically. | Role | Usage | On-Role | |------|-------|---------| | `primary` | Key actions, active states, FAB | `onPrimary` | | `primaryContainer` | Less prominent primary elements | `onPrimaryContainer` | | `secondary` | Supporting UI, filter chips | `onSecondary` | | `secondaryContainer` | Navigation bar active indicator | `onSecondaryContainer` | | `tertiary` | Accent, contrast, complementary | `onTertiary` | | `terti