Skills

Onboard a future AI session to a specific slice of an existing codebase before a migration, refactor, or extension. Produces onboarding docs under ./onboarding/ — a repo-global glossary that is amended across slices, plus per-slice decision records and (when existing code is affected) a navigation map. Use this skill whenever the user is about to change part of an unfamiliar or inherited codebase and says things like "onboard an agent to this slice", "prepare context before I refactor X", "scope this change", "I'm about to extend/migrate Y", "where do I start in this repo", or "onboard me to this codebase". Reach for it even when the user doesn't say "onboarding" but is clearly trying to build durable context for an upcoming change rather than make the change itself.

Background work patterns for Android/KMP - WorkManager (one-time, periodic, expedited, foreground promotion), foreground services, work observation, Koin WorkerFactory, and the SyncScheduler abstraction. Use this skill whenever implementing background sync, scheduling periodic work, creating a foreground service, observing work progress, setting up WorkManager with Koin, or deciding between WorkManager and foreground services. Trigger on phrases like "WorkManager", "background work", "sync worker", "periodic sync", "foreground service", "schedule sync", "SyncScheduler", "CoroutineWorker", "work observation", "expedited work", or "background sync".

Orchestrates Android development tasks including project creation, deployment, SDK management, and environment diagnostics using the `android` command-line tool.

Compose screen-level architecture for Android/KMP - stability, recomposition strategy, state ownership, side effects, lazy layouts, deferred state reads, and TextField state dispatching. Use this skill whenever architecting a Compose screen's structure, optimizing recomposition at the screen level, deciding state ownership between ViewModel and composables, adding side effects, structuring lazy layouts, or making screen-level performance decisions. This skill is about HOW screens are structured, not how individual components are built — for component construction, see android-compose-components. Trigger on phrases like "recomposition", "stability", "@Stable", "LaunchedEffect", "DisposableEffect", "LazyColumn performance", "collectAsStateWithLifecycle", "derivedStateOf", "screen layout", "Compose performance", "deferred state read", or "state ownership".

Building individual Compose UI components for Android/KMP — IconButton wrapping, project icon objects, previews per state, parameter design, sizing with relative modifiers, theme colors, design system reuse, Material 3 as the base for design-system components, component decomposition, string resources, animations in graphicsLayer, slot composables, and modifier extensions. Use this skill whenever writing or modifying a composable function that is NOT a Root/Screen-level composable: buttons, cards, list items, toolbars, input fields, bottom sheets, dialogs, or any extracted sub-composable. This skill applies every time you write raw Compose UI code for a component — even small ones. For Root/Screen composables, use android-presentation-mvi instead. Trigger on phrases like "create a component", "composable function", "IconButton", "Icon composable", "preview", "modifier extension", "slot API", "design system component", "shared button", "custom icon button", "design-system icon button", "wrap Material 3", "Fill

Koin dependency injection setup for Android/KMP - module definitions per layer, ViewModel injection, assembling modules in :app, and koinViewModel() in composables. Use this skill whenever setting up Koin, defining a DI module, providing a repository or ViewModel, injecting a dependency, or wiring modules in the Application class. Trigger on phrases like "set up Koin", "add a Koin module", "inject a dependency", "DI module", "koinViewModel", "provide a ViewModel", "startKoin", or "single/viewModel/factory".

Integration testing for Android - wire real production classes together (real repositories, real DAOs, real data sources) and only swap test doubles at the boundaries that leave the device: Ktor MockEngine for HTTP, in-memory Room for storage, fake Clock, WorkManagerTestInitHelper for background work. Instrumented tests preferred (no Robolectric). An integration test crosses at least one I/O / process / external-state boundary. Use this skill whenever writing or reviewing tests that touch a database, network, file system, system clock, or background work scheduler. Trigger on phrases like "integration test", "test the repository with Room", "in-memory Room", "Room.inMemoryDatabaseBuilder", "MockEngine", "MockWebServer", "test sync", "test offline-first", "test the data layer", "test the DAO", or "test with a real database".

