- Agenten-Code in Android und KMP funktioniert oft, verletzt aber die Layer-Grenzen. Im Review fällt das kaum auf, teuer wird es bei späteren Änderungen.
- „Halte dich an Clean Architecture“ ist als Anweisung zu allgemein. Ein Konsist-Test liefert dem Agenten einen konkreten Fehler, den er selbst korrigieren kann.
- Ausnahmen gehören in eine Liste mit Begründung, und ein eigener Test meldet Einträge, die nicht mehr gebraucht werden.
- In einem KMP-Projekt mit rund 40 Modulen sank die Detekt-Baseline in zwei Tagen von 558 Einträgen auf null. Eine neue Konsist-Regel fand 114 Verstöße in 13 Modulen, heute greift sie ohne Ausnahme.
- In KMP schützt der Compiler nur commonMain. Die Regeln müssen androidMain und iosMain mitprüfen, und dieselben Checks laufen lokal und in der CI.
Beim Agentic Coding in Android- und KMP-Projekten funktioniert der erzeugte Code oft technisch, passt aber nicht sauber in die bestehende Architektur. Ein Hinweis im Prompt auf Clean Architecture reicht nicht, um das zu verhindern. Verlässlicher ist es, einen Teil der Architektur technisch prüfbar zu machen: mit Architekturtests in Konsist und Detekt, die der Agent nach jeder Änderung selbst ausführt und die lokal wie in der CI gelten.
Wo bricht generierter Code die Architektur in Android-Projekten?
Am häufigsten dort, wo der Agent den kürzesten Weg zu einem funktionierenden Feature nimmt: quer durch die Schichten. In unseren Android- und KMP-Projekten sehen wir drei Muster immer wieder.
- Data-Logik im UI-Layer. Ein ViewModel macht plötzlich selbst einen Netzwerkaufruf oder greift direkt auf die Datenbank zu, obwohl das über Repository und Domain laufen sollte.
- Abhängigkeiten dort, wo sie gerade gebraucht werden. Der Agent baut eine neue Abhängigkeit an der Stelle ein, an der er sie braucht. Dadurch kennt die UI auf einmal konkrete Repository-Implementierungen oder Data-Klassen, die dort nichts zu suchen haben.
- Models, die durch alle Layer wandern. Ein API-DTO wird direkt bis in die UI gereicht, statt im Data-Layer auf ein Domain- oder UI-Modell gemappt zu werden. Kurzfristig spart das Code, langfristig koppelt es die Schichten unnötig zusammen.
Warum fallen diese Fehler im Code Review nicht auf?
Weil das Feature erst einmal funktioniert. Wer einen PR prüft, schaut zuerst, ob das Feature tut, was es soll. Ein ViewModel, das eine Data-Klasse importiert, oder ein DTO im UI-State ist im normalen Review leicht zu übersehen.
Problematisch werden solche Fehler oft erst bei späteren Änderungen. Dann wissen plötzlich mehrere Layer voneinander, und kleine Anpassungen haben Auswirkungen quer durchs Projekt. Wie sich die Arbeit insgesamt verschiebt, beschreibt unser Artikel Agentic Coding vs. Normal Coding.
Warum reicht es nicht, dem Agenten Clean Architecture vorzuschreiben?
Weil solche Anweisungen zu allgemein sind und nicht immer gleich interpretiert werden. Unserer Erfahrung nach genügt es nicht, dem Agenten zu sagen, dass er sich an Clean Architecture oder an unsere Projektstruktur halten soll. Was „sauber getrennt“ im Einzelfall bedeutet, legt der Agent jedes Mal neu aus.
Gut zu wissen: Eine Architekturregel, die nur im Prompt steht, ist eine Bitte. Eine Regel, die gegen die Codebasis geprüft wird, liefert einen konkreten Fehler, und genau mit dem kann der Agent arbeiten.
Welche Architekturregeln lassen sich mit Konsist technisch prüfen?
Gut prüfbar sind klare Grenzen zwischen Layern und Modulen. Für den Einstieg eignen sich drei Regeln:
- UI darf nicht direkt auf Data zugreifen.
- Domain darf keine Android-Abhängigkeiten kennen.
- Konkrete Repository-Implementierungen dürfen nur im Data-Layer liegen.

