AI Code Review voor Rails: Tools en Workflows die Echt Bugs Vinden

AI code review tools vinden echte bugs in Rails projecten — N+1 queries, ontbrekende autorisatiechecks, onveilig params gebruik — maar alleen als je ze correct configureert. De meeste teams schakelen een AI reviewer in, worden overspoeld met ruis en zetten het binnen een week weer uit.

Deze gids beschrijft wat werkt na zes maanden AI-geassisteerde review op productie Rails 8 codebases: welke tools je moet gebruiken, hoe je ze configureert en de specifieke prompt patronen die nuttige feedback opleveren in plaats van pedante stijlklachten.

Het Huidige Tool Landschap

Er bestaan drie categorieën AI code review tools voor Rails projecten in 2026:

IDE-geïntegreerde reviewers zoals GitHub Copilots code review functie (gelanceerd eind 2024, nu stabiel) analyseren pull requests direct in GitHub. Je schakelt het in via repository instellingen onder Code Review > Copilot. Het draait automatisch op nieuwe PRs en plaatst inline opmerkingen.

API-gebaseerde reviewers waarbij je diffs naar Claude, GPT-4 of vergelijkbare modellen stuurt via je CI pipeline. Dit geeft je volledige controle over prompts en context, maar vereist meer setup.

Dedicated platforms zoals CodeRabbit, Sourcery en Codium die AI modellen combineren met Rails-specifieke heuristieken. Deze zitten tussen de andere twee benaderingen — minder aanpasbaar dan directe API calls, maar minder werk dan zelf een pipeline bouwen.

Voor Rails projecten specifiek heeft de API-gebaseerde aanpak met Claude in mijn ervaring de beste resultaten opgeleverd. De reden: Rails conventies zijn enorm belangrijk voor het vinden van echte problemen, en generieke AI reviewers missen framework-specifieke problemen zoals onveilige before_action volgorde of ontbrekende Strong Parameters op geneste attributen.

Claude-Based Review Instellen in GitHub Actions

Hier is een werkende GitHub Actions workflow die PR diffs naar Claude stuurt voor review:

# .github/workflows/ai-review.yml
name: AI Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
      contents: read
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Get diff
        id: diff
        run: |
          git diff origin/$...HEAD -- '*.rb' '*.erb' > diff.txt
          echo "size=$(wc -c < diff.txt)" >> $GITHUB_OUTPUT

      - name: AI Review
        if: steps.diff.outputs.size > 0
        env:
          ANTHROPIC_API_KEY: $
        run: |
          ruby scripts/ai_review.rb diff.txt > review.md

      - name: Post Review
        if: steps.diff.outputs.size > 0
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const body = fs.readFileSync('review.md', 'utf8');
            if (body.trim().length > 0) {
              github.rest.pulls.createReview({
                owner: context.repo.owner,
                repo: context.repo.repo,
                pull_number: context.issue.number,
                body: body,
                event: 'COMMENT'
              });
            }

Het Ruby script voor de daadwerkelijke review:

# scripts/ai_review.rb
require "net/http"
require "json"

diff = File.read(ARGV[0])

if diff.bytesize > 150_000
  diff = diff.byteslice(0, 150_000)
  diff += "\n\n[diff truncated]"
end

prompt = <<~PROMPT
  You are reviewing a Ruby on Rails pull request. The codebase uses Rails 8.0, Ruby 3.3, and PostgreSQL.

  Review this diff for:
  1. Security issues (SQL injection, XSS, mass assignment, missing authorization)
  2. N+1 queries or missing eager loading
  3. Missing database indexes for new queries
  4. Incorrect ActiveRecord usage
  5. Missing error handling for external service calls
  6. Race conditions in concurrent scenarios

  Do NOT comment on:
  - Code style or formatting (RuboCop handles that)
  - Test coverage (separate CI step)
  - Minor naming preferences

  For each issue found, specify the file, line range, severity (critical/warning/info), and a specific fix.
  If the diff looks clean, say "No issues found" and nothing else.

  DIFF:
  #{diff}
