DEV Community: Olwethu Pissot

We shipped an MCP Server for accurate AI fixes in KMP apps

Olwethu Pissot — Mon, 27 Apr 2026 13:55:16 +0000

If you've ever pasted a crash log into your AI assistant and gotten back "try moving work off the main thread" — you know the problem.

Your AI assistant has not a single clue what's actually running in your app. No dependency graph, no session data, no component timings. So it guesses.
And sometimes it's right.

That's what we kept hearing from Android and KMP teams. And it's what we built the Kotzilla MCP Server to fix.

The problem

Android and KMP teams spend hours on production issues that should take minutes. An ANR shows up in Play Console.
Someone digs through logs, pastes a stack trace into Claude or Cursor, and gets a suggestion that doesn't account for the actual dependency chain causing the problem.

For KMP teams it's worse.
A crash only shows up on iOS. Your monitoring tool has nothing useful for that target. Your AI assistant has even less. So the debugging process is mostly educated guesses while the issue sits in production.

*The root cause is almost always the same: your AI assistant is working blind. *

It sees your code but not your runtime. It knows your architecture on paper but not how it behaves under real user sessions.

What we built

The Kotzilla MCP Server connects your AI coding assistant to the Kotzilla Platform.
It gives your assistant the same structural and runtime context Kotzilla captures from real user sessions — dependency graphs, resolution timings, crashes, component behaviour — together with a knowledge base of proven fix patterns for Android and KMP projects.

The result: your assistant can go from detecting an issue to producing a concrete fix, all without leaving your editor.

How it works

Once connected, you ask your assistant questions in plain language:

What are the main performance issues in my app?
Why is HomeScreen slow?
Show me the crashes on the iOS target of my CMP app
Is version 1.2.1 performing better than 1.1.5?

Your assistant gets back real data. It gets back dependency resolution trees with timings, symbolicated stack traces, component-level performance data across every KMP target.
And uses it to give you a specific answer, not a guess.

Ask it to fix the issue and it retrieves the fix pattern for that specific issue type, reads your code, and applies the changes across files under your review.

A few things you can ask it right now

Setting up

One natural language prompt registers your app, reads your project structure, generates kotzilla.json, updates your version catalog and Gradle plugin, and adds the monitoring() call to your Koin setup.

After that, your assistant is connected to real session data from your app. You don't need a new dashboard, context switching, or copy-pasting between tools.

Works with the tools you already use
Claude Code, Cursor, Windsurf, the Android Studio MCP panel, and any LLM-powered terminal assistant.

Try it

Free to get started.
👉 doc.kotzilla.io/docs/discover/mcpServer

If you try it, we'd love to hear how it holds up in the wild, especially on KMP projects.

Drop a comment below.
— The Kotzilla team

We're Kotzilla — and We're Done Watching Android Devs Navigate Blind

Olwethu Pissot — Thu, 09 Apr 2026 14:48:12 +0000

Hey dev.to 👋
We're the team behind Koin — the dependency injection framework used by 25% of native Android applications. If you've built an Android or Kotlin Multiplatform app in the last few years, there's a good chance Koin is already in your stack.
We've spent years in the Android ecosystem. We know the codebase, the tooling, the pain points. And one pain point kept coming up, over and over again:

Production issues you can't explain.
A crash you can't reproduce. A frozen screen that only happens at scale. A startup time that degrades release after release, with no clear culprit. Most monitoring tools give you flat signals, logs, and stack traces and leave you to do the correlation manually.
We got tired of watching great developers navigate blind.

So we built Kotzilla
Kotzilla is a runtime observability platform built specifically for Android and Kotlin Multiplatform apps. Not a generic APM with a mobile SDK bolted on. Built from the ground up for the Kotlin ecosystem, with deep integration into the dependency injection layer where most performance issues actually originate.
The platform captures every event with full structural context: which component, which thread, which scope, which screen. It doesn't just tell you something is slow. It tells you why — and points to the exact component responsible.

What we just shipped: Console 4.0
Today we're sharing a walkthrough of our new Dashboard,the centrepiece of Console 4.0.

It connects business-level health KPIs (Crash Free Rate, ANR Free Rate, Slow Component Free Rate) to the root cause detection Kotzilla is known for. You start from user impact, drill down to the blocking component, and land on the exact dependency resolution causing the problem,in three clicks, with no custom instrumentation.
We walk through a real example in the full article, from a slow MainActivity all the way to MainViewModel, blocking the main thread and the full dependency graph explaining why.

What's next
We'll be posting here regularly — deep dives on Android performance, Kotlin Multiplatform observability, Koin internals, and everything we're learning building dev tools in the open.
If that sounds useful, follow us. And if you have questions, war stories about production issues, or things you wish your observability tooling could do — drop them in the comments. We're genuinely listening.

— The Kotzilla Team

When developing a Compose application......

Olwethu Pissot — Tue, 29 Oct 2024 14:25:15 +0000

👋🏾 you can use the koinInject function to inject any instance or koinViewModel to inject a ViewModel.

Instances injected via koinInject will follow the lifecycle of the Composable they are used in, releasing the instance when the Composable is disposed. ViewModel instances will adhere to the standard ViewModel lifecycle.

To Get Started With Koin 👉🏾 https://insert-koin.io/

Smooth Migration from Dagger to Koin

Olwethu Pissot — Fri, 25 Oct 2024 14:11:09 +0000

For a smooth migration from Dagger to Koin, consume Dagger components from your Koin configuration using Dagger's EntryPoint to access dependencies. You can declare this dependency in Koin thanks to the daggerBridge. #AndroidDev

https://blog.kotzilla.io/why-migrate-from-dagger2/hilt-to-koin

Koin is now updated to support the latest Kotlin version

Olwethu Pissot — Thu, 24 Oct 2024 12:15:18 +0000

The Koin framework is now updated to support the latest Kotlin version, now integrating with Google KSP. Koin Annotations 2.0.0-Beta1 to take advantage of Kotlin 2.0.20 and KSP 2.0.20-1.0.25, and target Koin 4.0. This release is based on the stable 1.4.0 version.

Koin has just refreshed all Koin and Kotlin getting-started projects.

Olwethu Pissot — Tue, 22 Oct 2024 12:25:05 +0000

Hey everyone

You can now play with Kotlin Multiplatform Swift UI projects or Compose Multiplatform projects. Also added Ktor & Annotations projects.

You can check them all:

KMP (no shared UI) - https://insert-koin.io/docs/quickstart/kmp/

CMP (Compse UI & ViewModel) - https://insert-koin.io/docs/quickstart/cmp/

Ktor & Annotations - https://insert-koin.io/docs/quickstart/ktor-annotations/

Have a lovey day