Skip to content
Skills Library
Programming · Building & coding

android-studio

/android-studio

Expert Android Studio IDE assistance covering Gradle sync, Logcat, Layout Inspector, SDK Manager, and virtual devices (AVD). Use when developing native Android applications with Kotlin or Java.

Licence
MIT
Last repository change
01.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 01.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Expert Android Studio IDE assistance covering Gradle sync, Logcat, Layout Inspector, SDK Manager, and virtual devices (AVD). Use when developing native Android applications with Kotlin or Java.

Original author description

Expert Android Studio IDE assistance covering Gradle sync, Logcat, Layout Inspector, SDK Manager, and virtual devices (AVD). Use when developing native Android applications with Kotlin or Java.

How it works

  1. When to Use
  2. Quick Start
  3. Core Concepts
  4. Common Patterns
  5. Best Practices
  6. Troubleshooting
  7. References
Original SKILL.md headings · 155 lines, 598 words
SKILL.md preview
---
name: android-studio
description: Expert Android Studio IDE assistance covering Gradle sync, Logcat, Layout Inspector, SDK Manager, and virtual devices (AVD). Use when developing native Android applications with Kotlin or Java.
---

# Android Studio

Android Studio is the official integrated development environment (IDE) for Android application development, built on IntelliJ IDEA with rich profiling and emulator tools.

## When to Use

- **Native Android & Jetpack Compose Development**: Official Google IDE with visual layout editor, Compose preview, and Profiler.
- **Gradle Build Script Optimization**: Configuring multi-module build logic with Kotlin DSL (`build.gradle.kts`).
- **Android Emulator & Device Management**: Running virtual and physical devices via ADB and headless emulator CLI.
- **App Performance & Memory Profiling**: Diagnosing frame drops, memory leaks, and CPU spikes using Android Studio Profiler.

## Quick Start

```bash
# Launch Android Studio or build project from command line
./gradlew assembleDebug

# Install and run on connected device/emulator
./gradlew installDebug
adb shell am start -n "com.example.app/.MainActivity"
```

## Core Concepts

### Jetpack Compose Preview & UI Inspection

Authoring declarative UI with multi-device previews:

```kotlin
import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp

@Composable
fun MetricCard(title: String, value: String, modifier: Modifier = Modifier) {
    Card(
        modifier = modifier.padding(8.dp),
        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant)
    ) {
        Column(modifier = Modifier.padding(16.dp)) {
            Text(text = title, style = MaterialTheme.typography.labelMedium)
            Spacer(modifier = Modifier.height(4.dp))
            Text(text = value, style = MaterialTheme.typography.headlineMedium)
        }
    }
}

// Interactive Preview for Android Studio Design Canvas
@Preview(name = "Light Mode", showBackground = true)
@Preview(name = "Dark Mode", uiMode = android.content.res.Configuration.UI_MODE_NIGHT_YES)
@Composable
fun MetricCardPreview() {
    MaterialTheme {
        MetricCard(title = "Network Throughput", value = "1.2 GB/s")
    }
}
```

### Modern Gradle Build Configuration (build.gradle.kts)

Multi-module build setup with version catalogs:

```kotlin
// app/build.gradle.kts
plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
    alias(libs.plugins.compose.compiler)
}

android {
    namespace = "com.company.enterpriseapp"
    compileSdk = 35

    defaultConfig {
        applicationId = "com.company.enterpriseapp"
        minSdk = 26
        targetSdk = 35
        versionCode = 1
        versionName = "2026.1.0"
    }

    buildTypes {
        release {
            isMinifyEnabled = true
            isShrinkResources = true
            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
        }
    }
}
```

### Headless Emulator & ADB Operations

Managing testing devices from command line:

```bash
# List available Android Virtual Devices (AVDs)
emulator -list-avds

# Launch AVD headlessly in CI runner
emulator -avd Pixel_8_API_35 -no-window -no-audio -no-boot-anim &

# Wait for device to complete boot
adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;'
```

## Common Patterns

### Gradle Build Cache and Memory Optimization

**Problem**: Slow Gradle build and sync times inside Android Studio.

**Solution**:
Configure build properties in `gradle.properties`:

```properties
org.gradle.jvmargs=-Xmx4096m -XX:+UseParallelGC
org.gradle.parallel=true
org.gradle.caching=true
org.gradle.configuration-cache=true
android.useAndroidX=true
```

## Best Practices

**Do**:

- Migrate build scripts to Kotlin DSL (`build.gradle.kts`) and Gradle Version Catalogs (`libs.versions.toml`).
- Enable R8 code shrinking and resource minification (`isMinifyEnabled = true`) on release builds.
- Utilize Android Studio Profiler (CPU, Memory, Energy) before pushing production releases.
- Allocate sufficient heap memory to the Gradle daemon in `gradle.properties` (`org.gradle.jvmargs=-Xmx4096m`).

**Don't**:

- Leave debug signing credentials in open repositories; inject keystores via environment variables.
- Run heavy unit tests on the Android Emulator if pure JVM unit tests (`src/test`) suffice.
- Ignore Lint warnings; configure `lint { abortOnError = true }` in CI.

## Troubleshooting

| Error                                          | Cause                                                                 | Solution                                                                 |
| :--------------------------------------------- | :-------------------------------------------------------------------- | :----------------------------------------------------------------------- |
| `Gradle sync failed: Connection timed out`     | Proxy, firewall, or Gradle wrapper downloading over slow network.     | Check offline work in Gradle settings or use pre-downloaded wrapper.     |
| `Installed Build Tools revision is corrupted`  | Incomplete download of Android SDK Build Tools.                       | Open SDK Manager, uninstall affected Build-Tools version, and reinstall. |
| `Emulator: Process crashed with exit code 139` | Hardware acceleration (HAXM/Hypervisor) conflict or GPU driver issue. | Change Emulator settings > Emulated Performance: Graphics to 'Software'. |

## References

- [Android Studio User Guide](https://developer.android.com/studio/intro)

Versions

The database has no other skills named android-studio.

Database snapshot: 13.11.2026 · package version bc67c3ed521c (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100android-sdk
    Expert Android SDK assistance covering Android architecture components, Activity/Fragment lifecycles, permissions, background work with WorkManager, and Gradle build optimizations. Use when building native Android applications, configuring ProGuard/R8, or interacting with platform SDK APIs.
  • 100android-emulator-build
    Assembles Release APKs with Gradle on an AVD started by name (pinned JDK and SDK) and inspects them. Use when trying the app on the Android emulator, or Gradle, adb, an AVD or the SDK fails. Not for Play uploads (android-release-play).
  • 90kotlin-android
    Build and upgrade native Android applications with Kotlin, Compose/View UI and lifecycle-aware work. Use when implementing Android screens, navigation, permissions or background jobs; coordinate Kotlin, Gradle, AGP and SDK compatibility.
  • 100android-debugging
    Use when debugging Android or KMP issues — Android-specific techniques covering Logcat, ADB, ANR traces, R8 stack trace decoding, memory leaks, Gradle build failures, and Compose recomposition bugs, on a root-cause-first foundation.
  • 90Android Gradle
    Fix Android Gradle builds on the phone: AGP/Gradle compatibility, SDK/build-tools, memory, daemon, offline mode and common error messages. Use when configuration or plugin resolution fails.
  • 100tracing-recompositions-at-runtime
    Use this skill to instrument a Jetpack Compose composable with `@TraceRecomposition` from `skydoves/compose-stability-analyzer` so per-recomposition diffs (which state or parameter changed, what value transition) print to logcat under the `Recomposition` tag. Works in…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.