understanding-hot-reload-limits — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited understanding-hot-reload-limits (Agent Skill) and scored it 100/100 (green). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 0 high-severity and 0 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 0 flagged
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
Android Runtime (ART) enforces strict rules for class redefinition: a redefined class must have an identical schema (fields, method signatures, interfaces) as the previous version. Only method bodies are mutable at runtime. HotSwan automatically detects schema changes and falls back to a full incremental build, so failures are not silent. Knowing the boundary in advance is what keeps an iteration loop sub-second instead of multi-second.
inline fun change that "didn't reload" and is debugging.../setting-up-compose-hotswan/SKILL.md.../setting-up-compose-hotswan/SKILL.md (tool window status WATCHING, body-only edit reloads in under one second).| Change | Notes |
|---|---|
| Composable function body | text, colors, modifiers, layout, control flow inside the function |
| Non-composable function body | ViewModel methods, mappers, utilities, repositories |
| Adding a new composable | same file or new file |
| Reordering composables | HotSwan 1.2.0+ |
| Resource value changes | strings.xml value, colors.xml value, dimens.xml value |
| Extension functions | including suspend, including vararg |
Adding data class properties | API 30+ only |
| Numeric, string, float literal patches | compiled separately for fastest reload |
| Change | Reason |
|---|---|
| Adding or removing function parameters | method signature changes |
| Constructor changes | parameter list, default values, init blocks affecting fields |
| Interface or superclass changes | class hierarchy is part of the schema |
| Adding new resource ids | new R.string, R.drawable, R.id entries require generated R class regeneration |
| Inline functions | expanded at every call site; no discrete unit to swap |
| Lambda count change inside a function | internal lambda class renumbering |
| Removing a previously defined function | method table shrinks; schema changes |
Adding data class properties below API 30 | constructor schema change without ART support |
inline while iterating, hot-reload as needed, and restore inline before commit. If iteration is rare or the perf characteristic must be preserved, accept the rebuild.<string name="title">Updated Title</string> (existing id) hot-reloads; adding <string name="brand_new_id">...</string> does not.// RIGHT (body-only change, hot-reloads)
@Composable
fun Greeting() {
Text("Hello, World", color = Color.Blue)
}// WRONG for the fast path (signature change, forces rebuild)
@Composable
fun Greeting(name: String) {
Text("Hello, $name")
}
// WRONG because: adding a parameter changes the method signature, which violates ART's class
// schema constraint. To stay inside the fast path, introduce the parameter with a default value
// in one save (still a rebuild; accept it once), then iterate on the body across subsequent saves.// RIGHT (new composable in the same file, hot-reloads on HotSwan 1.2.0+)
@Composable
fun SecondaryAction() {
Text("New")
}// WRONG for the fast path (constructor change)
data class User(val id: Long, val name: String, val age: Int)
// WRONG because: adding `age` extends the constructor. On API 30+ HotSwan supports adding
// data class properties; below API 30 the schema change forces a rebuild. When targeting older
// minSdk, batch property additions and accept a rebuild for each.// WRONG for the fast path
inline fun <T> Modifier.observer(value: T, body: (T) -> Modifier): Modifier = body(value)
// WRONG because: inline functions are expanded at every call site at compile time. There is no
// discrete unit to swap, so editing the inline body forces a full rebuild of every call site.
// Drop `inline` for the duration of iteration, or accept the rebuild.// RIGHT for the fast path (non-inline variant during iteration)
fun <T> Modifier.observer(value: T, body: (T) -> Modifier): Modifier = body(value)<!-- RIGHT: value change on an existing id, hot-reloads -->
<string name="title">Updated Title</string><!-- WRONG for the fast path: new id, forces rebuild -->
<string name="brand_new_id">Hello</string>
<!-- WRONG because: adding a new string id grows the generated R class. R class regeneration
is a schema change that ART cannot redefine in place. -->// RIGHT (body change inside the existing lambda, hot-reloads)
@Composable
fun Row() {
Button(onClick = { log("tapped") }) { Text("Tap") }
}// WRONG for the fast path (adds a second lambda, renumbers inner lambda classes)
@Composable
fun Row() {
Button(onClick = { log("tapped") }) { Text("Tap") }
Button(onClick = { log("second") }) { Text("Second") }
}
// WRONG because: a Kotlin function's compiled lambdas are anonymous classes named like
// Row$lambda$1, Row$lambda$2. Adding a lambda renumbers them and changes the class table,
// which is a schema change. The fix is to add the second composable as a separate top-level
// function (which is supported), then call it from Row once the structural change has rebuilt.:app:clean for a clean build; HotSwan auto-falls-back when needed and turning it off costs the next round-trip.WATCHING.<string> resource triggers the fallback; editing an existing <string> value does not.inline function triggers the fallback; converting it to a non-inline function and editing the body hot-reloads.data class hot-reloads on a device running API 30+; on API 29 and below it triggers the fallback./docs/supported-changes)./docs/limitations).../setting-up-compose-hotswan/SKILL.md for installation and the first save-to-reload verification.~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.