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

| Check | Recommendation | Severity | |-------|----------------|----------| | Side-effect in Composable | Use LaunchedEffect/SideEffect | HIGH | | Object creation without remember | Use remember { } | HIGH | | Missing State hoisting | Hoist state to parent | MEDIUM | | Missing derivedStateOf | Use for derived state | LOW | | LazyColumn without key | Add key parameter | HIGH |

// 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

| Check | Recommendation | Severity | |-------|----------------|----------| | GlobalScope usage | Use viewModelScope/lifecycleScope | CRITICAL | | Missing Dispatcher | Specify Dispatchers.IO/Default | MEDIUM | | Missing exception handling | try-catch or CoroutineExceptionHandler | HIGH | | runBlocking abuse | Convert to suspend function | HIGH |

// 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

| Check | Recommendation | Severity | |-------|----------------|----------| | Direct collect in Composable | Use collectAsState | HIGH | | SharedFlow without replay | Set appropriate replay value | MEDIUM | | Nullable StateFlow initial | Provide meaningful initial value | MEDIUM |

// 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

| Check | Issue | Severity | |-------|-------|----------| | Direct Context reference | Memory leak risk | CRITICAL | | View reference | Memory leak risk | CRITICAL | | Missing SavedStateHandle | Process death handling | MEDIUM | | Bidirectional data flow | Use UiState + Event pattern | MEDIUM |

// 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

| Check | Problem | Solution | |-------|---------|----------| | Inner class with outer reference | Activity leak | WeakReference or static | | Unremoved Listener | Memory leak | Remove in onDestroy | | Uncancelled Coroutine Job | Job leak | Structured concurrency | | Unreleased Bitmap | OOM risk | recycle() or Coil/Glide |

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