PROMPT

uri = URI("https://api.anthropic.com/v1/messages")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request["x-api-key"] = ENV["ANTHROPIC_API_KEY"]
request["anthropic-version"] = "2023-06-01"
request["content-type"] = "application/json"
request.body = JSON.generate({
  model: "claude-sonnet-4-20250514",
  max_tokens: 4096,
  messages: [{role: "user", content: prompt}]
})

response = http.request(request)
result = JSON.parse(response.body)

puts result.dig("content", 0, "text") || "Review failed: #{response.code}"

Wat AI Review Daadwerkelijk Vindt (Met Echte Voorbeelden)

Na het draaien hiervan op meerdere Rails projecten, zijn dit de categorieën waar AI review consistent waarde toevoegt:

Ontbrekende autorisatiechecks. Wanneer een ontwikkelaar een nieuwe controller actie toevoegt en before_action :authenticate_user! of een Pundit authorize call vergeet, signaleert AI review dit in ongeveer 90% van de gevallen. Dit is de meest waardevolle vangst.

# AI signaleerde dit — nieuwe actie zonder autorisatie
class InvoicesController < ApplicationController
  def export
    @invoices = Invoice.where(date: params[:from]..params[:to])
    send_data @invoices.to_csv, filename: "invoices.csv"
  end
end

De AI identificeerde correct dat export was toegevoegd aan een controller waar elke andere actie authorize @invoice calls had, en deze miste zowel authenticatie als autorisatie.

Onveilige parameter handling. Vooral met geneste attributen, waar ontwikkelaars de parent permitten maar vergeten geneste IDs te whitelisten:

# AI ving de ontbrekende :id op in reject_if
def project_params
  params.require(:project).permit(:name, :budget,
    tasks_attributes: [:title, :description, :_destroy])
    # Ontbrekende :id — bestaande taken kunnen niet worden
    # bijgewerkt, alleen aangemaakt/verwijderd
end

N+1 queries verborgen in partials. Wanneer een PR een associatie-aanroep toevoegt in een partial die in een collectie wordt gerenderd, vangt AI review dit op als de diff zowel de partial wijziging als de aanroepende view bevat.

Ontbrekende database indexes. Wanneer een migratie een kolom toevoegt en een apart bestand op die kolom query’t, legt de AI het verband in ongeveer 70% van de gevallen:

# Migratie voegt user_uuid kolom toe
add_column :audit_logs, :user_uuid, :string

# Model query't erop — AI signaleert ontbrekende index
scope :for_user, ->(uuid) { where(user_uuid: uuid) }

Het False Positive Probleem

Verwacht een false positive rate van ruwweg 30-40% bij een goed afgestelde setup. De hoofdcategorieën:

Context-afhankelijke patronen. De AI suggereert find_each wanneer je each gebruikt op een scope die maximaal 10 records retourneert. Het weet niets van je datavolumes.

Framework magie. Rails concerns, included blokken en STI hiërarchieën verwarren AI reviewers. Een before_action gedefinieerd in een concern wordt gesignaleerd als ontbrekend wanneer de AI niet kan zien dat de concern is geïncludeerd.

Bewuste tradeoffs. Soms sla je eager loading over omdat de associatie al gecached is vanuit een parent query.

De oplossing: onderhoud een .ai-review-ignore bestand in je repo met patronen om te onderdrukken:

# .ai-review-ignore
suppress:
  - pattern: "find_each suggestion"
    paths: ["app/admin/**"]
  - pattern: "missing eager load"
    paths: ["app/models/concerns/**"]

Integratie Met Bestaande CI

AI review werkt het beste als één laag in een review stack, niet als vervanging:

1. RuboCop — stijl en lint (snel, deterministisch)
2. Brakeman — security statische analyse (snel, Rails-specifiek)
3. AI Review — semantische analyse (langzaam, probabilistisch)
4. Menselijke Review — architectuur, business logic, teamkennis

