Claude Code hooks let you run your own shell commands automatically at specific points in Claude Code’s lifecycle — for example, after it edits a file or finishes a command. Imagine every Kotlin file Claude touches getting formatted and linted on the spot, or your test suite kicking off the moment a test file changes. […]
Understanding the Boundary Between Sealed Interfaces and Sealed Classes If you’re building a well-typed Kotlin codebase, you’ll encounter moments where you need to restrict which types can inherit from a base type. Sealed classes have been the go-to for this for years, but Kotlin 1.5 introduced sealed interfaces — and they’re better in subtle but
Building a live wallpaper is one of the best ways to learn Android’s rendering pipeline — and one of its harshest teachers of battery discipline. When your app draws on the home screen all day, every wasted frame eventually shows up in someone’s battery stats. Over the years building Seasons Live Wallpaper, I’ve learned that
What Are Kotlin Contracts? If you’ve worked with Kotlin for a while, you’ve likely encountered functions from the standard library that seem to have almost magical powers. Take require() and check()—call them with a condition, and the compiler somehow knows that if execution continues past that line, your variable is no longer nullable. Or use
The Problem: Primitive Obsession You’ve probably seen this pattern in production code: database IDs represented as Long, user emails as String, currency amounts as Double. On the surface, it’s simple and pragmatic. But it introduces a subtle bug vector—primitive obsession. Imagine you have a function that accepts a user ID and a post ID, both
LLM Prompts for Code Refactoring: Structuring Your Requests When you’re facing a large refactoring task in your Android codebase, asking an LLM the right way can save you hours. Unlike simple coding questions, refactoring requires your AI assistant to understand the architectural context, the business logic you’re preserving, and the specific constraints of your project.
Why Property Delegates Often Go Unnoticed Most Kotlin developers know lazy — it’s everywhere. You see it in Android ViewModels, dependency injection setups, and library code. But the standard library ships two more property delegates that are surprisingly powerful and almost never discussed: Delegates.observable and Delegates.vetoable. If you’ve been wiring up manual setters or using
The Hidden Cost of Eager Collections Kotlin’s collection functions — map, filter, flatMap — are a joy to use. But they share one characteristic that can quietly hurt your app: they’re eager. Each call processes the entire source and allocates a brand new intermediate list. Chain three or four of them on a list of
A Familiar But Slightly Awkward Pattern If you’ve written Kotlin for a while, you’ve almost certainly written code like this: fun getActiveUsers(users: List): List { val result = mutableListOf() for (user in users) { if (user.isActive) result.add(user) if (user.isPremium) result.add(user.copy(label = “Premium”)) } return result.toList() // convert back to read-only } The pattern works, but
The Problem With Try-Catch Everywhere Exception handling in Kotlin (and Java before it) has always had a composability problem. Once you introduce a try-catch block, you break the expression-oriented flow of your code. You can’t easily chain operations, return from them in one line, or pass the “success or failure” result to another function without
The Old Way: Manual Time Measurement If you’ve ever benchmarked a function in Kotlin or Android, you’ve probably written something like this: val start = System.currentTimeMillis() val result = doExpensiveWork() val elapsed = System.currentTimeMillis() – start Log.d(“Perf”, “doExpensiveWork took ${elapsed}ms, result=$result”) It works, but it’s noisy. You need three lines just to time one call,
AI-assisted development has moved well beyond autocomplete. Claude Code — Anthropic’s agentic coding tool — can read your project, reason about your architecture, write Kotlin, generate tests, and even help you debug Gradle. But like any powerful tool, it rewards those who know how to use it well. This guide walks you through everything you
One of the most satisfying things to code is a particle system. Snowflakes, falling leaves, fireflies — simple physics, beautiful results. Here’s how Seasons Live Wallpaper handles its snow, and how you can build something similar. The Particle Data Class data class Snowflake( var x: Float, var y: Float, val radius: Float, // visual size
In this article I would like to emphasise over a few options that we have when working with data structure and more precisely with collections in a mutable and immutable fashion. So let’s start with a few of them and see their mutability state. But first, what makes a list mutable or immutable? Immutable Collections
