Why migrate at all?

Because callback spaghetti and deprecated APIs slow every future feature. A screen that took a day in XML views takes hours in Compose once the pattern is set. The goal is not a big-bang rewrite; it is a steady march, one screen at a time, with the app shippable after each step.

How do you start a views-to-Compose migration?

1. Pick one self-contained screen with few dependencies. Not the home screen.
2. Ask Firebender to port that screen to Compose, keeping business logic untouched.
3. Run the app and diff the behaviour against the old screen side by side.
4. Delete the old XML once the new screen is verified and shipped.

One screen per pull request. Large migration diffs hide regressions, and reviewers stop reading.

How do you replace callbacks with coroutines?

• Migrate one repository or network layer at a time.
• Keep suspend functions at the boundary and let the agent adapt callers.
• Check dispatcher choices — IO for network and disk, Main for UI updates.
• Watch for cancellation: an old callback that ignored cancellation may now break.

The cancellation point is the one people miss. Converting threading models changes behaviour, so test the cancel path, not just the happy path.

How do you keep the build green?

Never let the agent change dependencies, code and Gradle config in the same step. Sequence them: dependency bump, then code, then config. If a step fails, revert it alone. Committing after each verified step is what makes this safe — without it, a migration branch becomes unrecoverable.

Where should you keep humans in the loop?

Anything touching payment, auth, or background scheduling. These have subtle lifecycle rules an agent may flatten. Review those diffs line by line, and keep an integration test for each migrated flow. The agent is fast; your job is to prove nothing broke.

Quick Summary

• Migrate screen by screen, never big-bang, keeping the app shippable.
• Port business logic untouched and diff behaviour against the old screen.
• Replace callbacks with coroutines layer by layer and test cancellation.
• Sequence dependency, code and config changes; commit after each verified step.
• Keep humans on payment, auth and scheduling flows with integration tests.

What makes Firebender different from a general AI coder?

It is tuned for Android: Gradle, Kotlin coroutines, Jetpack Compose, and the Android SDK. A general agent writes plausible Kotlin that ignores threading rules or lifecycle. A platform-tuned agent knows why you should not touch UI off the main thread, and it can navigate Gradle files without mixing up module paths.

It suits Android engineers juggling legacy Java and modern Compose. It is the wrong tool if most of your work is iOS or web.

How do you install and start?

1. Install the plugin from the JetBrains marketplace into Android Studio.
2. Sign in and connect your model provider or use the bundled option.
3. Open a project and index it so the agent sees your modules.
4. Start with a small task: add a permission and its manifest entry.

Indexing takes a minute on a large multi-module project. Let it finish before asking for cross-module changes, or the agent will guess at file locations.

What tasks does it handle well?

• Converting a screen to Jetpack Compose.
• Adding a Retrofit endpoint and its data class.
• Fixing coroutine scope and dispatcher mistakes.
• Updating Gradle dependencies and version catalogs.

These are pattern-heavy tasks where Android has strong conventions, which is exactly where a tuned agent earns its keep.

Is Firebender free?

Firebender has a free tier for individual developers with usage limits, and paid plans for higher volume and team features. You can also bring your own model API key. Pricing is usage-oriented, so heavy agent use costs more — check current terms before relying on it daily.

What are the honest limitations?

It cannot run your app or see the device, so UI bugs that only appear at runtime still need you and a real emulator. Compose previews and complex navigation graphs often need hand-fixing. And generated code follows common patterns, not your team’s conventions, unless you feed it those. Treat output as a strong first draft.

Quick Summary

• Firebender is an Android and Kotlin specific AI assistant inside Android Studio.
• Install from the marketplace, index the project, then start with a small task.
• It excels at Compose conversions, Retrofit endpoints, coroutines and Gradle edits.
• Free tier for individuals; paid and bring-your-own-key options exist.
• It cannot run your app, so runtime bugs and team conventions still need you.