Good Kotlin code usually feels calmer than Java code.
That is the part I keep coming back to. Not faster, not cleverer, not more fashionable. Just calmer. The code asks for less ceremony, says more with less noise, and makes the next change feel less annoying than it should.
I think that is why Kotlin works well for people who have spent enough time in Java to notice the small things. You stop appreciating syntax for its own sake and start caring about whether the code is readable, direct, and hard to misuse.
The first thing you notice is the lack of ceremony
Java often makes you pay a tax for simple ideas.
Kotlin still has structure, but it gets out of the way more often. Data classes, named arguments, smart casts, and concise lambdas all help the code read closer to the actual intent. That matters more than people think. When the shape of the code matches the shape of the problem, you spend less time translating in your head.
For me, that is the real benefit. Not that Kotlin is shorter. Shorter code can still be ugly. The useful part is that it usually says the thing more directly.
Nullability is one of the few features that actually changes behavior
I trust Kotlin more than Java in part because it makes null handling harder to ignore.
Java lets you wave your hands and hope the null problem stays someone else’s problem. Kotlin forces the question earlier. That does not make bugs impossible, but it does make the risky parts more visible. And once you have worked in enough codebases, visibility is worth a lot.
The best Kotlin code does not abuse !! to get around the type system. It uses the type system to describe reality more honestly. If something can be absent, say so. If it cannot, keep it that way. That sounds basic, but basic is usually where the useful discipline starts.
Extension functions are useful when they remove clutter
I like extension functions when they make code read naturally.
Used well, they let you attach behavior where it belongs without wrapping everything in a utility class or a pile of static helpers. That can make APIs feel cleaner and more local. You can usually see the intent faster.
But they are also easy to overuse. If every problem turns into an extension function, you end up with code that looks elegant but is harder to trace. The line I try to keep in mind is simple: if the extension makes the code easier to understand, keep it. If it mainly makes the code feel clever, stop.
Coroutines are good when the code still reads like code
Coroutines are one of the parts of Kotlin I actually like, because they usually reduce the amount of ceremony around async work without turning everything into callback soup.
That said, they are not magic. They are only good when the surrounding code stays understandable. If you hide too much work in flow operators, nested scopes, or layers of abstraction, you can still make the program hard to reason about. Kotlin gives you nicer tools. It does not save you from bad structure.
What I want from coroutine code is boring clarity. I want to know what runs, where errors go, and what happens when something times out or gets cancelled. If I have to untangle that every time I read the function, the code is not good, no matter how modern it looks.
Readability still wins
This is the part people miss when they argue about language style.
Good Kotlin code is not the code with the most language features in it. It is the code that is easiest to read three months later. That usually means keeping the control flow obvious, naming things plainly, and not using language features just because they are there.
If a Kotlin file starts to feel too clever, I usually assume somebody has gone past the useful part.
The best Kotlin code I have seen has a very specific quality: it feels like fewer decisions were left for the reader. The types say more. The null handling is clearer. The async code is easier to follow. The names do more work. The whole thing feels like it wants to be maintained.
That is what good code should feel like.