Set up JaCoCo code-coverage on a Gradle-based Android project — apply the jacoco plugin, pin its tool version (fetched fresh from Maven Central) in the version catalog, and enable unit-test + instrumentation-test coverage on the debug build type so AGP generates the coverage report tasks. It adapts to the project layout: if the project uses convention plugins in `build-logic`/`buildSrc`, it adds a dedicated JaCoCo convention plugin there; for a single-module project without convention plugins it edits the module's `build.gradle(.kts)` directly. Use this skill whenever the user wants to "set up JaCoCo", "configure code coverage", "add coverage to Gradle", "enable test coverage reports", or enable `enableAndroidTestCoverage` / `enableUnitTestCoverage`. The android-instrumentation-coverage skill cross-references this skill to set up coverage on demand. This skill MODIFIES build files (it commits a real setup); for non-invasive, on-the-fly JVM coverage use android-jvm-test-coverage instead.

Measure JVM unit-test coverage for a module in a native Android Gradle project and print the Android-Studio-style report — the module total plus per-package and per-class Class/Method/Line/Branch percentages. Use this skill whenever the user wants test coverage for local JVM unit tests (the `src/test` suite, run via `testDebugUnitTest` or `test`), asks "what's the coverage of this module/package/ class", "how well is X tested", wants a coverage report without opening Android Studio, or wants the same numbers Android Studio's "Run with Coverage" gives but from the command line. Works on both Android library/app modules and pure Kotlin/JVM modules. This is for JVM unit tests, NOT on-device instrumented (androidTest) coverage.

Module layout, dependency rules, and Gradle convention plugins for Android and Kotlin Multiplatform (KMP) projects. Use this skill whenever setting up a new Android/KMP project, deciding where a new module should live, asking "how should I structure this", creating a new feature module, adding a core submodule, configuring Gradle convention plugins, working with version catalogs, or making any decision about project-level architecture. Trigger on phrases like "set up the project", "add a module", "create a feature", "how should I structure", "project structure", "convention plugin", "build-logic", or "where does X live".

MVI presentation layer for Android/KMP - State, Action, Event, ViewModel, Root/Screen composable split, UI models, UiText error mapping, and process death with SavedStateHandle. Use this skill whenever creating or reviewing a ViewModel, defining screen state, actions, or events, structuring composables, mapping errors to UI strings, or handling process death. Trigger on phrases like "add a ViewModel", "create a screen", "MVI", "state", "action", "event", "screen composable", "UiText", "SavedStateHandle", "ObserveAsEvents", or "UI model".

Compare a single rendered Compose @Preview against a single Figma frame and report the visual/structural differences back to the calling agent as a severity-graded issue list. NO device or emulator needed — it renders the preview straight from Android Studio via the android CLI's `render-compose-preview`, so it works on any @Preview, including landscape, tablet, and per-state previews. The calling agent supplies BOTH the exact preview (file + composable name) AND the exact Figma frame (URL with node-id); this skill never guesses the pairing. Treats Figma as the single source of truth. Reports only — it never edits code. Use this skill whenever the caller wants to check a Compose preview against a design WITHOUT running the app: "compare this preview to Figma", "verify <SomethingPreview> against node-id ...", "does this preview match the design", "render the preview and diff it against Figma", "check my Compose preview against the mockup", or after building/changing a screen when there's a Figma frame to valid

Visually verify a single Android Compose screen against a Figma design using the Android CLI's annotated screenshot tools (`android screen capture --annotate`, `android screen resolve`). Catches overlap, clipping, truncation, color drift, wrong icon shape, broken contrast, and visual misalignment that the structural `android-ui-verify` skill cannot see. Single screen, single viewport, live device/emulator only. Reports a pass/fail verdict plus a lean issue list — does not edit code. Trigger on: "verify the screen visually", "screenshot verify against Figma", "annotated screenshot verify", "does it look right", "compare what I built to Figma visually", or after building a Compose screen from a Figma design when the calling agent wants visual (not structural) verification. For structural / hierarchy / dp-sizing checks, use `android-ui-verify` instead.

