We’ve been running with Gradle’s Isolated Projects for a few months now, and it’s been a game changer for our build times 💥. An unexpected benefit: because modules are much cheaper now, we’ve completely rethought how we modularize our app.
Cyril Mottier
@cyrilmottier.com
Leadership, Engineering & Product amo.co. ex Zenly (Snap), CapitaineTrain.
I published vibrance-0.1.0 on Maven, now with support for Compose for Desktop (JVM). The APIs let you mix colors yourself, or draw gradients as modifiers or Compose brushes. Next steps: refine the model training to improve some color transitions, better alpha support. github.com/romainguy/vi...
Can't wait to meet the Kotlin community @kotlinconf.com for the next 2 days. You can find me on Bump 😛. See you tomorrow 👋
I often describe engineering leadership as choosing "the least flawed decision." There are no perfect trade-offs in software. Every choice has a cost. The job is to understand those costs, make them deliberately, and slow system entropy better than competitors.
"Software engineering is programming integrated over time" has never resonated more. Programming is getting close to free. The hard part is building systems that can live, change, and remain reliable over time.
A strong signal that your feature was designed well: it has clear boundaries. So clear that removing it feels like using a scalpel: delete a single directory, not start an excavation.
I'll be in the Bay Area for a few days Week 18. Ping me if you are around and wanna grab a coffee.
AI isn’t changing the job of engineering leadership. It’s amplifying it. Our job has always been to turn raw contributions into reliable systems. Before, that meant juniors & new hires. Now, it also means agents & AI-augmented engineers. What changed is the throughput.
Divide and conquer still wins. Separation of concerns still wins. Modularity still wins. Why? Because complexity is expensive. For humans (cognitive load, pace, quality) and for AI (reasoning depth, latency, token burn). Fighting complexity still pays off.
The fundamental shift with modern AI: the time it takes to execute is starting to match the speed at which ideas appear.
AI in software engineering is a megaphone: it makes both good and bad developers louder. The difference? One is music. The other is noise.
Compile-time flagging is a game-changer for large codebases. Just be sure to expose these variants only at the highest level of your build. If you don’t, you’ll end up with combinatorial complexity leaking everywhere in your code.
> We fixed a few minor bugs that were causing problems. Thanks for that detailed changelog. Super helpful 🤦♂️
Thrilled to meet the Android community tomorrow and dive into video generation, dependency injection, and compiler plugins! Don’t miss out, register now: www.meetup.com/android-pari...
Meetup de Janvier chez amo 👑, Tue, Jan 13, 2026, 7:00 PM | Meetup
Bonne année 2026 à tous 🥳! On vous souhaite une bonne dose de Kotlin, d'Android, d'interfaces réactives & intuitives et surtout du code bien propre ✨! Pour commencer sur
meetup.com
Join us with @ParisAndroidUG at @amoamoamo HQ on Jan 13, 2026! 🚀 On the agenda: generating videos off-screen and off-main thread from Composables, why & how we switched from Hilt to Metro DI, and how to build your own Kotlin compiler plugin.
Big news. On January 13, 2026, amo is serving up something special for the @parisandroid.bsky.social 🚀. Think Metro DI insights and video magic from Composables. Stay tuned after the holidays for all the details!🍹
Hidden perk of Metro DI over Dagger: no more wrestling with naming binding functions. We’ve migrated nearly our entire codebase to @Contributed* annotations cutting thousands of lines of code in the process.
My job isn't to design the perfect solution. It's to build the least flawed one possible.
Websites like apilevels.com are useful, but nothing beats analyzing your own data. At amo, we see a radically different Android versions distribution. It completely shifts our decision process regarding usage of AGSL, AVIF, HEIC, and more.
Tooling helps manage the complexity of large codebases. We built tools to track important metrics: ‘unused-modules’ to find deletable modules via DFS, ‘longest-path’ to calculate the longest dependency path - highlighting potential critical paths and more.
Watched 'The Whale' last night. It made me cry, and I still get goosebumps rewatching the ending scene. Strongly recommended!
I love enums/sealed classes/union types. I really do. They give exhaustivity at compile time ❤️. But they just don’t scale. I always end up making the painful choice of trading compile-time safety for scalability. It hurts, but it’s necessary.
