Kotlin for Seniors: Stop Writing Code, Start Crafting it. Tooling. Part 4.

do not upset big brother that watching your code quality

As a senior developer, you’re not just writing code — you’re crafting high-quality, maintainable, and scalable software. One of the biggest differentiators between good and great developers is how well they leverage tools to enforce clean code, catch issues early, and ensure long-term maintainability.

In this article, we’ll explore essential Kotlin tooling techniques to level up your development workflow:

✅ Enforce Code Style with ktlint (for legacy projects too)
✅ Detect Issues Early with Detekt (for legacy projects too)
✅ Jacoco Code Coverage for analyzing test coverage
✅ Write Robust Tests for Better Code Stability

Enforce Code Style with ktlint

Ever spent hours debating code formatting in a PR review? Stop wasting time — use ktlint to automate style enforcement and maintain a clean, consistent codebase.

What is ktlint?

ktlint is a zero-configuration Kotlin linter that enforces Kotlin coding standards and formatting rules based on Kotlin’s official style guide.

How to Install ktlint in a Gradle Project

Add this to your build.gradle.kts:

plugins {
    id("org.jlleitschuh.gradle.ktlint") version "12.2.0"
}

Then, run:

./gradlew ktlintCheck

This will scan your codebase and flag any formatting violations.

Auto-Fix Formatting Issues

Instead of manually fixing each issue, run:

./gradlew ktlintFormat

ktlint will automatically fix indentations, spacing, and other style inconsistencies—saving time in PR reviews.

Detect Issues Early with Detekt

Writing clean Kotlin isn’t just about formatting — it’s also about detecting potential issues before they become real problems.

What is Detekt?

Detekt is a static code analysis tool for Kotlin that flags:
✔️ Code smells (long functions, nested loops)
✔️ Complexity issues
✔️ Security vulnerabilities

How to Add Detekt to Your Project

Add this to build.gradle.kts:

plugins {
    id("io.gitlab.arturbosch.detekt") version "1.23.8"
}

# Run the analysis:
./gradlew detekt

Now, your team can enforce quality standards across all PRs before they get merged!

Handling Legacy Code with ktlint and Detekt Baselines

If you’re working on a large legacy Kotlin codebase, introducing ktlint and Detekt can lead to hundreds or thousands of violations. Instead of fixing everything at once, you can use baselines to gradually improve code quality.

What Are Baselines?

A baseline captures all existing issues at a specific point in time.
✔️ Allows you to focus only on new issues instead of old ones
✔️ Helps gradually refactor code without blocking development
✔️ Makes code quality improvements manageable

Creating a Baselines

To generate a ktlint baseline:

./gradlew ktlintBaseline
./gradlew detektBaseline

# regenerate after fixes
./gradlew detektBaseline --delete-baseline

This creates a ktlint-baseline.xml file that ignores existing issues but flags new ones.

This creates detekt-baseline.xml, marking current issues as known, so only new violations will be flagged.

🚀 Enables gradual refactoring without overwhelming the team
🚀 Prevents large PRs filled with auto-fixes
🚀 Ensures new code meets quality standards while keeping old issues under control

Measure Code Coverage with JaCoCo

Writing unit tests is great, but how do you know if your tests are covering enough code? That’s where JaCoCo (Java Code Coverage) comes in — it helps track how much of your code is actually tested and ensures you’re not missing critical paths.

What is JaCoCo?

JaCoCo is a code coverage tool that integrates with Gradle to generate reports on how much of your code is executed during tests. It highlights:
✔️ Which lines/methods are covered by tests
✔️ Which parts of the code are untested
✔️ How much of the project meets coverage thresholds

Setting Up JaCoCo in a Kotlin Project

Add this to your build.gradle.kts:

plugins {
    jacoco
}

tasks.jacocoTestReport {
    reports {
        xml.required.set(true) // Useful for CI integration
        html.required.set(true) // Generates a user-friendly report
    }
}

# Then run
./gradlew test jacocoTestReport

This generates a coverage report under build/reports/jacoco/test/html/index.html.

Enforcing Code Coverage Rules

To fail the build if coverage is too low, add:

tasks.jacocoTestCoverageVerification {
    violationRules {
        rule {
            limit {
                minimum = 0.5 // 50% coverage required
            }
        }
    }
}

Now, if tests cover less than 50% of the code, the build will fail, forcing developers to improve test coverage! Good practice to keep this percentage at least over 50%.
By integrating JaCoCo into your CI/CD pipeline, you enforce better testing discipline and catch potential issues early.

Write Robust Unit Tests for Code Stability

Senior developers don’t just write code — they write tests to ensure their code actually works. If you’re still skipping unit tests, you’re making future debugging 10x harder.

Using JUnit5 and Mockito for Kotlin Unit Tests

First, add dependencies in build.gradle.kts:

dependencies {
    testImplementation("org.junit.jupiter:junit-jupiter:5.12.0")
    testImplementation("org.mockito.kotlin:mockito-kotlin:5.4.0")
}

Unit Test for a Simple Kotlin Function

import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.Test

class MathUtilsTest {
    @Test
    fun `test addition`() {
        val result = 2 + 3
        assertEquals(5, result)
    }
}

Mocking Dependencies with Mockito

If your function depends on external objects, mock them using Mockito:

import org.mockito.kotlin.*

class UserServiceTest {
    private val mockRepo: UserRepository = mock()
    private val userService = UserService(mockRepo)

    @Test
    fun `fetch user should return correct data`() {
        whenever(mockRepo.getUser(1)).thenReturn(User(1, "Alice"))

        val user = userService.getUser(1)
        assertEquals("Alice", user.name)
    }
}

By testing business logic in isolation, you prevent regressions and increase confidence in your code.

🔖 Follow me for more :)