Compose UI testing for Android/KMP - instrumented only via createAndroidComposeRule (no Robolectric, no JVM-only Compose runtime). Covers UI+real ViewModel integration tests, full feature E2E tests, the Robot pattern for E2E suites, and the Compose 1.11.0 dispatcher change from UnconfinedTestDispatcher to StandardTestDispatcher (which requires explicit advanceUntilIdle / mainClock advancement when coroutines run inside LaunchedEffect, produceState, or rememberCoroutineScope). Use this skill whenever writing or reviewing tests that exercise Compose UI on a real device or emulator. Trigger on phrases like "UI test", "Compose test", "ComposeTestRule", "createAndroidComposeRule", "test the screen", "E2E test", "feature test", "Robot pattern", "test the navigation flow", "instrumented UI test", "androidTest", or "test the LaunchedEffect".

Verify Android UI against Figma designs or HTML mockups by structural comparison. Compares layout hierarchy, text content, sizing (dp with ±4dp tolerance), and dynamic states using the device's UI Automator tree — never pixel-perfect. Use after finishing UI implementation to validate the result matches the reference. Trigger on: "verify UI", "check the UI", "compare against Figma", "does this match the design", "UI verification", "check layout matches", or when finishing UI implementation work that has a design reference.

Unit testing for Android - JUnit5, AssertK, Turbine, fakes over mocks, UnconfinedTestDispatcher, SavedStateHandle, dispatcher injection, exhaustive edge-case enumeration, and an optional kotlin-mutation-testing pass (run only when explicitly requested). A unit test runs entirely in-process, in memory, with NO I/O - no disk, no network, no database, no real clock, no real concurrency. It can wire many real classes together as long as none of them cross those boundaries. Use this skill whenever writing or reviewing tests for ViewModels, validators, mappers, use cases, formatters, reducers, or any pure-logic unit. Trigger on phrases like "unit test", "test the ViewModel", "test this logic", "fake repository", "Turbine", "UnconfinedTestDispatcher", "runTest", "JUnit5", "test the validator", "test the mapper", or "test the use case".

Gradle version catalog management and convention plugin creation for Android/KMP - adding libraries, plugins, bundles, and version refs in libs.versions.toml, plus creating convention plugins for libraries with non-trivial Gradle config (KSP, compiler plugins, multi-artifact setup). Use this skill whenever adding a dependency, creating a bundle, registering a plugin in the version catalog, creating a convention plugin, looking up the latest version of a library, or updating a dependency version. Trigger on phrases like "add a library", "add a dependency", "version catalog", "libs.versions.toml", "bundle", "add a plugin", "convention plugin", "latest version of", "update dependency", "create a convention plugin", "add Ktor", "add Room", or "add KSP".

Create an Architectural Decision Record (ADR) in the MADR format under docs/decisions. Use this skill whenever an architectural decision is being made or has just been made in the project — choosing a database, framework, library, language, communication protocol, auth approach, architectural pattern/style, build or deployment strategy, API shape, or any other hard-to-reverse, project-shaping technical choice — even if the user does not say "ADR". Also use it on explicit requests like "create an ADR", "write a decision record", "document this decision", "record this in MADR", or "add an ADR for X". When a decision surfaces in conversation, proactively offer to capture it with this skill rather than letting it go unrecorded. Do NOT use it for routine code changes, bug fixes, or non-architectural choices.

Adaptive Compose Multiplatform layouts for structurally different UIs across device configurations — DeviceConfiguration enum, when(configuration) branching, slot-based adaptive layout composables, cross-screen pattern analysis, and Figma mockup interpretation. Works for Android, KMP, and Compose Desktop. Use this skill whenever the composable tree structure itself must change across device configurations — elements rearranged (Column to Row), elements appearing or disappearing entirely, or container wrapping changes (full-screen to centered card). Do NOT use this skill for responsive sizing achievable with fillMaxWidth(), widthIn(max = ...), Modifier.weight(), or responsive padding. Trigger on phrases like "adaptive layout", "tablet layout", "desktop layout", "landscape layout", "different layout per screen size", "window size class", "DeviceConfiguration", "side-by-side on tablet", "rearrange for landscape", "responsive screen structure", "multi-form-factor", "centered card on tablet", "structural UI differ

