Claude Skills by ronjunevaldoz

**KMP Agent Skills** — modify an existing skill safely: add or update a section, fix a pattern, bump library versions, or resolve a flagged quality gap. Skill name: **$ARGUMENTS** (e.g. `repository-pattern`, `design-system`) ---

**KMP Agent Skills** — scaffold a new SKILL.md from scratch, following every structural rule enforced by `audit_skills_repo.py` and `scan_skill_issues.py`. Skill name (kebab-case): **$ARGUMENTS** Example: `kmp-new-skill kmp-offline-first` ---

**KMP Agent Skills** — refine a *project-owned* skill (one your own project authored under its own `skills/<name>/`) against agentskills.io's real qualitative best practices. Complements, not duplicates, `kmp-audit`'s mechanical `_detect_project_skill_standards` check (frontmatter presence, 500-line cap) — this command is about whether the skill is *good*, not just structurally valid. Skill path: **$ARGUMENTS** (e.g. `awake-render-vulkan` → `skills/awake-render-vulkan/SKILL.md`) ---

Shared Analytics interface for Kotlin Multiplatform — sealed event types in commonMain, platform implementations for Firebase Analytics (Android) and equivalent (iOS/Desktop), automatic screen tracking, Koin wiring with platform modules, and testing with a fake analytics recorder.