Mit Konsist lassen sich solche Regeln direkt gegen die Codebasis prüfen. Damit fällt zum Beispiel auf, wenn ein ViewModel eine Klasse aus dem Data-Package importiert oder eine Repository-Implementierung außerhalb des vorgesehenen Layers verwendet wird. Der Agent bekommt nach seiner Änderung einen konkreten Fehler und kann genau diesen Verstoß korrigieren.
Wie so ein Test aussieht, zeigt die einfachste Regel aus unserem Projekt: Ein Feature importiert kein anderes Feature. Für jedes Feature-Modul entsteht ein eigener Testfall, und die Fehlermeldung nennt Datei und Import:
class FeatureFeatureBanTest : FunSpec({
val featureNames = featureModuleNames()
featureNames.forEach { name ->
test("feature:$name does not import any other feature") {
val bannedPackagePrefixes = featureNames
.filter { it != name }
.map { "com.example.app.features.$it." }
val violations = projectScope.files
.filter { it.moduleName == "feature/$name" && it.isProductionSource() }
.flatMap { file ->
file.imports
.filter { import -> bannedPackagePrefixes.any { import.hasNameStartingWith(it) } }
.map { import -> "${file.path}: ${import.name}" }
}
violations.shouldBeEmpty()
}
}
})
Wie geht man mit Ausnahmen von einer Architekturregel um?
Mit einer Ausnahmeliste, in der jeder Eintrag begründet ist, und mit einem zweiten Test, der fehlschlägt, sobald ein Eintrag nicht mehr nötig ist. Dieses Muster bringt in der Praxis am meisten, weil eine Regel sofort scharf geschaltet werden kann, ohne dass vorher jeder Altfall gelöst sein muss.
Im Beispiel sollen alle suspend-Funktionen auf Repository- und UseCase-Interfaces ein Outcome zurückgeben. Eine Funktion ist bewusst ausgenommen:
val OUTCOME_ESCAPE_HATCH = mapOf(
"OfflineQueue.processQueue" to "Fire-and-forget: Fehler pro Eintrag werden intern wiederholt",
)
private fun currentViolations(): Map<String, String> =
projectScope.interfaces()
.filter { it.isProductionSource() }
.filter { it.hasNameEndingWith("Repository") || it.hasNameEndingWith("UseCase") }
.flatMap { iface -> iface.functions().filter { it.hasSuspendModifier }.map { iface.name to it } }
.mapNotNull { (interfaceName, fn) ->
val returnType = if (fn.hasReturnValue) fn.returnType?.bareSourceType else "Unit"
if (returnType == "Outcome") return@mapNotNull null
val key = "$interfaceName.${fn.name}"
key to "$key returns $returnType, not Outcome<...> (${fn.path})"
}
.toMap()
class OutcomeReturnTypeTest : FunSpec({
test("suspend functions on data interfaces return Outcome") {
currentViolations().filterKeys { it !in OUTCOME_ESCAPE_HATCH }.values.shouldBeEmpty()
}
test("escape hatch has no stale entries") {
val stillViolating = currentViolations().keys
OUTCOME_ESCAPE_HATCH.keys.filterNot { it in stillViolating }.shouldBeEmpty()
}
})
Gut zu wissen: Der zweite Test prüft gegen die aktuellen Verstöße und nicht nur, ob die Funktion noch existiert. Sonst bleibt ein Eintrag in der Liste, obwohl der Code längst repariert ist.
Wofür braucht es zusätzlich Detekt, und wie streng sollte es sein?
Detekt deckt die kleineren Qualitätsprobleme ab, die Konsist nicht sieht. Gerade bei generiertem Kotlin entstehen schnell sehr große Funktionen, unnötige Verschachtelungen oder Code, der zwar funktioniert, aber unnötig kompliziert geworden ist. Konsist prüft, ob Code in der richtigen Schicht liegt. Detekt prüft, ob er innerhalb dieser Schicht verständlich bleibt.
Bewährt hat sich bei uns maxIssues: 0 ohne Baseline: streng bei Logik, großzügiger bei Composables.
| Regel | Unser Wert | Default |
|---|---|---|
| CyclomaticComplexMethod | 15, Composables ausgenommen | 15 |
| NestedBlockDepth | 4 | 4 |
| ComplexCondition | 4 | 4 |
| LongMethod | 60, Composables ausgenommen | 60 |
| LargeClass | 400 | 600 |
| LongParameterList | 13, Composables ausgenommen | 6 / 7 |
| TooManyFunctions | 20 | 11 |
| ReturnCount | 4 | 2 |
| MaxLineLength | 120 | 120 |
- MagicNumber: Die Regel bleibt an, ignoriert aber Composables. Sonst entstehen Konstanten wie EIGHT_DP.
- Compose-Regeln: Dazu kommt das Regelset von io.nlopez.compose.rules, unter anderem mit UnstableCollections, MutableParams und RememberMissing.
- Lücke bei Composables: Weil Detekt sie bei der Parameterzahl ausnimmt, begrenzen Konsist-Tests öffentliche Design-System-Composables auf 8 Parameter und commonMain-Dateien auf 800 Zeilen.
- Eigene Regeln: Den größten Hebel haben sieben eigene Detekt-Regeln, etwa gegen harte UI-Texte, Result in Signaturen, throw im Data-Layer und selbstgebaute Design-Primitive.
- Lokal und in der CI: Lokal korrigiert Detekt Formatierung automatisch, in der CI prüft es nur.
Wie sorgt man dafür, dass der Agent die Checks wirklich ausführt?
Indem Detekt und Konsist ganz normale Gradle-Befehle sind, genau wie Kompilieren oder Tests, und auf vier Ebenen verankert werden. Im Alltag ergibt sich daraus eine brauchbare Schleife: Der Agent implementiert eine Änderung, führt Build, Tests, Detekt und Architekturchecks aus und korrigiert die gefundenen Probleme selbst.

