AI Code Generation in de Praktijk: Wat Werkt en Wat Niet

De hype rond AI code generation is inmiddels wat afgekoeld. Mooi. Want nu kunnen we er nuchter naar kijken — wat levert het daadwerkelijk op in een dagelijkse development workflow?

De realiteit van gegenereerde code

Laten we eerlijk zijn: AI-gegenereerde code is niet magisch. Het is patroonherkenning op steroïden. Dat betekent dat repetitieve taken er enorm van profiteren, terwijl complexe business logic nog steeds mensenwerk blijft.

Een concreet voorbeeld. Stel, er moet een REST endpoint komen voor een standaard CRUD-operatie:

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IProductRepository _repository;

    public ProductsController(IProductRepository repository)
    {
        _repository = repository;
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<Product>> GetById(int id)
    {
        var product = await _repository.GetByIdAsync(id);
        if (product == null) return NotFound();
        return Ok(product);
    }

    [HttpPost]
    public async Task<ActionResult<Product>> Create(
        [FromBody] CreateProductRequest request)
    {
        var product = new Product
        {
            Name = request.Name,
            Price = request.Price,
            Category = request.Category
        };

        await _repository.AddAsync(product);
        return CreatedAtAction(
            nameof(GetById),
            new { id = product.Id },
            product);
    }
}

Dit soort boilerplate? Daar blinkt AI code generation in uit. De structuur is voorspelbaar, het patroon komt duizenden keren voor in trainingsdata, en het resultaat is bruikbaar.

Waar het wél goed werkt

Unit tests genereren. Geef een functie als input en laat de AI testcases bedenken. Vaak komen er edge cases uit die anders over het hoofd worden gezien. Niet alle tests zijn perfect, maar het startpunt scheelt flink.

# Input: een simpele validatiefunctie
def validate_email(email: str) -> bool:
    import re
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(pattern, email))

# Gegenereerde tests (na review en aanpassing)
def test_valid_email():
    assert validate_email("user@example.com") is True

def test_missing_at_sign():
    assert validate_email("userexample.com") is False

def test_empty_string():
    assert validate_email("") is False

def test_special_chars_in_local():
    assert validate_email("user+tag@example.com") is True

def test_double_dot_domain():
    assert validate_email("user@example..com") is False

Database migraties en schema's. Van een beschrijving naar een migration script gaat verrassend soepel. Zeker bij standaard relaties.

Configuratiebestanden. Docker Compose files, CI pipelines, Terraform modules — configuratie met een vast format is ideaal terrein.

Waar het misgaat

De problemen beginnen zodra er domeinkennis nodig is. AI kent jouw businessregels niet. Het weet niet dat klant X een speciale korting krijgt op dinsdag, of dat bepaalde producten niet gecombineerd mogen worden.

Nog een veelvoorkomend probleem: security. Gegenereerde code bevat regelmatig kwetsbaarheden. SQL queries die niet geparametriseerd zijn. API keys die hardcoded staan. Input validatie die ontbreekt.

// Dit soort code komt er regelmatig uit — NIET gebruiken
const query = `SELECT * FROM users WHERE name = '${userName}'`;

// Wat het had moeten zijn
const query = 'SELECT * FROM users WHERE name = $1';
const result = await pool.query(query, [userName]);

Dat tweede voorbeeld is wat elke ervaren developer schrijft. Maar AI kiest nog te vaak voor de eerste variant, zeker bij snelle prompts.

Praktische aanpak

Een workflow die goed blijkt te werken:

1. Genereer de basis. Laat AI het skelet maken — endpoints, models, basis-configuratie.
2. Review alles. Geen uitzondering. Elke regel gegenereerde code wordt gelezen alsof een junior het geschreven heeft.
3. Pas business logic handmatig aan. De kern van je applicatie schrijf je zelf.
4. Laat tests genereren. Na het schrijven van de functie. Check of de edge cases kloppen.
5. Draai security scanning. Tools als Snyk of SonarQube over de gegenereerde code heen.

De juiste verwachtingen

AI code generation vervangt geen developers. Het vervangt typewerk. Dat is een belangrijk verschil. De tijdwinst zit in het niet hoeven typen van boilerplate, niet in het niet hoeven nadenken over architectuur.

Teams die er het meeste uithalen behandelen het als een slimme autocomplete. Niet als een collega die zelfstandig features oplevert. Met die instelling bespaart het daadwerkelijk uren per week — zonder de technische schuld die ontstaat als gegenereerde code blind wordt overgenomen.

De tooling wordt snel beter. Maar de fundamentele beperking blijft: een model dat code genereert op basis van patronen kent jouw specifieke context niet. Zolang dat zo is, blijft het een hulpmiddel. Een goed hulpmiddel, dat wel.