Skip to content
Back to search

compose-skill

Jetpack Compose Agent Skill — AI-powered coding guidance with actual androidx/androidx source code receipts. Works with Claude Code, Codex CLI, Gemini CLI, Cursor, Copilot, Windsurf, and more.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/aldefy--compose-skill/badge.svg)](/listings/aldefy--compose-skill)

HTML

<a href="/listings/aldefy--compose-skill"><img src="/api/listings/aldefy--compose-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

This skill is distributed as a plugin. See **[docs/INSTALL.md](docs/INSTALL.md)** for per-host instructions:

- **Claude Code:** `/plugin marketplace add aldefy/compose-skill` → `/plugin install compose-expert` - **Copilot CLI:** `copilot plugin install aldefy/compose-skill` - **Codex CLI:** manual install — see INSTALL.md.

Already installed manually? See **[docs/MIGRATION.md](docs/MIGRATION.md)**.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "aldefy-compose-skill",
  3. "description": "Compose and Compose Multiplatform skills maintained by Adit Lal.",
  4. "owner": {
  5. "name": "Adit Lal",
  6. "url": "https://github.com/aldefy"
  7. },
  8. "plugins": [
  9. {
  10. "name": "compose-expert",
  11. "source": "./",
  12. "description": "Compose expert skill — state, animations, navigation, performance, PR review, M3 motion."
  13. }
  14. ]
  15. }
