AI-Gestuurde Code Review: Sneller, Consistenter, Minder Gedoe

Pull requests die dagenlang open staan. Reviewers die dezelfde nitpicks herhalen over formatting en naamgeving. Ondertussen blijft de echte architectuurvraag onbesproken omdat iedereen al moe is van de discussie over tabs versus spaces. Klinkt bekend?

Code review is essentieel, maar het schaalt niet. Bij groeiende teams wordt het een bottleneck. AI-gestuurde review tools pakken precies dat probleem aan.

Wat AI Wél en Niet Kan Reviewen

Even realistische verwachtingen scheppen. AI excelleert in patroonherkenning en consistentie. Het vindt moeiteloos:

• Security vulnerabilities zoals SQL injection of hardcoded secrets
• Performance anti-patterns (N+1 queries, onnodige loops)
• Afwijkingen van coding standards
• Ontbrekende of incorrecte typings
• Dead code en ongebruikte imports

Wat lastiger ligt: architectuurbeslissingen, business logic validatie, of de vraag of een bepaalde abstactie wel zin heeft. Daar blijft menselijk oordeel nodig.

Integratie in de CI Pipeline

De meeste teams starten met een simpele GitHub Action of GitLab CI job. Het basisprincipe: laat AI de diff analyseren voordat menselijke reviewers ernaar kijken.

# .github/workflows/ai-review.yml
name: AI Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      
      - name: Get changed files
        id: changed
        run: |
          echo "files=$(git diff --name-only origin/${{ github.base_ref }}...HEAD | tr '\n' ' ')" >> $GITHUB_OUTPUT
      
      - name: Run AI analysis
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        run: |
          for file in ${{ steps.changed.outputs.files }}; do
            if [[ $file == *.ts || $file == *.js ]]; then
              ./scripts/ai-review.sh "$file"
            fi
          done
      
      - name: Post review comments
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const comments = JSON.parse(fs.readFileSync('review-comments.json'));
            for (const comment of comments) {
              await github.rest.pulls.createReviewComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                pull_number: context.issue.number,
                body: comment.body,
                path: comment.path,
                line: comment.line
              });
            }

Het Review Script

Hier wordt het interessant. De kwaliteit van AI-feedback hangt volledig af van hoe de prompt is opgebouwd. Een generieke "review deze code" geeft waardeloze output. Specifieke instructies werken beter.

#!/bin/bash
# scripts/ai-review.sh

FILE=$1
CONTENT=$(cat "$FILE")

# Haal alleen gewijzigde regels op voor context
DIFF=$(git diff origin/main...HEAD -- "$FILE")

curl -s https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d @- << EOF >> review-comments.json
{
  "model": "gpt-4",
  "messages": [
    {
      "role": "system",
      "content": "Je bent een senior developer die code reviewt. Focus op: 1) Security issues 2) Performance problemen 3) Type safety. Negeer styling - daar is linting voor. Geef output als JSON array met {path, line, body} objecten. Wees specifiek en actionable."
    },
    {
      "role": "user", 
      "content": "Review deze wijzigingen:\n\nFile: $FILE\n\nDiff:\n$DIFF\n\nVolledige context:\n$CONTENT"
    }
  ],
  "temperature": 0.3
}
EOF

De lage temperature is bewust. Bij code review wil niemand creatieve interpretaties — consistente, voorspelbare feedback werkt beter.

Resultaten Filteren

Niet alle AI-suggesties zijn zinvol. Een filterlaag voorkomt dat reviewers overspoeld worden met ruis.

interface ReviewComment {
  path: string;
  line: number;
  body: string;
  severity: 'critical' | 'warning' | 'suggestion';
  confidence: number;
}

function filterComments(comments: ReviewComment[]): ReviewComment[] {
  return comments
    .filter(c => c.confidence > 0.7)
    .filter(c => {
      // Skip bekende false positives
      const falsePositivePatterns = [
        /consider using const/i,
        /variable naming/i
      ];
      return !falsePositivePatterns.some(p => p.test(c.body));
    })
    .sort((a, b) => {
      const severityOrder = { critical: 0, warning: 1, suggestion: 2 };
      return severityOrder[a.severity] - severityOrder[b.severity];
    });
}

Kosten en Performance

Een veelgestelde vraag: wat kost dit? Hier een ruwe indicatie gebaseerd op een middelgroot project met ~50 PRs per week:

Metric	Waarde
Gemiddelde diff grootte	~200 regels
Tokens per review	~3000
Kosten per PR (GPT-4)	€0.15 - €0.30
Maandelijkse kosten	~€60
Tijdsbesparing per PR	15-30 minuten

Die €60 per maand verdient zich terug in de eerste week. Reviewers besteden minder tijd aan triviale feedback en meer aan architectuurdiscussies die er toe doen.

Valkuilen

Een paar dingen om op te letten:

Over-reliance. Teams die blind AI-suggesties accepteren zonder na te denken. De tool is een assistent, geen vervanger.

Context verlies. AI ziet alleen de diff, niet de bredere codebase. Soms suggereert het iets dat elders al anders is opgelost.

Alert fatigue. Te veel comments per PR en mensen negeren ze allemaal. Begin streng gefilterd en versoepl later.

Volgende Stappen

Start klein. Eén repository, alleen security checks. Meet hoeveel issues het vindt die anders door de review heen waren geglipt. Breid uit als het waarde bewijst.

De tooling evolueert snel. Wat vorig jaar nog custom scripts vereiste, zit nu ingebouwd in platforms. Maar het basisprincipe blijft: laat machines doen waar machines goed in zijn, zodat mensen zich kunnen focussen op de lastige beslissingen.