SVG to Android VectorDrawable XML and Compose ImageVector conversion — faithful, mechanical transformation of SVG path data into Android-native vector formats. Use this skill whenever creating vector drawables from Figma designs, converting SVG icons to Android XML, generating ImageVector code from SVG, or implementing any icon from a Figma design system. This skill is critical because Claude tends to hallucinate vector paths instead of using actual SVG data — it prevents that failure mode. Trigger on phrases like "vector drawable", "SVG to Android", "icon from Figma", "create icon", "vector icon", "ImageVector", "pathData", "drawable XML", "convert SVG", "Figma icon", "export icon", "icon drawable", "vector XML", "android icon", "convert icon", "icon asset", "VectorDrawable", or any task involving creating Android vector files from design tool exports.

Commit all uncommitted changes in the current git repo as one or more atomic Conventional Commits. Use when the user says "/git-commit", "commit my changes", "commit the work", "make commits for what I did", or otherwise asks Claude to commit pending work. Splits unrelated changes into separate commits, writes Conventional Commit messages, and stops at local commits — does not branch or push.

Create or resume from structured handoff documents for session continuity. Use this skill whenever the user says "create handoff", "write handoff", "handoff for X", "resume from handoff", "read handoff for X", "continue from X handoff", or "pick up where we left off on X". Creates task-named, timestamped handoff files that preserve goals, progress, decisions, failed approaches, interfaces, and next steps between sessions.

Analyzes a native Android (Kotlin) codebase to plan its migration to Kotlin Multiplatform (KMP) and produces a sequential, ordered migration report with batches and "still compiles & runs" checkpoints. It is PURELY ANALYTICAL — it never edits source or performs the migration, and it never re-architects code (the goal is a behavior-identical 1:1 translation). Use this skill whenever the user wants to plan, scope, sequence, or assess an Android→KMP / Android→ Kotlin Multiplatform / Android→Compose Multiplatform migration, asks "what do we migrate first", "in what order", "how do we batch this migration", "is this module KMP-ready", "what's blocking us from going multiplatform", "can this code go in commonMain / shared code", or wants a migration roadmap, readiness assessment, or checkpoint plan for moving an Android app (or a slice of it) to KMP. Trigger on phrases like "migrate to KMP", "migrate to Kotlin Multiplatform", "go multiplatform", "Compose Multiplatform migration", "KMP migration plan", "what's KMP-r

Module layout, dependency rules, Gradle 9 convention plugins, and Compose Multiplatform setup for Kotlin Multiplatform (KMP) projects. Use this skill whenever setting up a new KMP project, deciding where a new module should live, asking "how should I structure this", creating a new feature module, adding a core submodule, configuring Gradle convention plugins, working with version catalogs, setting up build-logic, configuring Compose Multiplatform, fixing Android preview issues in KMP, or making any decision about project-level architecture. Trigger on phrases like "set up the project", "add a module", "create a feature", "how should I structure", "project structure", "convention plugin", "build-logic", "where does X live", "Gradle 9", "KMP module", "Compose Multiplatform setup", "Android preview in KMP", or "composeApp".

Kotlin coroutines for Android/KMP — suspend functions, cancellation safety, structured concurrency, parallel execution, synchronization, scopes, blocking code wrapping, and cooperative cancellation. Use this skill whenever writing or reviewing coroutines, suspend functions, coroutine scopes, or any asynchronous Kotlin code that is NOT primarily about Flows. Trigger on phrases like "coroutine", "suspend", "async", "launch", "withContext", "Dispatchers", "ensureActive", "NonCancellable", "Mutex", "limitedParallelism", "coroutineScope", "supervisorScope", "viewModelScope", "application scope", "parallel execution", "blocking code", "runBlocking", "cancellation", or "yield".