- Anweisung: Die CLAUDE.md wird in jeder frischen Session geladen und enthält die Definition of Done: Modul kompilieren, Tests, detekt, :konsist-tests:test. Zusätzliche Regeldateien laden automatisch, sobald eine .kt-Datei bearbeitet wird.
- Hooks: Vor einem git push erinnert ein Hook an Detekt, blockiert aber nicht. Hart blockiert wird nur bei destruktiven Befehlen.
- CI: Sie führt dieselben Befehle aus und ist als Pflicht-Check für Merges gesetzt. Hat der Agent lokal etwas übersehen, schlägt es spätestens dort fehl, und der PR lässt sich nicht mergen. Das kann der Agent autonom beobachten und darauf reagieren.
- Wrapper: Ein kleines Skript um Gradle kürzt die Ausgabe und liefert bei Fehlern Ursache und Abbruchbedingung. Der Agent muss also nicht raten.
Die Checks werden außerdem selbst geprüft, denn ein Guard, der nicht mehr anschlägt, fällt sonst niemandem auf:
- Regel-Logik: Viele Konsist-Regeln haben eigene Unit-Tests für ihre Logik.
- Leere Scans: Eigene Tests schlagen fehl, wenn eine Regel nichts mehr scannt, etwa nach einer Umbenennung.
- Veralteter Cache: Konsist liest das ganze Repo, ohne dass Gradle das sieht, und hat deshalb bei uns einmal veraltete grüne Ergebnisse gemeldet. Die gescannten Dateien sind jetzt als Task-Inputs deklariert.
Warum müssen dieselben Checks lokal und in der CI laufen?
Damit für menschlich geschriebenen und generierten Code dieselben Grenzen gelten. Wichtig ist für uns, dass diese Regeln nicht nur für den Agenten existieren. Laufen dieselben Checks lokal und in der CI, gibt es keine Sonderbehandlung: Ein Verstoß ist ein Verstoß, egal wer ihn geschrieben hat.
Was finden die Checks in einem echten KMP-Projekt?
Zwei Refactorings in unserem eigenen Setup zeigen das gut. Es läuft in einem größeren Kotlin-Multiplatform-Projekt mit rund 40 Modulen und etwa 130.000 Zeilen Produktionscode, der größte Teil davon in commonMain.
Detekt: Beim Abbau der Altlasten standen 558 Einträge in der Baseline, zwei Tage später waren es null.
- Regel-Konfiguration für Compose angepasst (MagicNumber): 203
- Restliche MagicNumber-Funde: 73
- Mechanische Fixes, vor allem Zeilenlänge: 201
- UnstableCollections, Umstieg auf Immutable Collections: 38
- Komplexität, echte Zerlegung von Code: 43
Auffällig ist, dass nur 43 der 558 Einträge echte Zerlegung von Code erforderten. Der größte Teil ließ sich über eine passende Konfiguration und mechanische Fixes erledigen.
Konsist: Bei einer neuen Regel zur Paketstruktur innerhalb der Feature-Module meldete der erste Lauf 114 Verstöße in 13 Modulen. Meist lagen Dateien direkt im internal-Root statt im Paket ihres Screens. Über 28 Commits und rund 470 Dateien ging die Ausnahmeliste auf null, seitdem greift die Regel ohne Ausnahme.
Wie führt man die Checks in einem Bestandsprojekt ein?
Bei Detekt über eine Baseline-Datei: Die Altverstöße kommen dort hinein, neuer Code muss sauber sein.
In unserem Projekt startete die Baseline bei 744 Einträgen und fiel durch eine bessere Konfiguration noch am selben Tag auf 508. Am Ende wurde sie vollständig abgebaut und gelöscht. Seitdem gilt maxIssues: 0 ohne Baseline. Drei Stolperfallen haben wir dabei kennengelernt:
- Einträge hängen an Dateiname und Code-Ausschnitt. Beim Aufteilen einer großen Datei kann die Zahl steigen, ohne dass etwas schlechter wurde.
- Ein neues @Suppress an einer Deklaration kann ihren Eintrag ungültig machen.
- Bei parallelen PRs die Baseline neu erzeugen, nicht per Hand mergen.
Für Konsist funktioniert dasselbe über die Ausnahmeliste, jeder Eintrag mit Begründung. Das Prinzip gilt auch für Dateilängen: Über 800 Zeilen braucht eine commonMain-Datei einen eigenen Eintrag, der nur sinken darf.
Was ist bei Kotlin Multiplatform anders?
Detekt und Konsist lesen nur Quelltext und kompilieren nichts. Deshalb prüfen beide iosMain auch auf einem Linux-Runner. Ein grüner Lauf heißt aber nicht, dass iOS baut, dafür braucht es zusätzlich einen CI-Job auf macOS. Außerdem schützt der Compiler nur commonMain: In androidMain und iosMain kompilieren auch android.*- oder java.*-Imports. Die Regeln müssen diese Source-Sets also mitprüfen.
Detekt in KMP
- Keine Typauflösung: Ein einziger Root-Task über alle Source-Sets hat keinen Compiler-Classpath. Regeln mit @RequiresTypeResolution tun dann still nichts, darunter viele aus potential-bugs und coroutines.
- Aufrufe aus Swift sind unsichtbar: Eine Kotlin-Funktion, die nur aus Swift aufgerufen wird, wirkt ungenutzt und braucht ein @Suppress("unused") // Used from Swift.
Konsist in KMP
- expect/actual liegen im selben Paket: Regeln zu Paketgröße oder Paketnamen müssen commonMain, androidMain und iosMain deshalb zusammenrechnen. Sonst gilt eine einzelne androidMain-Datei schon als zu kleines Paket.
- Plattformcode gezielt anders behandeln: Über sourceSetName lässt sich etwas in commonMain komplett verbieten und auf der Plattform nur für wenige benannte Dateien erlauben:
internal fun violatesLegacyJavaTimeBan(
importName: String,
sourceSetName: String,
fileProjectPath: String,
): Boolean {
if (!isLegacyJavaTimeImport(importName)) return false
return when {
sourceSetName == "commonMain" -> true
sourceSetName in PRODUCTION_SOURCE_SETS ->
JAVA_TIME_PLATFORM_ALLOWLIST.none { fileProjectPath.endsWith(it) }
else -> false
}
}
Wann helfen Architekturtests beim Agentic Coding am meisten?
Bei Änderungen, die mehrere Layer betreffen, und bei Refactorings.
- Features über mehrere Layer. Ein neues Feature kann UI, Domain und Data gleichzeitig anfassen. Genau dort passiert es schnell, dass der Agent Abkürzungen nimmt und Verantwortlichkeiten zwischen den Layern vermischt.
- Refactorings. Ein Agent kann in kurzer Zeit viele Kotlin-Dateien verändern. Architekturtests zeigen, ob der Code danach zwar noch baut, aber neue unerwünschte Abhängigkeiten zwischen UI, Domain und Data entstanden sind.
Worauf konzentriert sich das Review, wenn die Checks laufen?
Auf das, was sich nicht sinnvoll automatisieren lässt: Fachlogik, API-Design und Architekturentscheidungen. Der eigentliche Mehrwert liegt für uns nicht darin, dass ein Agent schneller Kotlin schreibt. Interessant wird es, wenn er einfache Architektur- und Qualitätsfehler selbst findet und korrigiert, bevor wir den Code sehen.
Wie ihr das Review im Team dafür aufsetzt, zeigt unser Artikel AI Code Review im Team: PR-Workflow, Regeln, Tools.
Fazit: Architektur prüfbar machen statt sie nur zu beschreiben
Agentic Coding in Android und KMP scheitert selten an der Funktion, sondern an der Architektur. Allgemeine Prompt-Anweisungen halten die Layer nicht zuverlässig zusammen. Was hilft, sind klare Regeln, die Konsist und Detekt gegen die Codebasis prüfen, eine Ausnahmeliste, die nur schrumpfen kann, und dieselben Checks im Agenten-Loop wie in der CI. So landen einfache Architekturfehler gar nicht erst im Review.
Architekturchecks einführen: selbst machen oder Verstärkung holen?
Die ersten Regeln sind schnell aufgeschrieben. Aufwendiger ist es, sie in einem gewachsenen Projekt einzuführen, Altlasten abzubauen, den Agenten-Workflow darauf abzustimmen und das Team mitzunehmen, während der nächste Release-Termin näher rückt.
Genau dafür gibt es OneCode: Senior AI-native Developers aus Deutschland, die mit Android und KMP arbeiten und euer Team temporär verstärken. Sie arbeiten in eurem Repo, in euren Sprints und nach euren Prozessen, und Agentic Coding ist für sie Arbeitsstandard. Die Workflows für Code Review, CI/CD und Testautomatisierung bleiben danach bei eurem Team.
Im kostenlosen Erstgespräch schildert ihr euer Projekt und euren Engpass und bekommt eine erste Einschätzung, wo Agentic Coding in eurem Stack am meisten bringt.
Häufige Fragen
Warum reicht eine Clean-Architecture-Anweisung im Prompt nicht?
Weil sie zu allgemein ist und vom Agenten nicht immer gleich interpretiert wird. Ein technischer Check liefert dagegen einen konkreten Fehler, den der Agent gezielt korrigieren kann.
Was ist der Unterschied zwischen Konsist und Detekt?
Konsist prüft Architekturregeln, also welche Klassen, Module und Packages voneinander abhängen dürfen. Detekt findet Qualitätsprobleme im Kotlin-Code, etwa sehr große Funktionen oder unnötige Verschachtelungen.
Wie geht man mit Ausnahmen von einer Konsist-Regel um?
Über eine Ausnahmeliste, in der jeder Eintrag begründet ist. Ein zweiter Test schlägt fehl, sobald ein Eintrag nicht mehr gebraucht wird, damit die Liste nur schrumpfen kann.
Wie lange dauert es, eine Detekt-Baseline abzubauen?
In unserem KMP-Projekt mit rund 40 Modulen ging die Baseline in zwei Tagen von 558 Einträgen auf null. Den größten Teil erledigten eine angepasste Konfiguration und mechanische Fixes, nur 43 Funde erforderten echte Zerlegung von Code.
Prüfen Detekt und Konsist in KMP auch den iOS-Code?
Sie prüfen den Kotlin-Quelltext in iosMain, auch auf einem Linux-Runner. Ob iOS tatsächlich baut, zeigt das nicht. Dafür braucht es einen zusätzlichen CI-Job auf macOS.
Gelten die Checks nur für Code vom Agenten?
Nein. Dieselben Checks laufen lokal und in der CI, damit für generierten und handgeschriebenen Code dieselben Grenzen gelten.