README.md · README · 480 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <img src="https://raw.githubusercontent.com/devicons/devicon/master/icons/jetpackcompose/jetpackcompose-original.svg" width="80" alt="Jetpack Compose logo"/>
  3. </p>
  4. <h1 align="center">Compose Agent Skill</h1>
  5. <p align="center">
  6. Make your AI coding tool actually understand Compose — Android, Desktop, iOS, and Web.<br/>
  7. Backed by real source code from <code>androidx/androidx</code> and <code>compose-multiplatform-core</code> — not vibes.
  8. </p>
  9. <p align="center">
  10. <a href="https://github.com/aldefy/compose-skill/stargazers"><img src="https://img.shields.io/github/stars/aldefy/compose-skill?style=flat&color=yellow" alt="GitHub stars"/></a>
  11. <a href="#setup"><img src="https://img.shields.io/badge/setup-5%20min-brightgreen" alt="Setup time"/></a>
  12. <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="License"/></a>
  13. <a href="https://developer.android.com/jetpack/compose"><img src="https://img.shields.io/badge/Jetpack%20Compose-1.7+-4285F4" alt="Compose version"/></a>
  14. <a href="https://www.jetbrains.com/lp/compose-multiplatform/"><img src="https://img.shields.io/badge/Compose%20Multiplatform-1.8+-7F52FF" alt="CMP version"/></a>
  15. <a href="https://kotlinlang.org"><img src="https://img.shields.io/badge/Kotlin-2.0+-7F52FF" alt="Kotlin version"/></a>
  16. </p>
  17. ---
  18. ## See the difference
  19. Same prompt. Same model. The only variable is whether this skill is installed.
  20. > **You:** "Add a counter to this composable."
  21. <table>
  22. <tr>
  23. <th>❌ Without the skill</th>
  24. <th>✅ With the skill</th>
  25. </tr>
  26. <tr>
  27. <td valign="top">
  28. ```kotlin
  29. @Composable
  30. fun Counter() {
  31. // recreated every recomposition —
  32. // count resets to 0 constantly
  33. var count = mutableStateOf(0)
  34. Button(onClick = { count.value++ }) {
  35. Text("Count: ${count.value}")
  36. }
  37. }
  38. ```
  39. State is **recreated on every recomposition** — the counter silently resets. Also boxes the `Int`.
  40. </td>
  41. <td valign="top">
  42. ```kotlin
  43. @Composable
  44. fun Counter() {
  45. // survives recomposition, no boxing
  46. var count by remember { mutableIntStateOf(0) }
  47. Button(onClick = { count++ }) {
  48. Text("Count: $count")
  49. }
  50. }
  51. ```
  52. `remember` keeps state across recomposition; `mutableIntStateOf` avoids boxing. Verified against `androidx` source.
  53. </td>
  54. </tr>
  55. </table>
  56. > **You:** "Set up navigation between two screens."
  57. <table>
  58. <tr>
  59. <th>❌ Without the skill</th>
  60. <th>✅ With the skill</th>
  61. </tr>
  62. <tr>
  63. <td valign="top">
  64. ```kotlin
  65. // string routes — no type safety,
  66. // args stringly-typed, deprecated pattern
  67. NavHost(nav, startDestination = "home") {
  68. composable("home") { Home(nav) }
  69. composable("detail/{id}") { back ->
  70. Detail(back.arguments?.getString("id"))
  71. }
  72. }
  73. ```
  74. </td>
  75. <td valign="top">
  76. ```kotlin
  77. // type-safe routes, compiler-checked args
  78. @Serializable object Home
  79. @Serializable data class Detail(val id: String)
  80. NavHost(nav, startDestination = Home) {
  81. composable<Home> { Home(nav) }
  82. composable<Detail> { entry ->
  83. Detail(entry.toRoute<Detail>().id)
  84. }
  85. }
  86. ```
  87. </td>
  88. </tr>
  89. </table>
  90. The difference is **source-backed grounding** — the agent checks real `androidx/androidx` and `compose-multiplatform-core` signatures instead of guessing. [See how it works ↓](#how-it-works)
  91. ---
  92. ## Install
  93. This skill is distributed as a plugin. See **[docs/INSTALL.md](docs/INSTALL.md)** for per-host instructions:
  94. - **Claude Code:** `/plugin marketplace add aldefy/compose-skill` → `/plugin install compose-expert`
  95. (one step on Claude Code 2.1.275+: `/plugin install compose-expert --marketplace aldefy/compose-skill`)
  96. - **Copilot CLI:** `copilot plugin install aldefy/compose-skill`
  97. - **Codex CLI:** manual install — see INSTALL.md.
  98. Already installed manually? See **[docs/MIGRATION.md](docs/MIGRATION.md)**.
  99. ## Updates
  100. New versions are published as [GitHub Releases](https://github.com/aldefy/compose-skill/releases) with migration notes. Run `/plugin update` (Claude Code) or `copilot plugin update aldefy/compose-skill` (Copilot) to pick them up.
  101. ---
  102. ## The problem
  103. AI coding tools generate Compose code that compiles but gets the details wrong. Incorrect `remember` usage, unstable recompositions, broken modifier ordering, deprecated navigation patterns, hallucinated APIs that don't exist. They guess at behavior instead of knowing it.
  104. This skill fixes that by giving your AI assistant two things:
  105. 1. **35 reference guides** covering every major Compose topic — including Compose Multiplatform, A2UI, AppState, Remote Compose, adaptive layouts and input, Android XR, Wear OS, Media3, Android TV, Material 3 motion, Paging 3, Nav 2 → Nav 3 migration, and production crash patterns
  106. 2. **6 source code files** pulled directly from [`androidx/androidx`](https://github.com/androidx/androidx/tree/androidx-main/compose) and [`compose-multiplatform-core`](https://github.com/JetBrains/compose-multiplatform-core) so the agent can check how things actually work
  107. ## What changes when you install it
  108. | Area | Without the skill | With it |
  109. |---|---|---|
  110. | State | Uses `remember { mutableStateOf() }` everywhere, even when `derivedStateOf` or `rememberSaveable` is the right call | Picks the right state primitive for each situation |
  111. | Performance | Generates code that recomposes every frame | Applies stability annotations, deferred reads, `key {}` on lists |
  112. | Navigation | String-based routes (deprecated) | Type-safe routes with `@Serializable` route classes |
  113. | Modifiers | Random ordering, misses `clickable` before `padding` bugs | Correct ordering with reasoning |
  114. | Side effects | Wrong coroutine scope, bad `LaunchedEffect` keys | Correct effect selection and lifecycle-aware keys |
  115. | APIs | Hallucinates parameters that don't exist | Checks against actual source before suggesting |
  116. | Multiplatform | Uses Android-only APIs in shared code | Uses `expect`/`actual`, `Res.*` resources, platform-correct patterns |
  117. | Design-to-code | Literal Figma node translation, wrong modifier ordering | Semantic M3 components, correct ordering, theme tokens |
  118. | Crash safety | No defensive patterns | Guards against zero-size DrawScope, duplicate keys, stale `derivedStateOf` |
  119. ## What's covered
  120. | Topic | What the agent learns |
  121. |---|---|
  122. | State management | `remember`, `mutableStateOf`, `derivedStateOf`, `rememberSaveable`, state hoisting, `snapshotFlow` |
  123. | View composition | Structuring composables, slot APIs, `@Preview` patterns, extraction rules |
  124. | Performance | Recomposition skipping, `@Stable`/`@Immutable`, deferred reads, baseline profiles, benchmarking |
  125. | Navigation | Type-safe routes, `NavHost`, deep links, shared element transitions, back stack |
  126. | Animation | `animate*AsState`, `AnimatedVisibility`, `Crossfade`, `updateTransition`, shared transitions, 9 recipes (shimmer, swipe-to-dismiss, etc.), gesture-driven patterns, Figma curve mapping |
  127. | Lists and scrolling | `LazyColumn`/`LazyRow`/`LazyGrid`, `Pager`, `key {}`, `contentType`, scroll state |
  128. | Side effects | `LaunchedEffect`, `DisposableEffect`, `SideEffect`, `rememberCoroutineScope` |
  129. | Modifiers | Ordering rules, custom modifiers, `Modifier.Node` migration |
  130. | Theming | `MaterialTheme`, `ColorScheme`, dynamic color, `Typography`, shapes, dark theme |
  131. | Accessibility | Semantics, content descriptions, traversal order, touch targets, TalkBack |
  132. | CompositionLocals | `LocalContext`, `LocalDensity`, custom locals, when to use vs. parameter passing |
  133. | Deprecated patterns | Removed APIs, migration paths from older Compose versions |
  134. | **Styles API (experimental)** | `Style {}`, `MutableStyleState`, `Modifier.styleable()`, composition, theme integration, alpha06 gotchas |
  135. | **Design-to-code** | Composable decomposition algorithm, Figma property mapping, spacing ownership, modifier ordering, design tokens |
  136. | **Production crash playbook** | 6 crash patterns with root cause + fix, defensive patterns, production state/performance rules |
  137. | **Compose Multiplatform** | CMP architecture, `expect`/`actual`, `Res.*` resources, API availability matrix, migration guide |
  138. | **Platform specifics** | Desktop (Window, Tray, MenuBar), iOS (UIKitView, gotchas), Web/WASM (canvas limitations) |
  139. | **TV Compose** | TV Material3 (Surface, Cards, Carousel, NavigationDrawer, TabRow), focus system, D-pad navigation, theming, immersive list, TVProvider |
  140. | **M3 Motion** | All duration tokens (`DurationShort1–4`, `DurationMedium1–4`, `DurationLong1–4`, `DurationExtraLong1–4`), easing tokens with CubicBezierEasing values, `MotionScheme` API (`defaultSpatialSpec`, `defaultEffectsSpec`), Compose API mapping, decision tree, PR review flags |
  141. | **Atomic design** | 5-level hierarchy (tokens, atoms, molecules, organisms, templates) mapped to Compose, M3 wrapper patterns, custom atom patterns, slot API contracts, token layer, anti-patterns |
  142. | **Paging 3** | `PagingSource`, `Pager`, `PagingConfig`, `LazyPagingItems`, `LoadState` UI handling, `flatMapLatest` for filter changes, `RemoteMediator` offline-first, MVI dual-flow pattern, `asSnapshot`/`TestPager`, full anti-pattern table |
  143. | **Nav 2 → Nav 3 migration** | Conceptual shifts (you own the back stack), mechanical migration steps (`NavKey`, `rememberNavBackStack`, `NavDisplay`, entry-scoped ViewModels, deep-link parsing), original "Choosing Nav 2 vs Nav 3" decision guide with the CMP 1.10+ polymorphic-serialisation caveat |
  144. | **A2UI** | Catalog capability boundaries, message processors, native agent-generated surfaces, progressive rendering, testing and security |
  145. | **AppState** | Headless `Transform`, `listener`, `StateStore`, DataStore persistence, and choosing between snapshot state and Flow |
  146. | **Adaptive layouts and input** | `MediaQuery`, `Grid`, `FlexBox`, Navigation 3 scenes, keyboard, mouse, trackpad, and indirect input |
  147. | **Remote Compose** | Remote documents and players, capability profiles, expressions, Glance and Wear Widgets |
  148. | **Modern graphics** | Mesh gradients, wide gamut, polygon morphs, progressive/backdrop blur, and graphics performance |
  149. | **Android XR and Wear** | Compose Glimmer, projected activities, spatial UI, XR accessibility, Wear Material 3 and Wear Widgets |
  150. | **Media3 Compose** | Player ownership, customizable Compose controls, Cast handoff, lifecycle and form-factor input |
  151. | Source code | Actual `.kt` from `androidx/androidx` and `compose-multiplatform-core` for runtime, UI, foundation, material3, navigation, CMP |
  152. ## How it works
  153. ```
  154. You ask about Compose
  155. |
  156. v
  157. AI reads SKILL.md (workflow + checklists)
  158. |
  159. v
  160. Consults the right reference file
  161. |
  162. +-- state-management.md
  163. +-- performance.md
  164. +-- navigation.md
  165. +-- design-to-compose.md
  166. +-- production-crash-playbook.md
  167. +-- multiplatform.md
  168. +-- platform-specifics.md
  169. +-- tv-compose.md
  170. +-- ... (20 guides total)
  171. |
  172. +-- source-code/
  173. +-- runtime-source.md
  174. +-- material3-source.md
  175. +-- cmp-source.md
  176. +-- ... (6 source files)
  177. ```
  178. **Layer 1: guidance docs** (35 files) — practical references with patterns, pitfalls, and do/don't examples. The skill's `## Quick Routing` section maps task signals to a single file so the agent lands on the right reference in one read.
  179. **Layer 2: source code receipts** (6 files) — the actual Kotlin source from `androidx/androidx` and `compose-multiplatform-core`. When the agent needs to verify an implementation detail rather than guess, it reads these.
  180. ## File structure
  181. ```
  182. skills/compose-expert/
  183. ├── SKILL.md # Main workflow + checklists
  184. └── references/
  185. ├── state-management.md # State, remember, hoisting, derivedStateOf
  186. ├── view-composition.md # Structuring composables, slots, previews
  187. ├── modifiers.md # Modifier ordering, custom modifiers, Modifier.Node
  188. ├── side-effects.md # LaunchedEffect, DisposableEffect, SideEffect
  189. ├── composition-locals.md # CompositionLocal, LocalContext, custom locals
  190. ├── lists-scrolling.md # LazyColumn/Row/Grid, Pager, keys, contentType
  191. ├── navigation.md # NavHost, type-safe routes, deep links (Nav 2)
  192. ├── navigation-migration.md # Nav 2 → Nav 3 migration + decision guide
  193. ├── paging.md # Paging 3 core: PagingSource, Pager, LazyPagingItems
  194. ├── paging-offline.md # RemoteMediator, offline-first, LoadState gotchas
  195. ├── paging-mvi-testing.md # MVI dual-flow pattern, asSnapshot, TestPager
  196. ├── animation.md # animate*AsState, AnimatedVisibility, transitions
  197. ├── theming-material3.md # MaterialTheme, ColorScheme, dynamic color
  198. ├── performance.md # Recomposition, stability, benchmarking
  199. ├── accessibility.md # Semantics, content descriptions, testing
  200. ├── deprecated-patterns.md # Removed APIs, migration paths
  201. ├── styles-experimental.md # Styles API (@ExperimentalFoundationStyleApi)
  202. ├── design-to-compose.md # Figma/screenshot decomposition, property mapping
  203. ├── production-crash-playbook.md # Crash patterns, defensive coding, production rules
  204. ├── multiplatform.md # CMP architecture, expect/actual, Res.*, migration
  205. ├── platform-specifics.md # Desktop, iOS, Web/WASM platform APIs and gotchas
  206. ├── agentic-ui-a2ui.md # A2UI catalogs, surfaces, events, safety
  207. ├── appstate.md # Transform, listener, StateStore
  208. ├── text-editing.md # TextFieldState and transformations
  209. ├── adaptive-layout-input.md # MediaQuery, Grid/FlexBox, non-touch input
  210. ├── remote-compose.md # Remote documents, players, Glance/Wear
  211. ├── graphics-modern.md # Mesh gradients, shapes, blur, wide gamut
  212. ├── xr-compose.md # Glimmer, projected and spatial UI
  213. ├── wear-compose.md # Wear Material 3 and Wear Widgets
  214. ├── media3-compose.md # Media3 UI Compose and player lifecycle
  215. ├── tv-compose.md # Android TV: tv-material, Carousel, focus, D-pad
  216. ├── atomic-design.md # Atomic design system: tokens, atoms, molecules, organisms, templates
  217. └── source-code/ # Actual .kt source
  218. ├── runtime-source.md # Composer, Recomposer, State, Effects
  219. ├── ui-source.md # AndroidCompositionLocals, Modifier, Layout
  220. ├── foundation-source.md # LazyList, BasicTextField, Gestures
  221. ├── material3-source.md # MaterialTheme, all M3 components
  222. ├── navigation-source.md # NavHost, ComposeNavigator
  223. └── cmp-source.md # Window, UIKitView, ComposeViewport, Resources
  224. ```
  225. ## Setup
  226. The skill is just markdown files. Every tool below reads the same content. Pick yours.
  227. ---
  228. ### Claude Code
  229. Skills are file-based — Claude Code discovers them automatically from `~/.claude/skills/` (personal) or `.claude/skills/` (project-specific).
  230. **Personal skill (available in all your projects):**
  231. > Clone the repo and copy the skill into your personal skills directory:
  232. ```bash
  233. git clone https://github.com/aldefy/compose-skill.git /tmp/compose-skill
  234. mkdir -p ~/.claude/skills
  235. cp -r /tmp/compose-skill/skills/compose-expert ~/.claude/skills/
  236. ```
  237. **Project-specific skill (just one project):**
  238. > Clone the repo and copy the skill into your project's `.claude/skills` directory:
  239. ```bash
  240. git clone https://github.com/aldefy/compose-skill.git /tmp/compose-skill
  241. mkdir -p .claude/skills
  242. cp -r /tmp/compose-skill/skills/compose-expert .claude/skills/
  243. ```
  244. No CLI command or config file needed. Claude Code picks up `SKILL.md` from these directories automatically and triggers when you mention Compose, `@Composable`, `remember`, `LazyColumn`, `NavHost`, etc.
  245. ---
  246. ### Codex CLI (OpenAI)
  247. Add an `AGENTS.md` file to your project root:
  248. ```markdown
  249. # AGENTS.md
  250. ## Jetpack Compose
  251. For all Compose/Android UI tasks, follow the instructions in
  252. `skills/compose-expert/SKILL.md` and consult the reference
  253. files in `skills/compose-expert/references/` before answering.
  254. ```
  255. Add the skill to your project as a submodule:
  256. ```bash
  257. git submodule add https://github.com/aldefy/compose-skill.git .compose-skill
  258. ```
  259. Codex discovers `AGENTS.md` files automatically from the git root down to the current directory.
  260. ---
  261. ### Gemini CLI (Google)
  262. Add to `GEMINI.md` in your project root:
  263. ```markdown
  264. # GEMINI.md
  265. ## Jetpack Compose Expert
  266. For all Jetpack Compose tasks, follow the workflow and checklists in
  267. `skills/compose-expert/SKILL.md`.
  268. Before answering any Compose question, consult the relevant reference:
  269. - State management -> `skills/compose-expert/references/state-management.md`
  270. - Performance -> `skills/compose-expert/references/performance.md`
  271. - Navigation -> `skills/compose-expert/references/navigation.md`
  272. - (see SKILL.md for the full topic -> file mapping)
  273. For implementation details, check actual source code in
  274. `skills/compose-expert/references/source-code/`.
  275. ```
  276. Add as a submodule:
  277. ```bash
  278. git submodule add git@github.com:aldefy/compose-skill.git .compose-skill
  279. ```
  280. ---
  281. ### Google Antigravity
  282. Antigravity automatically discovers skills from workspace or global skill folders. The `skills/compose-expert` directory acts as a complete, ready-to-use Antigravity skill since it contains the needed `SKILL.md` file with a YAML frontmatter description.
  283. **Workspace skill (project-specific):**
  284. ```bash
  285. # Clone the repo
  286. git clone https://github.com/aldefy/compose-skill.git /tmp/compose-skill
  287. # Copy into your project's .agents/skills directory
  288. mkdir -p .agents/skills
  289. cp -r /tmp/compose-skill/skills/compose-expert .agents/skills/compose-expert
  290. ```
  291. **Global skill (available in all your projects):**
  292. ```bash
  293. # Clone the repo
  294. git clone https://github.com/aldefy/compose-skill.git /tmp/compose-skill
  295. # Copy into your global Antigravity skills directory
  296. mkdir -p ~/.gemini/antigravity/skills
  297. cp -r /tmp/compose-skill/skills/compose-expert ~/.gemini/antigravity/skills/compose-expert
  298. ```
  299. ---
  300. ### Cursor
  301. Create `.cursor/rules/compose-skill.mdc`:
  302. ```markdown
  303. ---
  304. description: Jetpack Compose expert guidance
  305. globs: **/*.kt
  306. ---
  307. Follow the instructions in `skills/compose-expert/SKILL.md`
  308. for all Compose-related code. Consult reference files in
  309. `skills/compose-expert/references/` before suggesting patterns.
  310. ```
  311. Or paste the contents of `SKILL.md` into **Settings > Rules for AI**.
  312. ---
  313. ### GitHub Copilot
  314. Add to `.github/copilot-instructions.md`:
  315. ```markdown
  316. ## Jetpack Compose
  317. For Compose/Android UI work, follow the skill instructions in
  318. `skills/compose-expert/SKILL.md`. Consult reference files in
  319. `skills/compose-expert/references/` for patterns, pitfalls,
  320. and source-code-backed guidance.
  321. ```
  322. ---
  323. ### Windsurf
  324. Create `.windsurf/rules/compose-skill.md` in your project root:
  325. ```markdown
  326. For all Jetpack Compose tasks, follow the workflow in
  327. `skills/compose-expert/SKILL.md` and consult the reference
  328. files in `skills/compose-expert/references/` before answering.
  329. ```
  330. > **Note:** The legacy `.windsurfrules` file also works but `.windsurf/rules/` is the current approach.
  331. ---
  332. ### Amazon Q Developer
  333. Add to `.amazonq/rules/compose.md`:
  334. ```markdown
  335. For all Jetpack Compose tasks, follow the workflow in
  336. `skills/compose-expert/SKILL.md` and consult the reference
  337. files in `skills/compose-expert/references/` before answering.
  338. ```
  339. ---
  340. ### Any other AI coding tool
  341. It's just markdown. Clone this repo into your project (or add as a submodule), then point your tool's instruction file at `skills/compose-expert/SKILL.md`. The agent reads `SKILL.md` for the workflow and pulls from `references/` as needed.
  342. ## Quick example
  343. After setup, just talk to your AI assistant normally:
  344. ```
  345. "My LazyColumn is janky when scrolling — help me fix it"
  346. ```
  347. What happens:
  348. 1. Agent reads `SKILL.md` for the workflow
  349. 2. Pulls in `references/lists-scrolling.md` and `references/performance.md`
  350. 3. Checks your code for missing `key {}`, unstable item types, heavy compositions in item blocks
  351. 4. If something's unclear, verifies against `references/source-code/foundation-source.md`
  352. 5. Gives you a fix based on the actual `LazyList` implementation
  353. No hallucinated APIs. No guessed behavior.
  354. ## Source
  355. Source code comes from [`androidx/androidx`](https://github.com/androidx/androidx/tree/androidx-main/compose) and [`JetBrains/compose-multiplatform-core`](https://github.com/JetBrains/compose-multiplatform-core) under Apache License 2.0. The guidance docs are original analysis of those sources plus official documentation.
  356. ## Contributing
  357. PRs welcome, especially:
  358. - Additional platform-specific gotchas and workarounds
  359. - New animation recipes for common UI patterns
  360. - Production crash patterns from real apps
  361. - Corrections based on newer Compose/CMP releases
  362. - Auto-update tooling for tracking new releases
  363. ## License
  364. MIT — see [LICENSE](LICENSE).
  365. Source code from `androidx/androidx` is Apache License 2.0, copyright The Android Open Source Project. Source code from `compose-multiplatform-core` is Apache License 2.0, copyright JetBrains s.r.o.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.