GM Friends. This is JetpackCompose.app’s Dispatch - your guide through the Android jungle that we’ve all come to love 🦍

This is Issue # 11 and and we're shaking things up. Instead of our usual format, I decided to throw a curveball: I asked some of the sharpest Android experts a burning question about the future of Android, and boy, did they deliver!

Here’s our expert lineup for today: Gabriel Peal (OpenAI), Stacey Devino (Fanatics), Ty Smith (Uber), Kaushik Gopal (Instacart), P-Y (Block), Tasha Ramesh (Tinder), Ryan Harter (Dropbox), Allie Ogden (Swappa), Vishnu Rajeevan (Freelancer) & Mike Wolfson (Target) 🤯 

There’s a bunch of stuff that I absolutely agree with and some, not so much. Regardless, I’m confident that it will ignite some wires in your brains and you will have a lot of takeaways so get yourself a nice cup of coffee and read away ☕️

Where do you see Android Development in three years, and how do you think developers should prepare for that future?

The first 13 years of Android (2008-2021) was defined by an incredibly rapid rate of improvement. This chapter was defined by:

• Android 1.0 -> 12  

• Eclipse -> Android Studio  

• Java -> Kotlin  

• AsyncTask -> RxJava -> Coroutines  

• Dagger 1.0/Guice -> Anvil  

• G1 -> Pixel 6

The progress was staggering during that period. Any app that was over a year old was inevitably ridden with "legacy" libraries and patterns. In my opinion, the finale of this chapter concluded with the release of Compose and Coroutines.

For the first time, an app built in 2021 would look nearly identical to an app built in 2025 and I don't see that trend meaningfully changing. Having spent time on many other platforms, I can confidently say that Android has a state of the art IDE, language, asynchronous primitives, UI toolkits, observability tools, and more.

The next chapter won't be about improving or reinventing primitives, it'll be about providing tools that allow more people to make high quality apps and enabling everybody to spend more time thinking about what they want to build, not how they want to build it.

AI will inevitably make its way into the life of an Android engineer including:

IDE: Android is in a particularly tricky spot with AI assisted IDEs. Copilot on Jetbrains IDEs is an afterthought and Cursor is inherently VS Code only and I don't see Android engineer switching to the VS Code platform any time soon. Jetbrains and Google are working on coding assistants but it remains to be seen how competitive they will be. In addition, LLMs are not as good at writing Compose as they are React and Python. It's also harder for them to "use" an Android emulator than a browser. There is opportunity for improvements on all fronts but I think the AI tooling will, at the very least, lag behind the forefront. 

Testing: I think it will become standard to have AI agents QAing your app nearly 24/7. By using natural language and multimodal inputs, models will be able to continuously and comprehensively test nearly any app with little setup.

Kotlin Compose Multiplatform on Jetbrains Fleet, likely in a cloud instance. Because... you are no longer an Android developer.

You just make Apps now, this is app development... and maybe even Backend. Android/iOS/Web/Desktop/Wearables/AR Hardware are all just compilation targets.

3 years from now, Fleet and build engines like Gradle & Bazel will have fixed the ergonomics of developing for iOS natively in KMP (a major pain point right now). Compose tooling for rendering on multi-device and multi-target will be little more than an annotation processor and we have a custom version of Skia that compiles nicely and quickly for our multiple use cases (*coughs in Flutter*).

Code modularity and truly modular architecture will allow Core code-monoliths where every aspect of a feature merges down together. Client-facing Backend and Consumer-facing Client Platforms folks will have options for deeper specialization and more broad perspective when it comes to delivery simultaneously, sharing any needed core logic where required across any platform. If you don't currently have module separations for Kotlin-only/Android-only/Compose-only dependencies and making your way to full Compose with all code being Interfaced on those layers between, you are already behind.

AI will be a tool that does more than just variable or typed code completion, but analytical to the code changes you are making for better quality answers and the ability to notice things in code that you may have missed prior to sending for review. It's biggest power in your work is as a contextual search engine in the IDE and a unit test generator. Maybe, even as an E2E tester as it can intelligently navigate apps with the adeptness of a 9yo student.

There will not be new Android Developers and our ranks will only be augmented by the platforms Kotlin consumes like what is happening to Java for Backend.

Sadly, newer generations of developers seem genuinely uninterested in pursuing mobile as it is seen as "extremely difficult" by a graduate who expect apps to be written in a few hundred lines of Python. Which, to be fair, is often all that was expected of them to deliver generated art or extremely detailed statistical analysis. The old Android hats will get even older and finally grow into the "Linux Beards" we have always secretly been. It means more the platform progress becomes community owned as Google switches business investment priorities and JetBrains directs Kotlin forward.

New blood isn't coming into Mobile and AI will have destroyed entry level software jobs so the pipeline no longer exists either. That also means the same for the Wearables and AI platforms coming next. It will still be us.

While a bit bleak, those already in the industry will likely have a place in its' future if they can prove themselves more valuable and creative than a code monkey trained on StackOverflow.

