# We vroegen een AI-reviewer wat hij in Kotlin controleert. Beveiliging ontbrak

> Open Code Review 1.13.11 beoordeelt Kotlin met een checklist van 683 woorden zonder één regel over beveiliging. Een SQL-bestand krijgt vier vragen. Eén regel configuratie lost het op.

2026-11-17 · Mardi Gras Developers

Over het opbouwen van strings in Kotlin krijgt Alibaba's AI-reviewer precies één aanwijzing mee: gebruik string templates. De Kotlin-checklist is 683 woorden lang en eindigt zo:

```console
$ ocr rules check src/main/kotlin/shop/OrderService.kt
Pattern: **/*.{kt,kts}
[…]
- **Immutability**: Prefer `val` over `var`.
- **String handling**: Use string templates (`"Value: $value"`) instead of concatenation.
```

Nergens in die 683 woorden staat dat een template in een SQL-string het begin van een injectie is. Over invoervalidatie, toegangscontrole of geheimen staat er ook niets. In hetzelfde project wordt de Dockerfile beoordeeld met de vraag "Is permission validation complete?".

**0 van 683** woorden over beveiliging in de checklist die een AI-reviewer bij een Kotlin-bestand krijgt

## Wat dat betekent in een pull request

Neem twee versies van dezelfde functie. Dit is ons eigen voorbeeld en geen uitvoer van de tool:

```kotlin
// Voldoet aan elk punt van de ingebouwde Kotlin-checklist: geen !!, geen var, een string template.
fun findOrders(status: String) =
    jdbc.queryForList("SELECT * FROM orders WHERE status = '$status'")

// Waar een regel over beveiliging om zou vragen: een gebonden parameter.
fun findOrders(status: String) =
    jdbc.queryForList("SELECT * FROM orders WHERE status = ?", status)
```

De eerste versie zet invoer uit het request rechtstreeks in de query. We hebben er geen model op losgelaten, dus we weten niet of de reviewer het toch zou melden. We weten wel dat niets in zijn instructies erom vraagt, en dat de enige aanwijzing over strings de andere kant op wijst.

## Waarom we dit uitzochten

