android-engineering-core
This skill is used to implement Android features within the existing Kotlin, Compose, Room, Hilt and Navigation architecture, including data, navigation and background work.
When & Why to Use This Skill
The Android Engineering Core skill is designed to accelerate the development of robust mobile applications by automating the implementation of features within a modern Android stack. It specializes in generating clean, production-ready code using Kotlin, Jetpack Compose, Room, and Hilt, ensuring that new features seamlessly integrate into existing architectures while adhering to best practices for data persistence, dependency injection, and UI state management.
Use Cases
- Feature Implementation: Rapidly building out new application modules including ViewModels, UI components with Compose, and business logic.
- Data Layer Development: Creating and updating Room entities, DAOs, and handling complex database migrations for local storage.
- Navigation & Routing: Wiring up multi-screen navigation flows using Jetpack Navigation and managing state across destinations.
- Background Services: Integrating platform-level components like AlarmManager and Notifications for scheduled tasks and user alerts.
- Architecture Alignment: Refactoring or extending existing codebases to strictly follow Hilt dependency injection and MVVM patterns.
| name | android-engineering-core |
|---|---|
| description | This skill is used to implement Android features within the existing Kotlin, Compose, Room, Hilt and Navigation architecture, including data, navigation and background work. |
Android Engineering and Core Implementation Skill
Purpose
Implement the shaped and designed Android feature in the existing architecture, covering data persistence, business logic, navigation, reminders and background behaviour.
When to Use
Use this skill once product shaping and UX design are complete and the UI structure is known.
Outputs
- Updated Room entities, DAOs and migrations when required
- Repository and use-case logic
- ViewModel state and event handling
- Navigation wiring
- Integration with AlarmManager, notifications or other platform components
Procedure
- Confirm the slice fits within the current stack:
- Kotlin, Coroutines and Flow
- Room for local data
- Hilt for dependency injection
- Jetpack Navigation and Compose for UI
- Apply the smallest data changes needed:
- Adjust existing entities where possible.
- Add new entities only when the UX slice truly demands it.
- Create safe Room migrations for any schema changes.
- Map user actions from the UX design to ViewModel events:
- Define clear intent functions (for example onAddTask, onToggleComplete).
- Keep side effects (saving, scheduling reminders) in the ViewModel or use-case layer, not in composables.
- Implement repositories or use-cases:
- Keep them focused on data and business logic.
- Expose Flows or suspend functions as appropriate.
- Wire navigation:
- Add or adjust routes in the NavHost.
- Pass arguments via navigation arguments and SavedStateHandle.
- Integrate platform services carefully:
- Use AlarmManager, Notifications and BroadcastReceivers for reminders when required.
- Handle boot rescheduling if reminders depend on time.
- Avoid new background frameworks unless necessary.
Guardrails
- Do not change the overall architecture or introduce new frameworks.
- Do not move logic into composables.
- Do not add network sync, backends or multi-device features unless explicitly required by shaping.
- Prefer small, incremental changes over broad refactors.