Draai AI review parallel met je test suite. Een typische PR krijgt AI feedback in 15-30 seconden voor diffs onder 500 regels, wat sneller is dan de meeste test suites.

Qua kosten kost het reviewen van 20 PRs per dag met Claude Sonnet ongeveer €3-5/maand. Dat is goedkoper dan één gemiste security kwetsbaarheid die productie bereikt.

Prompt Engineering voor Rails-Specifieke Review

De generieke “review deze code” prompt levert generieke feedback op. Deze toevoegingen verbeterden de signaal kwaliteit aanzienlijk:

Voeg je Gemfile.lock toe als context. Niet het geheel — alleen de Rails versie en belangrijke gems. Dit voorkomt dat de AI gems suggereert die je al gebruikt.

Specificeer je auth systeem. “Dit project gebruikt Devise met Pundit voor autorisatie” elimineert 80% van auth-gerelateerde false positives.

Verwijs naar je database. “PostgreSQL 16 met pgvector extensie” voorkomt dat de AI MySQL-specifieke oplossingen suggereert.

Stel de Rails versie expliciet in. Rails 7 vs Rails 8 verandert best practices significant. Solid Queue verving Sidekiq als default, Solid Cache verving Redis — de AI moet weten in welk tijdperk je zit.

Wanneer AI Review het Niet Waard Is

Sla AI review over voor:

• Solo projecten waar je de enige reviewer bent (gebruik gewoon Copilot inline suggesties tijdens het coderen)
• Grote refactors die honderden bestanden wijzigen — de AI verdrinkt in context
• Configuratie-only PRs (Dockerfiles, CI configs, infrastructure)
• Dependency updates — Dependabot PRs profiteren niet van AI review; je test suite is daar de poortwachter

FAQ

Hoeveel kost AI code review per maand?

Voor een team van 5 ontwikkelaars die ~100 PRs per maand mergen, verwacht €15-25/maand met Claude Sonnet via API. GitHub Copilots ingebouwde review zit inbegrepen in het $19/maand Copilot Individual plan of $39/maand Copilot Business plan. Dedicated platforms zoals CodeRabbit rekenen $12-24/seat/maand.

Kan AI code review menselijke reviewers vervangen?

Nee. AI vangt mechanische problemen — ontbrekende indexes, N+1 queries, security oversights — maar kan geen architectuurbeslissingen, business logic correctheid of de vraag of code het juiste probleem oplost evalueren. Gebruik het om de saaie checklist items af te handelen zodat menselijke reviewers zich op ontwerp en intentie kunnen richten.

Werkt AI code review met GitHub Enterprise en private repos?

Ja. De GitHub Actions aanpak die hier wordt getoond draait volledig binnen je CI omgeving. Je code bereikt de API van de AI provider, dus controleer het databeleid van je organisatie. Anthropic en OpenAI bieden beide zero-retention API opties voor enterprise klanten. Self-hosted opties bestaan via Ollama met modellen als CodeLlama, hoewel de kwaliteit aanzienlijk daalt.

Wat is het beste model voor Rails code review in 2026?

Claude Sonnet (momenteel claude-sonnet-4-20250514) biedt de beste balans van kosten, snelheid en Rails kennis voor code review. Claude Opus levert marginaal betere resultaten maar tegen 5x de kosten en 3x de latency — niet de moeite waard voor geautomatiseerde PR review.

Hoe ga je om met gevoelige code die je netwerk niet mag verlaten?

Draai een lokaal model via Ollama of vLLM. CodeLlama 34B en DeepSeek Coder V2 zijn de beste open-source opties voor Ruby review, hoewel geen van beide de Rails-specifieke kennis van Claude evenaren. Voor de middenweg bieden Anthropic en AWS Claude aan op Bedrock met VPC endpoints, waardoor verkeer binnen je AWS account blijft.