Vorige maand mergte een collega een PR met een subtiele bug. Een async method die Task returnde in plaats van Task<T>, waardoor de return value stil werd weggegooid. Twee reviewers hadden het goedgekeurd. De build was groen. De tests passeerden. Pas in productie, toen een bestelling verdween, vonden we het.

Het is precies het soort fout dat een mens over het hoofd ziet — maar dat een AI-reviewer bij de eerste scan oppikt.

Claude Code buiten je terminal

Je kent Claude Code waarschijnlijk als interactieve tool. Je typt een vraag, het leest je code, het stelt wijzigingen voor. Maar Claude Code heeft ook een non-interactive modus die perfect past in een CI/CD-pipeline.

De sleutel is de -p flag (print mode). Hiermee kun je een prompt pipen naar Claude Code en krijg je het antwoord op stdout terug. Geen interactie, geen editor — puur tekst in, tekst uit.

claude -p "Review de gewijzigde bestanden in deze PR op bugs en security issues"

De exit code is 0 bij succes, non-zero bij fouten. Dat betekent dat je het kunt gebruiken als een stap in je pipeline die de build kan laten falen.

Combineer dit met git diff en je hebt een AI-reviewer die precies weet welke bestanden zijn gewijzigd:

git diff origin/main --name-only -- '*.cs' | \
  xargs -I {} claude -p "Review dit bestand op bugs, security issues en .NET best practices: {}"

GitHub Actions: een complete workflow

Hier is een GitHub Actions workflow die Claude Code draait op elke PR naar main. Het reviewt alleen de gewijzigde C#-bestanden, zodat je geen tokens verspilt aan ongewijzigde code.

name: Claude Code Review

on:
  pull_request:
    branches: [main]
    paths: ['**.cs']

jobs:
  claude-review:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
      contents: read

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code

      - name: Get changed files
        id: changed
        run: |
          FILES=$(git diff origin/main --name-only -- '*.cs' | tr '\n' ' ')
          echo "files=$FILES" >> "$GITHUB_OUTPUT"

      - name: Claude review
        if: steps.changed.outputs.files != ''
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          REVIEW=$(claude -p "Je bent een .NET code reviewer. \
            Review de volgende gewijzigde bestanden op: \
            1. Bugs en logische fouten \
            2. Security issues \
            3. Naming conventions (.NET standaard) \
            4. Async/await correctheid \
            5. Null reference risico's \
            \
            Bestanden: ${{ steps.changed.outputs.files }} \
            \
            Geef alleen bevindingen. Als alles er goed uitziet, zeg dat.")

          echo "$REVIEW"

      - name: Post review comment
        if: steps.changed.outputs.files != ''
        uses: actions/github-script@v7
        with:
          script: |
            const body = `## 🤖 Claude Code Review\n\n${process.env.REVIEW}`;
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: body
            });
        env:
          REVIEW: ${{ steps.changed.outputs.files != '' && 'See logs' || 'No C# files changed' }}

De workflow doet vier dingen: checkout met volledige history (nodig voor git diff), installeer Claude Code, bepaal welke .cs-bestanden zijn gewijzigd, en laat Claude ze reviewen. Het resultaat wordt als comment op de PR gepost.

Azure DevOps: hetzelfde idee

Als je team op Azure DevOps werkt, is het principe identiek. Alleen de YAML-syntax verschilt.

trigger: none

pr:
  branches:
    include:
      - main

pool:
  vmImage: 'ubuntu-latest'

steps:
  - checkout: self
    fetchDepth: 0

  - task: NodeTool@0
    inputs:
      versionSpec: '20.x'

  - script: npm install -g @anthropic-ai/claude-code
    displayName: 'Install Claude Code'

  - script: |
      FILES=$(git diff origin/main --name-only -- '*.cs' | tr '\n' ' ')
      if [ -n "$FILES" ]; then
        claude -p "Review deze .NET bestanden op bugs, security en conventions: $FILES"
      fi
    displayName: 'Claude Code Review'
    env:
      ANTHROPIC_API_KEY: $(ANTHROPIC_API_KEY)

Sla je API key op als secret variable in je pipeline. Verder werkt het hetzelfde.

Wat laat je reviewen?

De kracht zit in de prompt. Je kunt Claude Code heel gericht inzetten. Een paar suggesties die goed werken voor .NET-teams:

Security checks. Laat Claude zoeken naar hardcoded connection strings, ontbrekende [Authorize]-attributen op controllers, SQL injection risico’s in raw queries, en gevoelige data in log statements.

Naming conventions. Volgt de code de .NET naming guidelines? PascalCase voor publieke members, camelCase voor parameters, geen Hongaarse notatie? Claude pikt dit moeiteloos op.

Async correctheid. Een van de lastigste categorien bugs in .NET. Task vs. Task<T>, ontbrekende await, async void methods die niet event handlers zijn. Precies waar die bug van mijn collega vandaan kwam.

Test coverage gaps. Stuur Claude de gewijzigde code en de bijbehorende tests, en vraag of er edge cases ontbreken. Het is verrassend goed in het vinden van scenario’s waar je niet aan hebt gedacht.

Migration safety. Bij Entity Framework-migraties: check of een migratie data kan vernietigen. Een DropColumn op een kolom met data? Claude waarschuwt je.

Eerlijke beperkingen

Dit is geen magische oplossing. Er zijn reele nadelen waar je rekening mee moet houden.

Kosten. Elke run kost API-tokens. Bij een groot project met veel PRs per dag loopt dit op. Beperk de review tot gewijzigde bestanden en stel een max token limit in. Reken op een paar cent tot een paar dollar per review, afhankelijk van de omvang.

Token limits bij grote PRs. Als iemand dertig bestanden wijzigt in een PR, kan de context te groot worden. Splits je review op per bestand of beperk het tot de bestanden met de meeste wijzigingen.

Niet-deterministisch. Dezelfde code kan bij twee runs een andere review opleveren. Soms vindt Claude iets, soms niet. Behandel het als een extra paar ogen, niet als een deterministische linter.

Geen vervanging voor menselijke review. Claude vangt bugs, maar oordeelt niet over architectuur, business logica of teamafspraken die nergens gedocumenteerd staan. Het is een aanvulling op code review, geen vervanging.

False positives. Claude kan opmerkingen maken over code die bewust zo is geschreven. Je team moet leren om de AI-review te behandelen als suggesties, niet als bevelen.

Begin hier

Kies het platform waar je team al op zit — GitHub Actions of Azure DevOps — en maak een pipeline die Claude Code draait op PRs. Begin simpel: alleen gewijzigde .cs-bestanden, een generieke review-prompt.

Draai het een week op een actief project. Kijk welke opmerkingen waardevol zijn en welke ruis. Verfijn je prompt op basis van wat je team nodig heeft.

De beste CI/CD-stap is er een die issues vindt die je reviewers zouden missen, zonder dat het hun workflow verstoort. Claude Code kan dat zijn — als je het gericht inzet en realistisch blijft over wat het wel en niet kan.