As the platforms enter their periods of long-term stability and the market looks to minimize costs, we'll see a continued push on cross-platform technologies. React Native will continue to thrive with newer companies due to its large pool of engineers and bigger TAM, and phone hardware is getting faster, and we'll also see further adoption and maturity of KMP. Platform innovations and where more native development will be invested will focus on non-phone form factors, like AR/VR, more scaled-out businesses, and more novel use cases. The gap between cross-platform and native apps will widen quite a bit over 3 years, so having a polyglot understanding is going to be more important.

More companies will invest in monorepos earlier in their lifecycle, putting more pressure on generalist build systems like Bazel to mature for Android. We'll also see more Kotlin in the backend at companies, opening doors for knowledge sharing and contributions by Android developers to other domains. We will start to see more Kotlin support in other dev tools, like alternative IDEs.

AI will continue to accelerate in quality and capabilities and will be a key tool for helping engineers quickly develop and scale products. As a result, more of the SDLC will be integrated, and AI will be an implementation detail of most tools rather than the main draw. Toil work will be greatly minimized until modern software development looks fundamentally different.

Unless the consumer market discovers a new-found desire for new apps, features, and experiences, this trend will have a continued market impact and further shrink open roles in existing companies. It will lower the overall need for team size and focus the open roles on more senior folks. The competition will increase in the smaller companies and startups because of the availability to productionize more quickly and access to more talent. However, it will also cause long-term issues, as there will not be enough new folks being mentored, and there will be a risk of loss of tribal knowledge.

It's too soon to tell what new developer archetypes exist, but I wouldn't be surprised if there are many more product-oriented developers using these tools to output quickly with a deeper integration into the consumer, business, etc.. and a smaller number of deep platform experts who need to thoroughly understand, review, and debug the AI outputs, and invest in their long term direction. The way to stay relevant is to align your work and goals with the business, understand your industry deeply, be quick to adapt & master new trends and tools, grow and lead people, and not be purely a technical specialist.

AI everything 🙄
AI is going to dominate every aspect of #AndroidDev. How we do #AndroidDev (writing the code, debugging, measuring etc.) - we’re only beginning to grasp some of these changes, but they will come pretty quickly. On the product side, we’ll see more on-device AI, with smaller models like Gemini Flash/o3-mini running locally to provide operator-like intelligence directly on phones and this will probably be what most folks are geared towards doing for mobile development.

Mobile is still
Speaking of which... mobile remains the fulcrum of all things AI. we'll see a lot of cool products like XR/glasses but those will at best occupy a market like airpods (auxiliary devices) but mobile still remains king.

Focus on product vs architecture/tech
Historically, AndroidDev conversations are predominantly around architecture, technologies, libraries etc. With Pixel and other Android OEMs gaining traction and having high quality hardware devices that are more AI-capable, our conversations (especially with 3rd party devs) are also going to shift around building premium experiences (some of this is me hoping).

CMP/KMP will cement a nice middle-tier position
Despite Google’s backing, KMP won’t completely dominate cross-platform development but it will continue growing as a serious player. Coupled with Compose Multiplatform (CMP), KMP may start overtaking Flutter and React Native in certain segments. However, unless there’s some kind of miraculous partnership with Apple, it will likely remain in its current tier—powerful, but not a universal cross-platform solution.

Myself? In 3 years I'll probably still be having fun debugging some nasty legacy code that uses all possible patterns in one go. For everybody else, I hope that by then we've figured out how to organize our Compose & coroutine code in a way that's maintainable with less footguns, that we'll have solid state management patterns instead of a bajillion remember(). I think our salaries will go up because you need a lot of expertise to undo the damages of AI generated code (😂). My biggest hope is that we'll have solved observability, i.e. that we're able to understand exactly what's happening in our mobile apps that run in production, without using SDKs that cost a fortunate and negatively impact the customer experience.

I think the biggest changes to Android development in the coming years will be related to form factors, including the ability to develop for more platforms, as more and more AndroidX and community libraries add support for Compose Multiplatform. The expansion of multiplatform libraries, along with the broadening diversity of form factors means that engineers will need to not only consider variations like phone vs. tablet when developing apps, but also things like alternative input methods like mouse and keyboard and fluid window resizing.

Thinking back to how web technologies have somewhat taken over desktop apps, Compose Multiplatform offers the ability for us to reconsider what makes apps good on the desktop vs. mobile devices, and how problems that users might solve on each are different, or similar.

I don't think that AI is going to completely reshape quality app development like much of the current hype will suggest. While AI can help solve some development problems, the real difference between mediocre apps and great apps aren't ones that I believe AI will be able to tackle in the foreseeable future. These problems are things like understanding your customer and the problems they need to solve, building relationships, recognizing patterns in seemingly unrelated systems, and leveraging your experience to determine how solutions to one problem can be bent into the shape of another.