[Open Code Review](https://github.com/alibaba/open-code-review) kreeg er op 17 november 951 sterren bij en die week 3.056, volgens de [trendinglijst van GitHub](https://github.com/trending?since=daily). Het is een commandlinetool in Go onder de Apache-2.0-licentie. Volgens de README begon het als de interne reviewer van Alibaba. De beschrijving van de repository belooft een "built-in multi-language ruleset (NPE, thread-safety, XSS, SQL injection)".

De helft van de tool is gewone code. Voordat er een model wordt aangeroepen, bepaalt die welke gewijzigde bestanden beoordeeld worden en welke regeltekst bij elk bestand hoort. Dat deel draait zonder API-sleutel en is dus te meten. Wij bouwen backends in Kotlin en Java, dus wilden we weten wat een team als het onze op de eerste dag krijgt.

## Wat we deden

We downloadden de binary van release 1.13.11 (59 MB, checksum gecontroleerd) in een container en maakten een voorbeeldproject van 17 bestanden: een kleine orderservice in Kotlin en Java met tests, een MyBatis-mapper, een SQL-migratie, een Dockerfile, Terraform, een Flutter-scherm, een Vue-pagina en een GitHub-workflow. Daarna stelden we met `ocr delegate preview` en `ocr rules check` drie vragen: welke bestanden worden beoordeeld, welke checklist krijgt elk bestand, en wat verandert een regelbestand in het project? Er is geen model aangeroepen. Het script en de volledige uitvoer staan in de repository van deze site.

## Twee bestanden, twee checklists

| De reviewer krijgt een vraag over | `OrderService.kt` | `V2__add_status.sql` |
| --- | --- | --- |
| Checklist | Kotlin-regel, 683 woorden | Terugvalregel, 101 woorden |
| SQL-injectie en XSS | Nee | Ja |
| Omgang met gevoelige gegevens | Nee | Ja |
| Controle van rechten | Nee | Ja |
| `val` in plaats van `var` | Ja | Nee |
| `GlobalScope` in coroutines | Ja | Nee |
| `@JvmStatic` voor aanroepen vanuit Java | Ja | Nee |

Voor wat ze behandelt is de Kotlin-checklist goed: null safety, coroutines, resources afsluiten met `use`. Het is een gids voor stijl en correctheid, en dat is wat het model ontvangt. Voor Java geldt hetzelfde, met 461 woorden over typfouten, dode code, logische fouten, performance en thread safety.

Per checklist telden we de regels waarin een van zes termen voorkomt: injection, XSS, security, vulnerab, sensitive, permission.

_Figure: Een SQL-migratie krijgt vier regels over beveiliging in haar checklist. Java en Kotlin krijgen er geen._

Juist de bestanden waar de tool het minst van weet, krijgen de terugvalchecklist. En daar staat beveiliging wel in:

```console
$ ocr rules check src/main/resources/db/migration/V2__add_status.sql
Pattern: default
[…]
#### Security
Are there security vulnerabilities such as SQL injection or XSS?
Is sensitive information handled correctly?
Is permission validation complete?
```

Van de 66 ingebouwde regelbestanden bevatten er 23 geen van de zes termen. Dat is een telling op trefwoorden en die telt te laag: de regel voor C heeft een onderdeel "Buffer Overflow Protection" en scoort nul. De teksten voor Java en Kotlin hebben we helemaal gelezen, dus die twee nullen kloppen.

## Waarom een taalregel de beveiligingsvragen weghaalt

De koppeling staat in [`system_rules.json`](https://github.com/alibaba/open-code-review/blob/v1.13.11/internal/config/rules/system_rules.json): 67 globpatronen die elk naar één regelbestand wijzen, plus `default.md`. De code in [`system_rules.go`](https://github.com/alibaba/open-code-review/blob/v1.13.11/internal/config/rules/system_rules.go) loopt de patronen in volgorde af en geeft de eerste match terug. De standaardregel wordt alleen gebruikt als niets past. Een taalregel vervangt de standaardregel dus en vult die niet aan. Een taalregel vraagt alleen naar beveiliging als de schrijver dat erin heeft gezet. In de regels voor Go, PHP en TypeScript staat het. In die voor Java en Kotlin staat het niet.

_Figure: De eerste regel die past wint, dus een Java-bestand krijgt de terugvalchecklist met de vraag over injectie nooit te zien._

De gevonden tekst komt in de prompt onder het kopje "Review Checklist". In de systeemprompt van de hoofdtaak komt het woord security in deze release ook niet voor. Een model kan een injectie die het toevallig ziet nog steeds melden, en de planningsprompt omschrijft hoge ernst als "May cause security vulnerabilities, data loss, system crashes, or critical functional failures". Maar de README verdedigt het ontwerp zelf met het argument dat de regels "the model's attention sharply focused" houden, en zegt erbij dat de recall lager is dan bij een algemene agent: "a deliberate trade-off favoring precision over noise". Een checklist die het model op spelling en dode code richt, richt het van de rest af.

## Wat de preview verder liet zien

```console
$ ocr delegate preview --commit HEAD
[…]
~~- `docs/README.md` [added] +2/-0 (excluded: unsupported_ext)~~
[…]
~~- `package-lock.json` [added] +1/-0 (excluded: default_path)~~
[…]
~~- `src/test/java/shop/PriceCalculatorTest.java` [added] +7/-0 (excluded: default_path)~~
~~- `src/test/kotlin/shop/OrderServiceTest.kt` [added] +12/-0 (excluded: default_path)~~
```

Dertien van de 17 bestanden worden beoordeeld, en het antwoord kwam in 0,038 seconde. Dat de lockfile wegvalt is verstandig. Dat beide testbestanden wegvallen moet je weten: een pull request die een assertion verwijdert, wordt niet bekeken. De tweede verrassing is `build.gradle.kts`. Dat bestand past op het Kotlin-patroon, dus het buildscript wordt beoordeeld met 683 woorden over coroutines en data classes. Een `build.gradle` in Groovy krijgt een regel van 30 woorden over afhankelijkheden.

## De configuratie die we getest hebben

De [documentatie](https://github.com/alibaba/open-code-review/blob/v1.13.11/pages/src/content/docs/en/review-rules.md) van het project beschrijft de oplossing, en die werkt. Zet je eigen checklist in de repository en laat die bij elk bestand samenvoegen met de ingebouwde regel:

```json
{
  "rules": [
    { "path": "**/*", "rule": ".opencodereview/security.md", "merge_system_rule": true }
  ],
  "include": ["**/src/test/**"]
}
```

Onze `security.md` had vier regels: gebonden parameters in SQL, validatie van invoer die in een pad, een commando of een redirect belandt, een toegangscontrole op elk endpoint, en geen geheimen of persoonsgegevens in logs. Met dit bestand groeit de Java-checklist van 461 naar 530 woorden, blijft het ingebouwde deel staan en meldt de preview 15 van de 17 bestanden, omdat de tests weer meedoen:

```console
src/main/java/shop/PriceCalculator.java | **/* | 530 | 1
src/main/kotlin/shop/OrderService.kt | **/* | 752 | 1
src/test/kotlin/shop/OrderServiceTest.kt | **/* | 752 | 1
```

Let op de vlag. Die staat standaard uit, en zonder vlag vervangt jouw regel de ingebouwde. Ook dat hebben we gedraaid: dezelfde regel zonder `merge_system_rule` bracht de Java-checklist van 461 woorden terug naar 60. Je hebt dan beveiliging toegevoegd en ongemerkt de controles op thread safety en logica verwijderd.


Draai `ocr rules check` op één bestand per taal in je repository en lees wat eruit komt. Je hebt er geen API-sleutel voor nodig en je ziet precies waar de reviewer naar moet kijken.


## Wat wij zouden doen

Wij zouden deze tool op een codebase in Kotlin of Java alleen proberen met een eigen regelbestand vanaf de eerste dag, en we zouden de standaardreview niet als beveiligingsreview meetellen. Zonder configuratie is het voor JVM-code een reviewer voor correctheid, performance en concurrency. Dat is nuttig, en het is iets anders dan de beschrijving van de repository doet verwachten.

Twee dingen zouden dit oordeel veranderen: een onderdeel over beveiliging in `java.md` en `kotlin.md`, of gepubliceerde recallcijfers per taal en per soort fout.

## Grenzen van deze test

We hebben de instructies gemeten en niet de bevindingen. Er is geen model aangeroepen, dus we weten niet hoeveel beveiligingsfouten de standaardinstelling in de praktijk mist. Het gaat om één versie (1.13.11, commit 0f5a284), één verzonnen voorbeeldproject van 17 bestanden en een telling van zes trefwoorden in de regelteksten. De benchmarkcijfers in de README zijn van de maker zelf en hebben we niet gereproduceerd.

## Sources

- [alibaba/open-code-review](https://github.com/alibaba/open-code-review)
- [system_rules.json op v1.13.11: welk regelbestand elk pad krijgt](https://github.com/alibaba/open-code-review/blob/v1.13.11/internal/config/rules/system_rules.json)
- [system_rules.go op v1.13.11: eerste match wint, merge_system_rule](https://github.com/alibaba/open-code-review/blob/v1.13.11/internal/config/rules/system_rules.go)
- [kotlin.md op v1.13.11: de ingebouwde Kotlin-checklist](https://github.com/alibaba/open-code-review/blob/v1.13.11/internal/config/rules/rule_docs/kotlin.md)
- [java.md op v1.13.11: de ingebouwde Java-checklist](https://github.com/alibaba/open-code-review/blob/v1.13.11/internal/config/rules/rule_docs/java.md)
- [Review Rules, de documentatie van het project](https://github.com/alibaba/open-code-review/blob/v1.13.11/pages/src/content/docs/en/review-rules.md)
- [GitHub Trending, dagelijks, 17 november 2026](https://github.com/trending?since=daily)

---
Source: https://mg-devs.nl/blog/ai-code-reviewer-java-kotlin-checklist-zonder-beveiliging/
