Menu
Creates a new Model file following the project's architecture (object with State, Action/Actions, and a @Factory Presenter). Use this when the user wants to add a new screen's logic or data state.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Scaffolds a complete feature package — Model, View, and Presenter unit tests — following the project's Molecule + Koin architecture. Orchestrates the create-model, create-view, and create-model-test skills. Creates a module file only when third-party dependencies are needed. Use this when the user wants to add a new screen end-to-end.
Creates a Repository interface, its implementation, optional SQLDelight schema, and a Fake for testing — following the project's Koin + StateFlow architecture. Use this skill whenever the user wants to add a data layer for a feature, persist data, fetch from an API, connect a Presenter to real data, or asks about "repository", "data layer", "database table", or "API integration" in this project.
Migrates an existing Android application module to the Molecule + Koin + Navigation3 architecture used in this project, so the create-feature skill can be used to add features. Updates build.gradle.kts (plugins, Java 17, dependencies), creates the Application class, retainMolecule.kt, and rewrites MainActivity with the Navigation3 scaffold. Use this when porting an app from any other architecture.
Creates unit tests for a Model's Presenter following the project's Molecule + Turbine testing pattern. Use this when the user wants to add tests for a Model created with the create-model skill.
Creates a new View file for a Model following the project's Compose + Molecule architecture (object with two Pane overloads — a connected one that injects the Presenter, and a stateless one that takes State directly). Optionally wires it into MainActivity navigation and the ListView menu. Use this when the user wants to add a screen UI for an existing or new Model.
Based on SOC occupation classification
| name | create-model |
| description | Creates a new Model file following the project's architecture (object with State, Action/Actions, and a @Factory Presenter). Use this when the user wants to add a new screen's logic or data state. |
| metadata | {"author":"leandro","version":"1.0"} |
This skill guides the creation of a "Model" which encapsulates the state and logic for a feature or screen in this project.
A Model should be defined as a Kotlin object containing:
sealed interface Action or an interface Actions defining user interactions.data class State containing all the data needed by the view, including the perform: (Action) -> Unit lambda or an actions: Actions implementation.@Factory annotated class with an @Composable operator fun invoke(...) that returns the State.Identify what data the screen needs to display and what actions the user can take.
Create a new file <FeatureName>Model.kt in the appropriate package.
package com.gethomsefe.arch26.<feature>
import androidx.compose.runtime.Composable
import org.koin.core.annotation.Factory
object <FeatureName>Model {
sealed interface Action {
// Define actions here
}
data class State(
// Define state properties here
val perform: (Action) -> Unit
)
@Factory
class Presenter {
@Composable
operator fun invoke(): State {
// Manage state using Compose remember/mutableStateOf
return State(
perform = { action ->
when (action) {
// Handle actions
}
}
)
}
}
}
androidx.compose.runtime primitives (remember, mutableStateOf, mutableIntStateOf, etc.) inside the Presenter.invoke() function.rememberLoader helper if available, or LaunchedEffect for side effects.Presenter is annotated with @Factory.object EditModel {
interface Actions {
fun increment()
fun decrement()
}
data class State(
val count: Int,
val actions: Actions
)
@Factory
class Presenter {
@Composable
operator fun invoke(initialCount: Int): State {
var count by remember { mutableIntStateOf(initialCount) }
return State(count, object : Actions {
override fun increment() { count++ }
override fun decrement() { count-- }
})
}
}
}
object SlotsModel {
sealed interface Action {
data object Pull : Action
}
data class State(
val slot1: Loader<Char>,
val perform: (Action) -> Unit
)
@Factory
class Presenter {
@Composable
operator fun invoke(): State {
var slot1 by rememberLoader {
delay(1000)
Random.nextInt(65, 91).toChar()
}
return State(
slot1 = slot1,
perform = {
when (it) {
Action.Pull -> { slot1 = Busy(Unit) }
}
}
)
}
}
}