AI as a Supercharger, Not a Replacement
I see AI as an augmentation, not a takeover. The learning curve for Android has always been steep, but AI tools like Studio Bot and Copilot will make onboarding smoother and help developers experiment and adopt best practices without spending hours deep-diving into Stack Overflow threads.

More interestingly, AI might change how teams collaborate. Imagine a world where AI is trained on your codebase, acting as a real-time mentor, surfacing relevant patterns, and even facilitating decision-making. It won’t replace developer intuition, but it will help teams document, discuss, and converge on best practices faster, almost like having an extra voice in the room, one that isn’t biased by seniority or past experience. I wouldn’t be surprised if AI-driven codebase insights become a standard part of onboarding and PR review processes.

The Evolution of Jetpack Compose & UI Development
Jetpack Compose seems to be following the same trajectory as Kotlin. Adoption is ramping up, and in many teams, it’s already at the “why would we do this any other way?” phase. Compose makes UI easier to prototype and iterate on, which means more products will embrace it for its modularity and maintainability. That said, XML isn’t disappearing overnight. Legacy codebases will keep it around under the "if it ain’t broke, don’t fix it" mentality. Long-term, I’d love to see Compose paradigms absorbed directly into Kotlin so UI development feels more native and less like something bolted onto the ecosystem.

Architectural Patterns
Will We Finally Agree on One? Unidirectional Data Flow (UDF) seems like the best bet for a standard. Google’s recent documentation efforts have helped, but I’d love to see them go even further. There’s still too much inconsistency in how teams structure Android apps, and it would be great to see a clear, opinionated approach emerge as the default.

Pain Points That (Hopefully) Go Away 
Fast-forward three years, and my dream scenario looks like this:

• No XML, no Activity themes, no Fragments. Just Activities and Compose.

• AI-powered tools generate design-system-compliant UI code from a spec, not just boilerplate but something that actually accelerates iteration.

• Business logic is written with AI-assisted unit testing baked in.

• Performance tuning becomes mostly automated, abstracting away device-specific optimizations.

• Cross-platform just works. (Not just “KMP exists” but a true solution to fragmentation.)

• Gradle build times stop ruining lives, and modularization strategies become standardized with an optimized, graph-based approach to dependencies

The Role of the Android Developer in an AI-Assisted Future
As AI lowers the barrier to entry, the role of an Android engineer shifts. The real value won’t be in just writing code but in understanding architecture, performance, and how to create great user experiences. The engineers who thrive will be the ones who think critically, solve complex problems, and push beyond just implementation. If I had to sum it up: Android development in three years will be more intuitive, more automated, and hopefully way less painful. But the creativity and problem-solving skills of engineers will matter more than ever, as AI becomes a powerful extension of workflow, helping us build faster and tackle challenges with a supercharged toolbelt.

We'll all be re-writing our apps again to implement the new design system (Material... 4?). We'll probably have auto-complete and auto-fixes powered by AI integrated into our IDEs. We can best prepare for the future by focusing our learning far more on architectural decisions rather than on syntax.

What distinguishes us from the machines will be our deep understanding of eccentricities of the platform that aren't easily indexable. When you find yourself frustrated that the search results are unhelpful, find solace in the thought that it means better job security for you (😂).

This is a fun question! If you'd asked me 3 years ago, I don't think I would have been able to predict where we're at now. However, after almost 15 years of doing this, something feels....stable! My hope is that we do find ourselves in a place with easy to reach for tools and practices off the shelf. I think gen-AI will find its little slot in our toolkit, but realistically we'll still need highly skilled humans that are able to put all the pieces together. At the end of the day, we're making things that humans touch, and it takes a human touch to do that right.

I think, to prepare, just keep sticking with what you're doing. If you're new in the field, learn learn learn. Always be willing to learn the new thing, don't get set in your ways or try to hold on to technology and practices from the past. It is a massive, well matured framework toolkit and there's always something new to learn, some new layer to play with, some new person to talk to. I think one thing that has been consistent in my career is that the best devs I've worked with are the ones that are always ready to change and try new things.

I think it will continue to get easier to develop Android apps, with better tools, particularly AI, enabling the dev to get a lot of boilerplate templates configured via fairly simple interactions with the tools. Compose will continue to evolve, including a more opportunities for delight from animations and complex UI interactions. Overall the future looks bright for Android devs!

🦄 How you can help?

👉🏻 If you enjoyed this newsletter, I'd greatly appreciate it if you could share it with your peers and friends. Your support helps me reach more Android developers and grow our community. Writing this newsletter takes time and effort, and it truly makes my day when I see it shared within your network. Consider tweeting about it or sharing it in your team's Slack workspace. Thank you!

👉🏻 If you find this newsletter or any of my other free websites or open source contributions useful, consider supporting my work 🙏🏻

👂 Let me hear it!

What’d you think of this email? Tap your choice below and lemme hear it 👇

🚀🚀🚀🚀🚀 AMAZING-LOVED IT!

🚀🚀🚀 PRETTY GOOD!

🚀 MEH - NOT GREAT

On that note, here’s hoping that your bugs are minor and your compilations are error free,