KMP-specific integration guide for Google's official `android` CLI. The CLI's own command reference already exists as a real, officially maintained skill at github.com/android/skills/tree/main/devtools/android-cli (installable via `android skills add android-cli`) — this skill does not re-document that surface. It covers what's specific to a Kotlin Multiplatform project: locating the Android target inside a multi-module 6-layer graph, why `android create` doesn't apply once `kmp-feature-scaff...

Mimics the public API *shape* (DSL entry points, chainable modifier objects, slot lambdas, marker annotations, scoped builders) of a well-known reference API — Jetpack Compose, SwiftUI, Retrofit, Room, etc. — when building a from-scratch Kotlin Multiplatform library on a different runtime (a custom Vulkan/Metal renderer, a custom RPC engine, a custom persistence engine). Does NOT cover consuming or wrapping the real reference library — that is normal dependency usage. Does NOT cover building ...

KMP project audit skill for reviewing an existing Kotlin Multiplatform codebase. Use this skill to inspect architecture, module boundaries, state handling, repository and network layering, Compose patterns, expect/actual usage, shared resources, design system usage, test coverage, platform readiness, and the skills repo itself. Produces findings, risk levels, and a fix sequence instead of implementation code. Pair with kmp-expert to route any follow-up work to the right domain skills.

Sets up kotlinx-benchmark for Kotlin Multiplatform performance measurement. Covers: Gradle plugin + allopen wiring, a separate benchmark source set (never mixed into commonMain/commonTest), @State/@Benchmark/@Setup/@TearDown conventions, per-target registration (JVM/Native/JS/Wasm), running benchmarks, and reading JSON/CSV output. Use this whenever a performance claim needs a real number instead of a guess — this is the "profile first" step the kmp-expert performance decision tree routes to w...

Biometric authentication for Kotlin Multiplatform — a sealed BiometricResult type in commonMain, expect/actual BiometricAuthenticator, Android BiometricPrompt with CryptoObject, iOS LocalAuthentication (LAContext.evaluatePolicy), Koin wiring, and graceful fallback to device PIN/password when biometrics are unavailable.

Sets up GitHub Actions CI for a Kotlin Multiplatform (KMP) project. Produces two workflow files: ci.yml (lint, Android tests, iOS tests, Desktop JVM tests, Web JS + WasmJs tests, Gradle cache) and release.yml (XCFramework build + upload artifact). All target platforms are covered. Assumes AGP 9+ and the project structure from kmp-feature-scaffold.

Defines the 6-layer clean architecture contract for KMP feature modules: :model / :api / :domain / :data / :presenter / :ui. Covers layer dependency rules, :model vs :api split, internal visibility enforcement, the api()/implementation() Gradle configuration boundary (ABI/type leakage, consumer compile fixtures, facade scopes), dependency-cycle detection, and Detekt architecture fitness functions that make violations fail the build.

Sets up Ktlint (formatting) and Detekt (code smells + architecture rules) for a KMP project. Both run as CI gates. Ktlint is near-zero config. Detekt architecture rules enforce the 6-layer module boundary contract from kmp-clean-architecture.

Accessibility (a11y) for Kotlin Multiplatform Compose — semantic roles and mergeDescendants, contentDescription on interactive and image elements, screen reader traversal order, minimum touch target size, Roborazzi accessibility snapshot tests, reduced-motion support, and a Compose a11y audit checklist.

Adaptive UI for Kotlin Multiplatform — WindowSizeClass-driven layouts that respond correctly to Compact (phone), Medium (tablet), and Expanded (desktop) breakpoints. Covers list-detail splits, adaptive navigation (bottom bar → rail → drawer), single-source WindowSizeClass propagation, and Roborazzi tests for each breakpoint. Enforces cross-session pattern consistency so every screen in the project uses the same adaptive strategy.

Compose Multiplatform animation patterns — AnimatedVisibility with enter/exit transitions, animateContentSize, Crossfade for screen-level transitions, animateFloatAsState / animateDpAsState for property animations, and shared element transitions (Compose 1.7+). Covers when to use each API and how to keep animations accessible with reduced-motion support.

Extends :core:designsystem (from kmp-compose-design-system) with 28 production-ready components using the Compose Styles API. Covers: Icon, IconButton, Label, Separator, Avatar, TopAppBar, NavigationBar, Tabs, Checkbox, RadioButton, Switch, Slider, Select/Dropdown, Progress (linear + circular), Skeleton, Spinner, Alert, Toast/Snackbar system (AppToastHostState + Scaffold slot), Dialog, AlertDialog, Sheet (BottomSheet), Tooltip, Popover, Accordion/Collapsible, ScrollArea (Desktop-only scrollba...

Scaffolds a fully owned Compose Multiplatform design system in :core:designsystem using the experimental Compose Styles API. Produces semantic design tokens, AppTheme, style accessors, sealed component variants, and core App* primitives without Material. The App prefix is derived from the project's name and can be customized.

Jetpack Compose graphics modifiers for KMP and CMP — use graphicsLayer for transforms, clipping, alpha, elevation, and layer effects; use Canvas, drawBehind, and drawWithCache for actual custom drawing. Recommended for workflow editors, node-based UIs, and other surfaces where a composable needs a transformable shell around a custom-drawn interior.

Preview-Driven Development (PDD) workflow for KMP: write Content composables first, iterate on Desktop JVM previews (3-5x faster than Android), cover all states with @PreviewParameterProvider, then promote previews directly to Roborazzi screenshot tests.

The Slot API pattern in Compose Multiplatform — designing components with composable lambda parameters (slots) instead of data parameters. Covers: single and named slots, scoped slots with receiver types (RowScope, ColumnScope), trailing lambda convention, slot-based component library design, CompositionLocal as a deep-slot alternative, performance characteristics, and when NOT to use slots. Zero new dependencies.

Choosing the right state container in Compose Multiplatform: remember vs rememberSaveable vs ViewModel vs rememberCoroutineScope. Covers: what survives recomposition, config changes, and process death; when each container applies; rememberSaveable with custom Saver for complex types; ViewModel scoping to nav back-stack entries; and the most common wrong choices (ViewModel for dropdown state, remember for form data that must survive rotation). Zero new dependencies.

State hoisting in Compose Multiplatform — the pattern of moving state up to the lowest common ancestor that needs it. Covers: stateful vs stateless composables, the controlled component pattern (value + onValueChange), the hoist-until-shared rule, UI state vs business state distinction, when to stop hoisting, and the common mistakes of over-hoisting (everything in ViewModel) and under-hoisting (buried state that can't be tested). Zero new dependencies.

Live browser performance analysis for a Compose Multiplatform Web (wasmJs) target, using the official Chrome DevTools MCP server (github.com/ChromeDevTools/chrome-devtools-mcp) — performance traces, Lighthouse audits, network waterfall, and Wasm bundle-size awareness specific to Skiko's canvas-based rendering. Does NOT cover micro-benchmarking Kotlin functions (see kmp-benchmark) — this is live, real-browser profiling of the running app, not isolated function timing.

General-purpose Kotlin coroutines and Flow patterns for Kotlin Multiplatform — structured concurrency and scope hierarchy, parallel decomposition, cold Flow vs StateFlow vs SharedFlow selection, exception transparency (the catch operator vs try/catch around a collector), cancellation-safe cleanup, and coroutine/Flow testing with runTest and Turbine. Does NOT cover screen-level state/effect wiring (see kmp-mvi) or repository Flow exposure conventions (see kmp-repository-pattern) — this is the ...

Crash reporting for Kotlin Multiplatform apps — Firebase Crashlytics on Android/iOS, Sentry as a cross-platform alternative, custom non-fatal event recording, and breadcrumb logging. Covers: logger breadcrumb bridges, symbolication setup for Kotlin/Native dSYMs, and a CrashReporter expect/actual interface that keeps commonMain free of platform SDKs. Does NOT cover general structured logging (see logging skill) or app analytics/events (see analytics skill).

Sets up Multiplatform DataStore for KMP: Preferences (key-value) and Proto (typed, schema-driven) variants. Covers createDataStore {} expect/actual per platform, Flow-based reads, coroutine writes, migration from SharedPreferences, and Koin wiring so feature modules never construct DataStore directly.

Deep linking for Kotlin Multiplatform — Android App Links (Digital Asset Links), iOS Universal Links (Apple App Site Association), NavHost route integration, deep-link route parsing in commonMain, intent handling in AndroidActivity, and NSUserActivity/openURL handling in the iOS app delegate.

KMP dependency injection with Koin — recommend manual modules first, then annotated mode when less wiring is preferred. Covers app/feature scope boundaries, constructor injection, module organization, platform startup, test overrides, and the anti-patterns that hide architecture problems behind DI. Use this when deciding how to wire KMP dependencies instead of repeating Koin setup across other skills.

Desktop-specific concerns for KMP Compose Multiplatform apps — window management, system tray, file picker, keyboard shortcuts, native menu bar, drag-and-drop, and packaging. Covers the Desktop target's deviations from Android/iOS: synchronous file I/O on the main thread is safe on Desktop, `LocalContext` does not exist, and window state must be managed differently than Android Activity state.

Sets up a public developer-guide website (getting started, guides, code examples, API reference) for a published Kotlin Multiplatform library, deployed to GitHub Pages. Covers MkDocs Material for hand-written guide content, Dokka HTML for auto-generated API reference, a compiler-verified snippet-extraction technique so code examples can't drift stale, and the CI deploy workflow. Library-only — does not apply to app projects, which have no external consumers to write a developer guide for. Dis...

The expect/actual mechanism in Kotlin Multiplatform — when to use it, when NOT to, and how to do it correctly. Covers: the four categories that genuinely warrant expect/actual (platform APIs, platform types, performance-critical code, SDK integration), the common-first rule that prefers a pure `commonMain` implementation before abstractions, the interface-injection alternative that handles most cases better, the "actual everywhere" anti-pattern, typealias actual for platform types, @ObjCName ...

KMP Expert Orchestrator — maps all skills in this collection, their dependency order, and how to sequence them for any Kotlin Multiplatform project. Use this skill first to decide which other skill to invoke, in what order, for a given task. Covers: skill dependency graph, layer-by-layer build order, feature-slice assembly sequence, decision trees for the most common "what do I use here?" questions, and when to hand off to the project audit skill. This is a meta-skill; it delegates to domain ...

Feature flag evaluation for Kotlin Multiplatform — a FeatureFlag enum and FeatureFlagProvider interface in commonMain, Firebase Remote Config as the default backend, A/B variant types, offline fallback defaults, flag evaluation in the :domain layer, and kill-switch support for fast disablement.

Scaffolds a production-ready Kotlin Multiplatform (KMP) multi-feature module architecture. Creates a full project by generating from the official Kotlin/kmp-wizard AGP 9 baseline, usually the `all-targets` branch for Android, iOS, Web, Desktop, and Server, or adds a new feature module group (:model/:api/:domain/:data/:presenter/:ui) to an existing KMP project. Uses AGP 9+, build-logic convention plugins, a TOML version catalog (`gradle/libs.versions.toml`), Compose Multiplatform, and Koin 4 (...

Sets up multi-environment configuration (dev/staging/prod) in a Kotlin Multiplatform project using BuildKonfig. Covers: environment-specific BuildKonfig values, Android product flavors wired to BuildKonfig, a shared AppConfig object in commonMain, secret management, and switching environments at build time. Assumes the project was scaffolded with kmp-feature-scaffold.

Declarative form validation for Kotlin Multiplatform — field-level validation rules in commonMain, synchronous and async validators, error state integrated into MVI UiState, submit gating, and reusable field components that display inline errors. No third-party validation library required.

Image loading for Kotlin Multiplatform using Coil 3 — AsyncImage, cache policy, placeholder and error states, circular/rounded clipping, local resource images, Koin wiring of ImageLoader, and memory/disk cache tuning. Coil 3 is KMP-ready for Android, iOS, Desktop, and WASM targets.

Eliminates raw pixel assets and hand-written vector paths from KMP Compose projects. Compiles raster images (PNG/JPG) and SVGs into Kotlin ImageVector code via a local, deterministic toolchain (quantize → trace → normalize → codegen). Agents are forbidden from writing path coordinates by hand — all vector generation is delegated to scripts/convert_image_to_imagevector.py. Use whenever a project needs an icon, logo, or flat illustration as a Compose asset, or when replacing PNG icons with vect...

In-app purchases and subscriptions in KMP — shared domain model for purchase state, platform implementations via expect/actual, Play Billing (Android) and StoreKit 2 (iOS), entitlement verification, and the MVI integration pattern for gating premium features. Covers: one-time purchases, auto-renewing subscriptions, receipt validation, and restore purchases. Zero server required for basic validation; server-side validation guidance included.

Expert in JNI bridge engineering between Kotlin/JVM and native C++ libraries. Specializes in memory safety across the JVM boundary, shared-library symbol isolation, type mapping, GPU-sync correctness, algorithm porting discipline, and stable-feature protection. Language and library agnostic — applies to any Kotlin ↔ native pipeline.

Kotlin RPC for Kotlin Multiplatform full-stack apps. Covers when to use Kotlin RPC instead of REST or gRPC, shared request/response contracts, client/server module layout, auth boundaries, service interface design, and a scaffold script for initial RPC project setup. Use this for Kotlin-to-Kotlin service boundaries, especially when the client and server both live in the same KMP ecosystem.

Building a custom KSP (Kotlin Symbol Processing) annotation processor that generates Kotlin source with KotlinPoet — FileSpec/TypeSpec/FunSpec/ PropertySpec builders, format specifiers, the two-module processor structure, ServiceLoader registration, and the kotlinpoet-ksp interop module for converting KSP's KSType/KSClassDeclaration into KotlinPoet's TypeName/ClassName. Use when a project wants compile-time code generation from annotations instead of runtime reflection. Does NOT cover consumi...

Ktor-based auth service pattern for Kotlin Multiplatform full-stack apps. Covers: bearer and JWT auth, sessions when stateful browser-style sessions are a better fit, Ktor RPC when the client and server are both Kotlin-first, typed auth errors, route guards, refresh/logout flows, and a small scaffold script for repeated auth module setup. Use this for server-side auth, not shared UI auth state.

Drafts and maintains KMP screen-layout documentation in docs/layout-system/. Produces one markdown spec and SVG wireframe per screen plus a shared component registry. Use for new screens, layout changes, layout review, or projects missing layout specs; create the documentation before or alongside implementation.

Lawyer agent for KMP apps: generates Privacy Policy and Terms & Conditions tailored to the data your app actually collects. Covers Google Play data safety section, App Store privacy nutrition labels, GDPR (EU), CCPA (California), and in-app display via a CMP composable. Produces web-ready markdown and a KMP WebView/ScrollView screen for showing the docs inside the app. Does NOT provide legal advice — output is a best-practice template that must be reviewed by a qualified lawyer before publish...

Consumer-side skill for capturing lessons learned from real KMP project work. Writes structured lesson files to docs/lessons/ whenever a skill's guidance was wrong, incomplete, or led to a bug — so that knowledge flows back into the skills collection. Use this skill whenever you fix a bug caused by following skill guidance, discover a better pattern than what the skill teaches, find a gap in skill coverage, or notice that a skill's dependency reference is stale. Trigger it proactively after a...

Publish a Kotlin Multiplatform library to Maven Central, GitHub Packages, or both. Covers: vanniktech maven-publish plugin setup, POM metadata, Sonatype OSSRH staging, multi-artifact BOM, kotlinx-binary-compatibility-validator API tracking, SNAPSHOT vs stable channels, and a release checklist. Pairs with kmp-xcframework-spm for iOS/SPM distribution.

Sets up kotlin-logging or Kermit for KMP projects: log levels, logger factories per target, crash boundary integration (Firebase Crashlytics, Sentry), and Koin wiring so every layer gets a logger without constructing it directly.

Model Context Protocol (MCP) for Kotlin Multiplatform using the official modelcontextprotocol/kotlin-sdk (maintained with JetBrains). Covers building an MCP server that exposes tools/resources/prompts to an LLM client (Claude, Claude Code, MCP Inspector), building an MCP client that connects to an external MCP server from a Kotlin app, transport selection (STDIO, Streamable HTTP, SSE, WebSocket, ChannelTransport for tests), and Ktor wiring since the SDK does not bundle a Ktor engine transitiv...

Incremental adoption guide for teams moving an existing Android or KMP project toward the kmp-agent-skills architecture. Covers assessment of current state, prioritized skill adoption order, migration paths from MVVM+LiveData to MVI, monolith to multi-module, and how to migrate without breaking a live app. Use this skill when a project already exists and the team wants to adopt KMP skills one feature or one layer at a time.