Waarom de prijs van een LLM niet de kwaliteit van de code bepaalt
Er heerst een hardnekkig idee dat het gratis model je slechtere antwoorden zal geven. Dat is deels waar en deels niet. Wat er echt verandert tussen een gratis en een betaald plan is niet alleen het model: het is de context die je kunt meesturen, de frequentie waarmee je het kunt raadplegen en de toegang tot de tools eromheen.
Een open model zoals Qwen 2.5 Coder of DeepSeek Coder dat lokaal draait, kan prima een functie voor formuliervalidatie of een script voor datamigratie oplossen. Waar het faalt, is wanneer het hele project niet in het contextvenster past, of wanneer je wilt dat de assistent 14 onderling samenhangende bestanden begrijpt. Daar begint het gratis plan van elke externe dienst zijn naden te tonen.
Volgens de officiële documentatie van de belangrijkste aanbieders beperken gratis plannen doorgaans zowel het aantal berichten per tijdslot als de maximale contextgrootte. Dat tweede punt is wat het echte programmeerwerk het meest beïnvloedt, veel meer dan het aantal queries per dag.
Wat een gratis plan je in 2026 echt biedt
Het gratis aanbod heeft zich gestabiliseerd rond drie verschillende bedrijfsmodellen, en het loont om ze te onderscheiden, want ze bepalen wat je ermee kunt doen.
Freemium met een dagelijks quotum aan berichten
Dit is het model van ChatGPT, Claude en Gemini. Je krijgt toegang tot het high-end model met een limiet aan berichten die per uur of per dag wordt vernieuwd. Voor losse taken (een regex die niet werkt, een stack trace uitleggen) is het meer dan genoeg. Het probleem ontstaat wanneer je midden in een refactoring zit en al 20 berichten achter elkaar hebt gestuurd: je quotum raakt op precies wanneer je het meest moet itereren.
Een detail dat bijna niemand noemt: bij verschillende van deze diensten omvat het gratis plan geen toegang tot de agent- of multi-bestand-bewerkingsfunctionaliteit. Alleen chat. Dat betekent dat je code moet kopiëren en plakken tussen de editor en het browservenster, wat de workflow doorbreekt.
Code-assistenten met een echte gratis laag
GitHub Copilot biedt een gratis niveau met een beperkt aantal completions en chatverzoeken per maand. Het verschil met de chatbots is dat het in de IDE is geïntegreerd: de suggesties verschijnen terwijl je typt, zonder van venster te wisselen. Voor repetitieve code (getters, basistests, routeconfiguratie) is de tijdsbesparing aanzienlijk, zelfs met het gratis quotum.
Cursor en Windsurf houden er ook bescheidener gratis plannen op na, met beperkte toegang tot snelle modellen. De gebruikerservaring is goed, maar het quotum raakt snel op als je meerdere uren achter elkaar werkt.
Open modellen die lokaal draaien
Hier is geen quotum, geen abonnement en geen verzending van je code naar een externe server. Tools zoals Ollama, LM Studio of llama.cpp maken het mogelijk modellen zoals CodeLlama, DeepSeek Coder of Qwen Coder te downloaden en op je eigen machine te draaien. De voorwaarde is voldoende hardware: een 7B-model gequantiseerd naar 4 bits werkt op een GPU met 8 GB VRAM, maar een 30B-model heeft heel wat meer nodig.
Het echte voordeel is niet alleen de prijs. Het is dat je met propriëtaire code kunt werken zonder je zorgen te maken over het dataretentiebeleid van de aanbieder. Het nadeel is dat de kwaliteit van de antwoorden bij complexe taken onder die van de frontier-modellen ligt, en dat de snelheid afhangt van je apparatuur.
Praktische vergelijking: wanneer gratis tekortschiet
Ik ga niet zeggen dat het gratis plan «niet werkt». Het werkt, en hoe, voor een groot percentage van de taken. Maar er zijn scenario’s waarin de betaalde versie ophoudt een luxe te zijn en een operationele noodzaak wordt.
Scenario 1: een fout opsporen in een klein project
Een gratis plan is volkomen toereikend. Je plakt de fout, je plakt het codefragment, je krijgt een hypothese. Zelfs een lokaal 7B-model kan bij veelvoorkomende syntax- of typefouten raak zitten.
Scenario 2: een overgenomen repository begrijpen
Hier schiet gratis bijna altijd tekort. Je moet meerdere bestanden meesturen, de context tussen vragen vasthouden en ervoor zorgen dat het model eerdere beslissingen onthoudt. Gratis plannen beperken de context doorgaans tot een fractie van wat het betaalde plan biedt, en het geheugen tussen sessies is vrijwel nihil.
Scenario 3: geautomatiseerde tests genereren voor een complete module
Dat hangt van de omvang af. Voor een klasse met vijf methoden kan het gratis plan van een IDE-assistent het aan. Voor een module met kruisende afhankelijkheden moet het model de interfaces van de gerelateerde klassen zien, en dat vreet snel context.
De fout die bijna iedereen maakt met gratis plannen
Er is een patroon dat ik steeds weer zie: het gratis plan gebruiken voor architectuurtaken. Dat wil zeggen, het model vragen de structuur van een applicatie te ontwerpen, te beslissen welk patroon te gebruiken of een migratie te plannen. Gratis modellen, met beperkte context en zonder toegang tot het volledige project, hebben de neiging afhankelijkheden te verzinnen die niet bestaan of generieke oplossingen voor te stellen die niet passen bij de werkelijke code.
Een concreet geval: een gratis plan vragen je te suggereren hoe je een authenticatiesysteem structureert in een app die al een specifieke ORM en een eigen sessiesysteem heeft. Zonder die bestanden te zien, stelt het model een standaardoplossing voor met JWT en een bibliotheek die je misschien niet gebruikt, en dan mag je het handmatig aanpassen. De tijd die je bespaart met het antwoord, verlies je bij de aanpassing.
De vuistregel: gebruik het gratis plan voor atomaire en lokale taken, en bewaar het betaalde plan voor taken die brede context of lange iteratie vereisen.
Open modellen die de moeite waard zijn in 2026
Het ecosysteem van open modellen is voldoende volwassen geworden om een echt alternatief te zijn, niet alleen een experiment. Dit zijn de modellen die, volgens de officiële documentatie van hun makers en de tests van de community, de beste verhouding kwaliteit/middelen bieden:
- Qwen 2.5 Coder: goed in populaire talen en met versies van 1.5B tot 32B. De kleine versie draait op bescheiden laptops.
- DeepSeek Coder V2: sterk in redeneertaken over code, al vereist het meer VRAM.
- CodeLlama: de meest ervaren van het stel, met goede ondersteuning in tools zoals Ollama. Minder nauwkeurig dan de vorige in moderne talen.
- StarCoder 2: getraind met permissieve licenties, nuttig als je je zorgen maakt over de herkomst van de gegenereerde code.
Een belangrijke nuance: de kwaliteit van deze modellen lokaal hangt sterk af van de quantisatie. Een 7B-model op 4 bits verliest precisie ten opzichte van de volledige versie. Als je hardware het toelaat, gebruik dan quantisaties van 8 bits of hoger voor codetaken.
Verborgen kosten van «gratis»
Het gratis plan van een externe dienst is niet helemaal gratis. Je betaalt met data: je code, je prompts en de gesprekken worden, volgens het beleid van elke aanbieder, gebruikt om het model te verbeteren. Sommige laten je dat gebruik in de instellingen uitschakelen, maar niet allemaal, en de standaardinstelling is doorgaans de permissieve.
Als je werkt met code onder NDA of met klantgegevens, is dit een serieus probleem. Het alternatief is het lokale model of een betaald plan met contractuele garanties dat er niet mee wordt getraind. Het is een beslissing die je het beste neemt voordat je de eerste regel propriëtaire code in een chatvenster plakt.
De andere verborgen kost is tijd. Kopiëren en plakken tussen de IDE en de browser, antwoorden herformatteren, hallucinaties in functienamen corrigeren… dat telt allemaal op. Een assistent die in de editor is geïntegreerd, ook al is die betaald, kan je meer tijd besparen dan hij kost als je hem dagelijks gebruikt.
Hoe je beslist zonder te veel uit te geven
Een strategie die in de praktijk goed werkt, is die van het opschalen op basis van frictie. Begin met het gratis plan van een in de IDE geïntegreerde assistent (Copilot of vergelijkbaar) en een gratis chatbot in de browser voor losse vragen. Als je binnen een week meerdere keren vastloopt door het quotum of de contextlimiet, overweeg dan de overstap.
Voor projecten met gevoelige code zet je een lokaal model op met Ollama en gebruik je dat als eerste lijn. Als het antwoord niet volstaat, wend je je pas tot de externe dienst met het minimale fragment dat nodig is, niet met het hele project.
En sluit de combinatie niet uit: lokaal model voor automatisch aanvullen en repetitieve taken, gratis extern plan voor losse vragen, en betaald plan alleen als het werkvolume dat rechtvaardigt. De meeste individuele ontwikkelaars hebben het duurste plan niet nodig, maar velen hebben wel baat bij een tussenliggend niveau met brede context en zonder agressieve limieten.
Wat deze modellen nog steeds niet goed doen
Het loont eerlijk te zijn over de beperkingen, want ze raken zowel gratis als betaald. Huidige LLM’s, zelfs de frontier-modellen, falen systematisch in:
- Redeneren over toestand in gedistribueerde systemen: ze hebben de neiging oplossingen voor te stellen die race conditions of consistentieproblemen negeren.
- Code die afhangt van een specifieke versie van een bibliotheek: ze verzinnen API’s die in eerdere versies bestonden of die nooit hebben bestaan.
- Echte prestaties: ze kunnen correcte maar inefficiënte algoritmen voorstellen, zonder te waarschuwen voor de computationele kosten.
- Beveiliging: het komt vaak voor dat ze code genereren met veelvoorkomende kwetsbaarheden (SQL-injectie, onvoldoende validatie) als je niet expliciet vraagt die te vermijden.
Geen van deze beperkingen wordt opgelost door te betalen. Ze worden opgelost door de code te reviewen, tests uit te voeren en kritieke beslissingen niet aan het model te delegeren. Het betaalde plan geeft je meer gemak en meer context, niet meer betrouwbaarheid op deze punten.
Operationele conclusie
Het gratis plan van een LLM om te programmeren is vandaag een volkomen valide tool voor afgebakende taken: een fout uitleggen, een fragment genereren, een eenvoudige test schrijven, code tussen talen vertalen. Het betaalde plan is zinvol wanneer de projectcontext groot is, wanneer je diepe integratie met de IDE nodig hebt of wanneer de code gevoelig is en je die niet wilt sturen naar een dienst die hem gebruikt om te trainen.
Open modellen lokaal vullen het gat van privacy en nul kosten in ruil voor hardware en iets minder kwaliteit. De beslissing is niet «gratis of betaald», maar welke combinatie van de drie opties past bij jouw type project en jouw tolerantie voor frictie.