android-native-dev

Standardize Gradle setup and build variants for native Android Kotlin and Jetpack Compose projects.

2|Updated May 3, 2026
One-click install
npx skills add https://github.com/Rosetears520/aili-workflows --skill android-native-dev-rosetears520
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: android-native-dev
Source: https://github.com/Rosetears520/aili-workflows/tree/main/skills/android-native-dev
Command: npx skills add https://github.com/Rosetears520/aili-workflows --skill android-native-dev-rosetears520

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Helps you scaffold and build native Android apps reliably by standardizing Gradle setup, dependencies, build variants, Kotlin patterns, Jetpack Compose practices, and common error diagnosis so you can ship a stable Material 3 experience.

Core Features & Use Cases

  • Project scenario assessment & required-file checklist: Choose the correct path for empty, partial, or existing Android Studio/Gradle projects before touching business logic.
  • Gradle + dependency standards: Set AndroidX/Jetifier, use Compose BOM, and configure build variants (flavors/buildTypes) with predictable build command names.
  • Kotlin, threading, and Compose guardrails: Enforce null-safety, exception-handling discipline, coroutine threading (Main vs IO/Default), and Compose best practices to avoid common crashes and warnings.
  • UI/UX compliance for Material 3: Apply accessibility, touch target sizing, contrast guidance, theming, and resource naming rules (including reserved-name avoidance).
  • Debugging and quality workflows: Provide practical fixes for frequent Gradle/AAPT/code errors and guidance for test layering (unit/robolectric/Espresso/Compose tests).

Quick Start

Use this skill to get a complete checklist and Gradle build commands for your native Android Kotlin/Jetpack Compose project so that ./gradlew assembleDebug succeeds before implementing features.

Frequently Asked Questions about android-native-dev

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I configure Gradle build variants and flavors for a Jetpack Compose app?

To configure Gradle build variants for Jetpack Compose, use the Compose BOM for dependency versions and define your flavors and buildTypes to generate predictable assemble commands. This ensures variant setup aligns with AndroidX and Material 3 standards for reliable builds.

Why does my Gradle build fail with resource conflicts during Android compilation?

Gradle build failures during Android compilation often stem from AAPT resource conflicts or incorrect dependency versions. You can resolve these build errors by checking the gradle.properties file for AndroidX/Jetifier settings and running diagnostic steps to identify specific resource or dependency conflicts.

What are the best practices for Compose state management and coroutine threading?

Best practices for Compose state and coroutines involve enforcing null-safety and exception-handling discipline while correctly routing tasks between Main and IO/Default threads. Following these guardrails prevents common crashes and ensures stable UI rendering in Kotlin.

How do I meet Material 3 accessibility and touch target requirements in Android?

To meet Material 3 accessibility requirements in Android, apply theming rules and ensure touch target sizing meets minimum dimensions. You must also follow contrast guidance and resource naming rules, including avoiding reserved names, to achieve full compliance.

Can I use this approach to recover an existing partial Android Studio project?

Yes, you can use this skill to recover an existing partial Android Studio project. It assesses your project scenario and provides a required-file checklist to standardize Gradle setup and dependencies before you implement any business logic.

What testing layers should I set up for a native Android Kotlin app?

For a native Android Kotlin app, you should establish test layering using unit tests, Robolectric, Espresso, and Compose tests. This quality workflow helps catch errors early and verifies that your Gradle build variants function correctly across different configurations.