Kotlin Flows for Android/KMP — Flow types (StateFlow, SharedFlow, callbackFlow, Channel), stateIn/shareIn, operators, flowOn, backpressure, lifecycle-aware collection, and offline-first patterns. Use this skill whenever writing or reviewing Flows, reactive chains, flow operators, or converting callbacks to flows. Trigger on phrases like "Flow", "StateFlow", "SharedFlow", "MutableStateFlow", "MutableSharedFlow", "Channel", "callbackFlow", "stateIn", "shareIn", "flowOn", "collectLatest", "flatMapLatest", "flatMapConcat", "combine", "zip", "merge", "debounce", "distinctUntilChanged", "conflate", "buffer", "backpressure", "receiveAsFlow", "awaitClose", "reactive", "offline-first flow", "onStart", "onCompletion", "collectAsStateWithLifecycle", or "repeatOnLifecycle".

Audit how well a Kotlin test class covers its production code with model-driven mutation testing. The skill modifies the production code the test class exercises with a small behavior-changing edit, reruns the entire test class, and flags any mutation no test in the class caught — surfacing under-tested production behavior. Works on Android, KMP, and plain JVM Kotlin projects. Use this skill ONLY when the user explicitly asks for mutation testing — e.g. "mutation test", "run a mutation test", "mutation-test these tests", "do a mutation testing pass", or otherwise names mutation testing directly. Do NOT trigger for general unit-testing requests, ordinary requests to write, review, audit, or verify tests, or generic "check my test quality" / "are my tests good" asks that don't mention mutation testing.

Spec Kit Parallelize It (Agent Teams variant) — execute a Spec Kit tasks.md with a Claude Code Agent Team that shares one working tree. Mirrors the task list into the team's shared task list, encoding [P] (parallel, file-disjoint) vs non-[P] (sequential barrier) and phase boundaries as task dependencies, then spawns N teammates (default 3) that self-claim ready work so every agent stays as busy as it can be. Each task is marked [x] in tasks.md the moment it completes. An optional phase-number argument caps how far to go: parallelize only up to that phase, then stop and hand back so a fresh session can resume — useful when a 15-phase task list would otherwise bloat one context window. Use after /speckit-tasks has generated a tasks.md AND when you want the Agent Teams engine (shared tree, no worktrees, no merges — for worktree isolation with sub-agents, use speckit-parallelize-subagents). Trigger on "/speckit-parallelize-agent-teams", "parallelize the spec kit tasks with an agent team", "run tasks.md with a tea

Spec Kit Parallelize It (sub-agents + worktrees variant) — execute a Spec Kit tasks.md with parallel sub-agents, each isolated in its own git worktree branched from the current Spec Kit branch and merged straight back into it on completion. Walks the task list in order and keeps N sub-agents (default 3) continuously busy by batching the [P]-marked tasks into parallel chunks, while running non-[P] tasks as sequential barriers on the lead. Each task is marked [x] in tasks.md the moment its worktree merges cleanly. An optional phase-number argument caps how far to go: parallelize only up to that phase, then stop and hand back so a fresh session can resume — useful when a 15-phase task list would otherwise bloat one context window. Needs no experimental flags. Use after /speckit-tasks has generated a tasks.md AND when you want git-worktree isolation with sub-agents (not the shared-tree Agent Teams engine — for that, use speckit-parallelize-agent-teams). Trigger on "/speckit-parallelize-subagents", "parallelize th

Unified IDE-local verification gate. Diff-vs-base review pipeline — skip-check → context discovery → parallel reviewers (bug + convention + security) → issue-validator → targeted Gradle tests → conditional mutation testing in N throwaway worktrees with per-worker GRADLE_USER_HOME → verify-audit → high-signal report (HIGH-confidence BLOCKER/MAJOR only, plus every well-formed survived mutation).