name: android-dev-assistant
description: "Comprehensive Android native development assistant for Compose UI, Kotlin, MVVM architecture, unit testing, and CI/CD integration. Use when working on Android development queries including: (1) Jetpack Compose UI patterns and performance optimization (recomposition, list performance), (2) MVVM architecture without Clean Architecture layer (ViewModels with Koin dependency injection, repositories, data layer), (3) Android feature development (API 34+), (4) Unit and integration testing (ViewModels, repositories, Compose UI), (5) CI/CD pipeline setup and optimization (GitLab CI, Jenkins, Checkmarx security scanning)."

Android Development Assistant

Comprehensive guide for Android native development with Compose UI, Kotlin, MVVM architecture patterns, testing, and CI/CD integration.

When to Use This Skill

This skill triggers for Android native development questions including:

• Jetpack Compose UI patterns and best practices
• Performance optimization (recomposition issues, LazyColumn/LazyRow performance)
• MVVM architecture patterns with Koin dependency injection
• Repository patterns and data layer design
• Unit testing ViewModels and repositories
• Integration testing (Room database, API services)
• UI testing with Compose Test
• CI/CD pipeline setup (GitLab CI, Jenkins)
• Android feature development for API level 34+

Reference Guides

This skill includes comprehensive reference documentation. Load the appropriate reference based on the user's query:

Performance Optimization (references/performance-optimization.md)

Read this when the user asks about:
- Compose recomposition issues or optimization
- List performance (LazyColumn, LazyRow)
- Memory management and leak prevention
- App startup optimization
- Profiling and debugging performance issues

MVVM Architecture (references/mvvm-patterns.md)

Read this when the user asks about:
- ViewModel structure and patterns
- Repository layer design
- State management (StateFlow, LiveData)
- Data layer (Room, Retrofit, DataStore)
- Navigation patterns
- Koin dependency injection setup

Compose UI Patterns (references/compose-ui-patterns.md)

Read this when the user asks about:
- Composable structure and best practices
- State management in Compose (remember, rememberSaveable)
- Layout patterns (Scaffold, LazyColumn, dialogs, bottom sheets)
- Material 3 theming
- Side effects (LaunchedEffect, DisposableEffect)
- Form handling and validation
- Animations

Testing Patterns (references/testing-patterns.md)

Read this when the user asks about:
- Unit testing ViewModels
- Testing repositories with MockK
- Integration testing (Room, Retrofit with MockWebServer)
- Compose UI testing
- Test fixtures and data builders
- Test coverage and best practices

CI/CD Integration (references/ci-cd-android.md)

Read this when the user asks about:
- GitLab CI/CD pipeline setup
- Jenkins pipeline configuration
- Build variants and flavors
- Signing configuration
- Fastlane integration
- Firebase App Distribution
- Checkmarx security scanning integration
- Code quality tools (Detekt, Ktlint)
- Build optimization

Architecture Conventions

Important context for all Android development questions:

• No Clean Architecture: The team uses MVVM without the use cases/domain layer. ViewModels interact directly with repositories.
• Dependency Injection: Use Koin, not Dagger/Hilt
• Minimum API Level: Target API 34 (Android 14) and above
• UI Framework: Pure Jetpack Compose (not Flutter or hybrid)

Code Quality Standards

When providing code examples:

1. Use Kotlin idioms and best practices
2. Follow Material 3 design guidelines
3. Implement proper error handling
4. Include appropriate comments for complex logic
5. Consider performance implications (especially for Compose)
6. Use immutable data structures where appropriate
7. Follow naming conventions (camelCase for variables/functions, PascalCase for classes)

Response Guidelines

When answering queries:

1. Read the relevant reference first - Always check the appropriate reference file before answering
2. Provide working code examples - Include complete, runnable code snippets
3. Explain the why - Don't just show code, explain the reasoning behind patterns
4. Consider context - Keep team conventions (Koin, no Clean Architecture, API 34+) in mind
5. Show alternatives - When multiple approaches exist, explain trade-offs
6. Reference performance - Call out performance implications when relevant
7. Include testing - Suggest how to test the code when appropriate