Kotlin Android Reviewer Skill

Kotlin Android Reviewer Skill

Purpose

Reviews Android Kotlin code for Jetpack Compose, Coroutines, Flow, and ViewModel best practices.

When to Use

• Android Kotlin project code review
• "Compose pattern", "Coroutines", "Flow", "ViewModel" mentions
• Android performance, memory leak inspection
• Projects with Android plugin in build.gradle.kts

Project Detection

• com.android.application or com.android.library in build.gradle
• AndroidManifest.xml exists
• src/​main/​java or src/​main/​kotlin directories

Workflow

Step 1: Analyze Project

**Kotlin**: 1.9.x
**Compose**: 1.5.x
**minSdk**: 24
**targetSdk**: 34
**Architecture**: MVVM + Clean Architecture

Step 2: Select Review Areas

AskUserQuestion:

"Which areas to review?"
Options:
- Full Android pattern check (recommended)
- Jetpack Compose UI patterns
- Coroutines/​Flow usage
- ViewModel/​State management
- Memory leaks/​Performance
multiSelect: true

Detection Rules

Jetpack Compose Patterns

// BAD: Object creation without remember
@Composable
fun MyScreen() {
    val list = mutableListOf<String>()  // New every recomposition
}

// GOOD: Use remember
@Composable
fun MyScreen() {
    val list = remember { mutableListOf<String>() }
}

// BAD: Direct suspend call in Composable
@Composable
fun MyScreen(viewModel: MyViewModel) {
    viewModel.loadData()  // Side-effect!
}

// GOOD: Use LaunchedEffect
@Composable
fun MyScreen(viewModel: MyViewModel) {
    LaunchedEffect(Unit) {
        viewModel.loadData()
    }
}

Coroutines Patterns

// BAD: GlobalScope
GlobalScope.launch {
    repository.fetchData()
}

// GOOD: viewModelScope
viewModelScope.launch {
    repository.fetchData()
}

// BAD: Network on Main
viewModelScope.launch {
    val result = api.getData()  // NetworkOnMainThreadException
}

// GOOD: IO Dispatcher
viewModelScope.launch {
    val result = withContext(Dispatchers.IO) {
        api.getData()
    }
}

Flow Patterns

// BAD: Direct collect in Composable
@Composable
fun MyScreen(viewModel: MyViewModel) {
    var data by remember { mutableStateOf<Data?>(null) }
    LaunchedEffect(Unit) {
        viewModel.dataFlow.collect { data = it }
    }
}

// GOOD: collectAsState
@Composable
fun MyScreen(viewModel: MyViewModel) {
    val data by viewModel.dataFlow.collectAsState()
}

// BAD: Nullable StateFlow initial
private val _state = MutableStateFlow<UiState?>(null)

// GOOD: Sealed class with clear initial state
private val _state = MutableStateFlow<UiState>(UiState.Loading)

ViewModel Patterns

// BAD: Activity Context reference
class MyViewModel(private val context: Context) : ViewModel()

// GOOD: Application Context with Hilt
class MyViewModel(
    @ApplicationContext private val context: Context
) : ViewModel()

// BAD: Bidirectional binding
class MyViewModel : ViewModel() {
    var name = MutableLiveData<String>()
}

// GOOD: Unidirectional + sealed class
class MyViewModel : ViewModel() {
    private val _uiState = MutableStateFlow(UiState())
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()

    fun onNameChanged(name: String) {
        _uiState.update { it.copy(name = name) }
    }
}

Memory Leak Detection

Response Template

## Android Kotlin Code Review Results

**Project**: [name]
**Kotlin**: 1.9.x | **Compose**: 1.5.x
**Files Analyzed**: X

### Jetpack Compose
| Status | File | Issue |
|--------|------|-------|
| HIGH | ui/​HomeScreen.kt | Object creation without remember (line 45) |
| MEDIUM | ui/​ProfileScreen.kt | State hoisting recommended |

### Coroutines/​Flow
| Status | File | Issue |
|--------|------|-------|
| CRITICAL | data/​Repository.kt | GlobalScope usage (line 23) |
| HIGH | viewmodel/​MainViewModel.kt | Missing exception handling |

### ViewModel/​State
| Status | File | Issue |
|--------|------|-------|
| HIGH | viewmodel/​DetailViewModel.kt | Activity Context reference |

### Recommended Actions
1. [ ] GlobalScope → viewModelScope
2. [ ] Add remember { }
3. [ ] Apply UiState sealed class pattern

Best Practices

1. Compose: Prefer Stateless Composable, State hoisting
2. Coroutines: Structured concurrency, appropriate Dispatcher
3. Flow: Distinguish Hot/​Cold Flow, StateFlow for UI state
4. ViewModel: Unidirectional data flow, avoid Context
5. Testing: Turbine for Flow, Compose test rules

Integration

• code-reviewer skill: General Kotlin code quality
• kotlin-multiplatform-reviewer skill: KMP shared code
• test-generator skill: Android test generation

Notes

• Based on Compose 1.0+
• Kotlin 1.9+, Coroutines 1.7+ recommended
• Supports Hilt/​Dagger DI patterns