Migrate Xml Views To Jetpack Compose
Android (Google)OfficialCreated by Google LLCDistributed by Android (Google)
- Skill
- Workflow
- Software development
- Apache-2.0
- No issues found
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
This skill provides a systematic methodology for converting Android XML Views into declarative Jetpack Compose components. It emphasizes maintaining visual parity and functional integrity through a rigorous process that includes project analysis, dependency setup, theming alignment, and validation. The workflow is designed for incremental adoption, ensuring that legacy XML and new Compose code can coexist through interoperability APIs while preparing the codebase for a full transition to Compose.
What it does
- Analyzes existing XML layouts and project infrastructure for migration readiness.
- Guides the setup of Compose dependencies and compiler configurations.
- Facilitates the migration of XML themes to Material 3 Compose theming.
- Provides a structured approach to replacing XML View usages with Compose components.
- Ensures visual parity through automated screenshot testing and Compose Previews.
- Manages the safe removal of legacy XML files and associated resources.
When to use it
- When modernizing an Android application's UI layer from XML to Jetpack Compose.
- When you need to perform an incremental migration of specific UI components.
- When you need to ensure visual consistency between legacy XML and new Compose code.
- When integrating new Compose features into an existing View-based Android project.
Advantages
- Reduces risk by following a validated, step-by-step migration methodology.
- Maintains project stability through interoperability best practices.
- Ensures visual fidelity using baseline screenshot comparisons.
- Promotes clean code by systematically removing redundant legacy XML resources.
Usage examples
- “Help me migrate my login_screen.xml to Jetpack Compose.”
- The agent will initiate the 10-step workflow, starting with an analysis of the login_screen.xml structure and project dependencies to create a migration plan.
- “How do I handle theming when moving from XML to Compose?”
- The agent will guide you through mapping XML color attributes and styles to Material 3 semantic roles within a Compose MaterialTheme.
Install
Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/android/migrate-xml-views-to-jetpack-compose/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip migrate-xml-views-to-jetpack-compose.zip -d .agents/skills
Documentation by Google LLC
This skill guides through the process of migrating an existing Android XML View to Jetpack Compose. It performs a stable, safe and visually consistent transition by following a structured, 10-step methodology. This skill migrates UI (XML to Jetpack Compose) only.
Objective
To systematically convert a single legacy XML layout into modern, declarative Jetpack Compose UI while maintaining pixel-perfect visual parity and functional integrity.
Summary of the 10-step migration process
Identify the optimal XML candidate for migration
Analyze the project and layout
Create a plan
Capture the XML View UI
Set up Compose dependencies and compiler
Set up Compose theming
Migrate the XML layout to Compose
Validate the migration
Replace usages
XML code removal
Detailed steps
Step 1: Identify the optimal XML candidate for migration
If the user has explicitly specified a target XML layout, proceed to Step 2. Otherwise, analyze the codebase to identify the best candidate for migration by following the logic in references/identify-optimal-xml-candidate.md.
Step 2: Analyze the project and layout
Analyze the identified XML View's structure, hierarchy, and implementation details. Use references/analysis-of-the-project-and-layout.md to guide your technical audit of the layout and surrounding project context.
Step 3: Create a plan
Using the outputs and analysis done in the Step 1 and 2, generate a step-by-step plan for the migration. If you support user interaction, present to the user and ask for approval before proceeding. If user interaction is not supported, proceed to Step 4 following the generated plan.
Step 4: Capture the XML View UI
IF you support user interaction, ask the user to upload a screenshot of the XML View UI or provide an absolute path to a file. Use this image as a visual reference for the layout migration in Step 7. ELSE IF you are able to run an Android emulator, locate an existing screenshot test for the XML candidate. If none exists, create one using the existing project testing framework. If no framework exists, use UI Automator or Espresso to create a screenshot test with minimum required setup. Run the test and take a baseline screenshot of the XML UI. ELSE proceed to Step 5.
Step 5: Set up Compose dependencies and compiler
Check build.gradle or libs.versions.toml for Compose dependencies and
compiler setup. If missing, use
Setup Compose Dependencies and Compiler.
Run a sync to ensure dependencies resolve without errors.
Step 6: Set up Compose theming
If the project already has Compose theming set up, proceed to Step 7. If Compose theming is missing, initialize it. For Material-based projects, follow Material 3 migration guidelines. For custom design systems, apply expert judgment to migrate XML theming and match existing styles. Constraints: Do not migrate the entire theme. Implement only the minimum theming required for the specific XML candidate. Maintain original XML themes for interoperability. Maintain existing project code conventions, patterns, names and values.
Step 7: Migrate the XML View to Compose
Convert the XML candidate to Jetpack Compose code, referencing references/xml-layout-migration.md and the image from Step 4. You must include a Compose Preview for the newly created composable to facilitate visual verification.
Step 8: Replace usages
Replace the usages of the migrated XML layout to use the new Compose component.
To add Compose in Views, use Compose in Views.
To add Views in Compose, use Views in Compose.
Step 9: Validate the migration
Compare the baseline screenshot image from Step 4 with the rendered Compose Preview of the new composable. Ignore string content; focus on layout and styling. Iterate on the Compose code until visual parity is achieved. Once verified, write a Compose UI test for the new composable.
Step 10: XML code removal
Delete the migrated XML file and its associated legacy tests. Caution: Only remove code and resources that are not referenced by other parts of the project.
Files
- ATTRIBUTION.mdAdded by AutoGineer1.0 KiB
- LICENSELicence file added by AutoGineer11.1 KiB
- SKILL.md5.3 KiB
- references/analysis-of-the-project-and-layout.md3.1 KiB
- references/android/develop/ui/compose/designsystems/migrate-xml-theme-to-compose.md8.1 KiB
- references/android/develop/ui/compose/migrate/interoperability-apis/compose-in-views.md12.0 KiB
- references/android/develop/ui/compose/migrate/interoperability-apis/views-in-compose.md12.2 KiB
- references/android/develop/ui/compose/setup-compose-dependencies-and-compiler.md7.3 KiB
- references/identify-optimal-xml-candidate.md1.6 KiB
- references/xml-layout-migration.md3.5 KiB
references/analysis-of-the-project-and-layout.md
1. Project health & build validation
Before performing any analysis, you must confirm the project is in a functional state. * Integrity check: Verify the project syncs (Gradle) and builds successfully. * Error resolution: If there are pre-existing build errors or sync failures, you must report these immediately and attempt to fix. Do not proceed with migration until a stable baseline is established.
2. Compose pattern & consistency analysis
If Jetpack Compose is already present, you must align with the established implementation style.
* Pattern identification: Scan the codebase for @Composable functions. Identify the project's "Best Practices" regarding state hoisting, composable construction and naming conventions, and file organization.
* Theming review: Determine how MaterialTheme or custom theme systems are implemented.
* Identify if the project uses a custom design system theme.
* Map how attributes, styles, and other theme components are accessed in Compose.
3. Design system & infrastructure audit
Understand the design system classification (e.g. Material 2, Material 3, or custom design system).
* Resource mapping: Locate central XML definitions:
* colors.xml (Light/Dark variants)
* dimens.xml
* styles.xml / themes.xml
* Hybrid analysis: Determine if the project is XML-only , Compose-only , or Hybrid .
* Reuse constraint: If a Compose theming layer (e.g., AppTheme.kt) already exists, DO NOT generate a new one. You must reuse the existing infrastructure and contribute to it by following its existing implementation pattern.
4. Candidate layout decomposition
Analyze the specific XML layout targeted for migration. You must extract and document the following requirements for the new composable: * Inputs: UI State objects, primitive parameters, and click listeners. * Styling: Specific color constants, typography styles, and shape definitions referenced in the XML. * Resources: Identifying string resources, drawables, and dimensions. * Layout logic: Modifiers required to replicate the XML constraints (padding, alignment, weight).
5. Architectural & non-UI analysis
Understand the environment in which the UI resides to ensure proper integration.
* State management: Identify the usage of ViewModel, Flow, or LiveData.
* Dependency Injection: Check for Hilt, Koin, or manual DI to understand how dependencies are provided to the UI layer.
* Testing & architecture: Note the architectural pattern (MVI, MVVM, or custom architecture setup.) and existing UI testing frameworks to ensure the migrated code remains testable. Unless the user explicitly requests, DO NOT make any changes to any non-UI code that aren't strictly required for the migration of the XML View.
Pro-tip: Always prioritize the "Existing infrastructure" over "Default templates." If the project has a custom way of handling spacing or colors, composable code, or any other project layer, your generated Compose code must reflect that specific implementation.
Requirements and compatibility
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Security
No issues found by our static scan· No issues found
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Created by
- Google LLC
- Publisher
- Android (Google) (Official)
- Distributed by
- Android (Google)
- Source
- android/skills · jetpack-compose/migration/migrate-xml-views-to-jetpack-compose · commit bf68e2d
- Licence
- Apache License 2.0 (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE.txt)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by Google LLC or Android (Google).
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download migrate-xml-views-to-jetpack-compose.zip