Claude Code met OpenRouter: Wissel gratis van AI-model

Mijn Claude Max-abonnement kost me $200 per maand. Voor klantwerk, enterprise-projecten en alles waarbij betrouwbaarheid niet onderhandelbaar is — elke cent waard. Ik denk er geen seconde over na.

Maar afgelopen dinsdag om 1 uur 's nachts was ik bezig met het prototypen van een zijproject. Een persoonlijke automatiseringstool. Niets kritisch. En mijn abonnement bereikte halverwege een gesprek zijn gebruikslimiet. Claude Code bevroor. De agent stopte midden in een bestandsbewerking, en ik staarde naar een terminal die me vertelde te wachten of te upgraden.

Ik wilde niet wachten. En ik wilde zeker geen extra geld uitgeven aan een hobbyproject om één uur 's nachts. Dus deed ik iets wat ik al weken wilde testen: ik verwees Claude Code naar OpenRouter, wisselde het onderliggende AI-model naar een volledig gratis exemplaar, en werkte gewoon door.

De agent pakte precies op waar hij was gebleven. Dezelfde bestandsbewerkingen. Dezelfde terminalcommando's. Dezelfde meerstaps agentische workflow. Ander brein — maar de handen bleven hetzelfde.

Die nacht veranderde mijn hele kijk op Claude Code. En het zal waarschijnlijk ook veranderen hoe jij het gebruikt, zodra je de truc begrijpt.

De Formule 1-analogie die alles helder maakt

Hier is het denkmodel dat dit concept eindelijk intuïtief voor me maakte.

Claude Code is een Formule 1-auto. Het chassis, de aerodynamica, het stuur, het telemetriesysteem, het pitcrew-team — dat is het agentische framework. Bestanden lezen, code bewerken, terminaluitvoering, git-beheer, sub-agents, skill-systemen. Al die engineering zit in de auto zelf.

Het AI-model? Dat is gewoon de motor.

Anthropic levert Claude Code met hun eigen motor — Opus 4.6, Sonnet, wat je abonnementsniveau ook biedt. En het is een fenomenale motor. Best in class voor veel taken. Maar hier is wat de meeste mensen niet beseffen: je kunt die motor losschroeven en er een compleet andere inzetten. Een Google-motor. Een DeepSeek-motor. Een gratis open-source motor. De auto rijdt nog steeds. Het stuur werkt nog steeds. De pitcrew doet nog steeds zijn werk.

En in tegenstelling tot een echte Formule 1-auto heb je geen krachtige lokale machine nodig om dit te draaien. Claude Code draait in de cloud. Je laptop is slechts de afstandsbediening. Of je het nu draait op een MacBook Pro van $3.000 of een Chromebook van $300, het zware rekenwerk gebeurt op externe servers. Je stuurt instructies en ontvangt resultaten — de model-inference draait ergens anders.

Dit is het punt waar mensen de mist in gaan. Ze nemen aan dat het draaien van Claude Code met verschillende modellen een flinke lokale setup vereist. Dat is niet zo. Je hebt een terminal nodig, een internetverbinding en ongeveer tien minuten voor de configuratie.

De echte vraag is niet of je de motor kunt wisselen. Het is welke motor je moet kiezen, en wanneer het zinvol is om de standaardmotor te gebruiken. Daar wordt het interessant — en daar heb ik een volle week aan testen aan besteed zodat jij dat niet hoeft te doen.

De vier afwegingen die je eigenlijk maakt

Voordat ik je door de setup loop, moet je begrijpen wat je inruilt. Overschakelen van Anthropic's premium modellen naar alternatieven is geen gratis lunch — zelfs als het model zelf gratis is. Er zijn precies vier dimensies waarop de afweging zichtbaar wordt.

Kosten: Van $200/maand naar letterlijk nul

De meest voor de hand liggende. Anthropic's Claude Max-abonnement kost $200/maand voor zware gebruikers. De Pro-tier is $20/maand. API-credits worden snel duur bij complexe agentische workflows die door context windows branden.

Via OpenRouter kun je modellen gebruiken die variëren van $15 per miljoen tokens tot helemaal niets. Ik heb complete codeersessies gedraaid — refactors over meerdere bestanden, testgeneratie, documentatie — op modellen die me minder dan een cent kostten. Sommige sessies kostten me nul.

Voor experimenteren, leren, zijprojecten en prototyping? Dat kostenverschil is allesbepalend.

Snelheid: De verborgen variabele waar niemand je voor waarschuwt

Goedkope en gratis modellen zijn vaak langzamer. Soms dramatisch langzamer. Een antwoord dat 2 seconden duurt op Opus 4.6 kan 8-12 seconden duren op een gratis model tijdens piekuren. Wanneer je een agentische workflow draait met tientallen heen-en-weer-uitwisselingen, stapelen die extra seconden zich op tot minuten.

Ik heb het gemeten. Een refactoring-taak die 4 minuten duurde op Opus 4.6 (Sonic) duurde bijna 14 minuten op DeepSeek V3's gratis tier op een drukke middag. Dezelfde taak, dezelfde prompt, dezelfde resultaatkwaliteit — alleen pijnlijk langzamer.

Buiten piekuren? Het verschil krimpt. 's Avonds laat en vroeg in de ochtend draaien gratis modellen aanzienlijk sneller omdat minder mensen de servers belasten.

Prestaties: Waar de 85%-regel in werking treedt

Niet alle modellen redeneren even goed. Premium Claude-modellen — met name Opus 4.6 — behandelen complexe meerstapscodeertaken met een nauwkeurigheid die goedkopere modellen oprecht niet kunnen evenaren. Randgevallen, subtiele bugs, architectuurbeslissingen die begrip vereisen van de volledige context van een codebase — dit is waar de dure modellen hun prijs verdienen.

Maar hier is wat ik ontdekte na een week testen: voor ongeveer 70-80% van de gangbare ontwikkeltaken — boilerplate schrijven, tests genereren, documentatie maken, eenvoudige refactors, bestandsmanipulatie — presteren middenklasse modellen vrijwel identiek aan premium modellen. Het verschil komt pas naar voren bij het moeilijke werk.

Ik beschouw het als de 85%-regel. Een model als Gemini Flash geeft je ruwweg 85% van Opus 4.6's codeerprestaties tegen ongeveer 10% van de kosten. Voor veel workflows maakt die rekensom de beslissing vanzelfsprekend.

Beveiliging: De olifant in de terminal

Dit punt is belangrijk en wordt te vaak over het hoofd gezien. Wanneer je Claude Code via OpenRouter routeert, passeren je code en prompts de infrastructuur van OpenRouter voordat ze bij de modelprovider aankomen. Dat is een extra schakel. Een extra bedrijf dat je gegevens ziet.

Voor persoonlijke projecten, open-source werk en niet-gevoelige code? Waarschijnlijk prima. OpenRouter heeft redelijke privacybeleid en traint standaard niet op je data.

Voor klantprojecten, eigendomscode, enterprise-werk of alles wat met inloggegevens en geheimen te maken heeft? Blijf op Anthropic's directe infrastructuur met je betaalde abonnement. Zonder twijfel. De beveiligingsafweging is het niet waard om een paar euro te besparen wanneer je met andermans intellectueel eigendom werkt.

Ik houd deze grens strikt. Klantwerk draait op het Max-abonnement via Anthropic rechtstreeks. Persoonlijke projecten en experimenten draaien via OpenRouter. Geen uitzonderingen, geen grijze gebieden.

Nu je begrijpt waarvoor je optimaliseert — hier is het deel waar we het daadwerkelijk instellen.

OpenRouter: De AI-modelgateway die alles verandert

OpenRouter is, in de eenvoudigste bewoordingen, een universele adapter voor AI-modellen. Eén API-key, één endpoint, honderden modellen van tientallen providers. Je maakt één API-aanroep, geeft aan welk model je wilt, en OpenRouter routeert je verzoek naar de juiste provider, regelt de authenticatie en stuurt het antwoord terug in een gestandaardiseerd formaat.

Zie het als Stripe voor AI-modellen. Je integreert niet met elke betalingsverwerker apart — je gaat via Stripe en die regelt de routering. OpenRouter doet hetzelfde voor taalmodellen. Google's Gemini, DeepSeek, Meta's Llama-varianten, Mistral, Anthropic's eigen modellen en honderden meer — allemaal toegankelijk via één API.

Waarom is dit belangrijk voor Claude Code specifiek? Omdat Claude Code's agentische framework met het AI-model communiceert via een standaard API-interface. Als je het een endpoint kunt geven dat hetzelfde protocol spreekt, maakt het niet uit wie er antwoordt. Het stuurt prompts. Het ontvangt completions. Het voert tools uit. Het framework is model-agnostisch door ontwerp — ook al geeft Anthropic uiteraard de voorkeur dat je hun modellen gebruikt.

Hier zijn de vijf modellen die ik het meest uitgebreid heb getest via OpenRouter met Claude Code, gerangschikt op mijn ervaring bij daadwerkelijk ontwikkelwerk.

Opus 4.6 Sonic — De premium benchmark ($15/M tokens)

Dit is Anthropic's eigen vlaggenschip, benaderd via OpenRouter in plaats van een direct abonnement. Prestaties? Een perfecte 10 op 10 in mijn tests. Het is het snelste premium model beschikbaar, het meest betrouwbaar voor complexe agentische ketens, en behandelt randgevallen met een precisie die me na maanden dagelijks gebruik nog steeds indruk maakt.

Waarom zou je het via OpenRouter benaderen in plaats van via een direct abonnement? Flexibiliteit. Met OpenRouter betaal je per token — geen maandelijkse verplichting. Als je een week hebt waarin je nauwelijks codeert, betaal je nauwelijks. Als je een sprintweek hebt waarin je door tokens brandt, betaal je meer. Voor ontwikkelaars met wisselende gebruikspatronen kan dit daadwerkelijk goedkoper zijn dan het Max-abonnement van $200/maand.

Het nadeel: tegen $15 per miljoen tokens wordt intensief gebruik snel duur. Een complexe agentische sessie kan makkelijk 100K-500K tokens verbranden, dus een drukke dag kan $1,50-$7,50 kosten. De rekensom werkt alleen in je voordeel als je aanzienlijke pauzes hebt tussen sprints.

Gemini Flash — De sweet spot ($1,50/M tokens)

Dit is mijn dagelijkse werkpaard voor niet-kritisch werk, en eerlijk gezegd heeft het me verrast. Google's Gemini Flash via OpenRouter kost ruwweg een tiende van wat Opus per token rekent. Qua prestaties zou ik het een 8,5 op 10 geven voor codeertaken.

Waar het uitblinkt: boilerplate-generatie, tests schrijven, documentatie, rechttoe rechtaan refactors, bestanden aanmaken en elke taak waarbij de instructies duidelijk zijn en de redeneerketen niet te diep gaat. Voor deze alledaagse ontwikkeltaken kan ik oprecht het verschil niet zien tussen Gemini Flash-output en Opus-output. De code is schoon. De bewerkingen zijn nauwkeurig. De agentworkflow draait soepel.

Waar het struikelt: complexe refactors over meerdere bestanden die begrip vereisen van subtiele architectuurafhankelijkheden. Taken waarbij het model een grote context moet vasthouden en moet redeneren over interacties tussen verafgelegen delen van een codebase. Randgevallen bij testgeneratie waarbij de faalscenario's niet voor de hand liggen.

Mijn workflow: Gemini Flash verwerkt inmiddels waarschijnlijk 60% van mijn dagelijks Claude Code-gebruik. De overige 40% — alles wat complex is, alles voor een klant, alles waarbij een fout me meer kost dan de tokenbesparing — gaat naar Opus.

Dro Small — Budgetoptie met gratis tiers

Dro Small valt in de budgetcategorie met gratis opties beschikbaar buiten piekuren. De prestaties zijn merkbaar lager — rond de 6,5-7 op 10 voor codeertaken. Duidelijke specificaties en eenvoudige functies? Prima. Subtiel debuggen of complexe refactors? Je besteedt meer tijd aan het corrigeren van output dan je aan tokens hebt bespaard.

De snelheid fluctueert enorm op de gratis tier — 3 seconden bij sommige verzoeken, 20+ seconden bij andere. Gedeelde capaciteit betekent onvoorspelbare responstijden.

Ik gebruik het voor één specifiek doel: bulk repetitieve taken met getempleerde prompts en sterk gestructureerde output. Boilerplate genereren over meerdere bestanden, gestandaardiseerde docstrings, test-stubs. Hiervoor is het verrassend toereikend en effectief gratis.

DeepSeek V3 — Gratis, snel en frustrerend

DeepSeek V3 is het meest interessante model op deze lijst omdat het tegelijkertijd indrukwekkend en irritant is.

Het model zelf is oprecht capabel. Voor pure codeerprestaties zou ik het een 7,5-8 op 10 geven — verrassend dicht bij Gemini Flash voor veel taken, en het is gratis. De code die het genereert is schoon, de redenering is solide, en voor rechtlijnig ontwikkelwerk zou je moeite hebben om het te onderscheiden van modellen die tien keer zoveel kosten.

Het probleem is betrouwbaarheid. DeepSeek V3's gratis tier op OpenRouter is gevoelig voor rate limiting — vooral tijdens Aziatische en Europese kantooruren wanneer het gebruik piekt. Ik heb sessies gehad waarin de agent drie tool-aanroepen succesvol uitvoerde en vervolgens bij de vierde een rate limit bereikte, waardoor ik achterbleef met een half-afgeronde bestandsbewerking en een kapotte workflow.

Er is weinig zo frustrerend als een agentische codeersessie die halverwege een refactor stopt omdat de modelprovider je verzoeken heeft afgeremd. Je kunt niet makkelijk hervatten vanuit een half-afgeronde toestand. Je wacht en probeert het opnieuw, of je schakelt over naar een ander model en hoopt dat het de context correct oppakt.

Mijn oordeel over DeepSeek V3: briljant voor leren, experimenteren en sessies waarbij je geduld en tijd hebt. Niet iets waar ik op zou vertrouwen voor werk met een deadline. De rate limiting alleen al diskwalificeert het voor serieus gebruik.

De overige honderden

OpenRouter geeft je toegang tot honderden meer — Meta's Llama-varianten, Mistral, Cohere's Command-serie, community fine-tunes. Het ecosysteem is enorm en groeit wekelijks.

Een eerlijke waarschuwing: niet elk model werkt soepel samen met Claude Code's agentische framework. Modellen die goed scoren op chatbenchmarks lopen soms vast op tool-calling protocollen — ze retourneren misvormde JSON, negeren functiesignaturen of hallucineren toolnamen. Dit is me meer dan eens overkomen. Als je buiten mijn geteste lijst experimenteert, begin dan met een eenvoudige taak die een verifieerbaar antwoord heeft en bevestig dat het model tool-aanroepen betrouwbaar afhandelt voordat je het met iets complexs vertrouwt.

Laten we dit nu instellen.

Stap voor stap: OpenRouter instellen met Claude Code

Het hele proces duurt ongeveer tien minuten. Ik loop je er precies doorheen zoals ik het zelf heb gedaan, inclusief de kleine valkuilen waar ik de eerste keer over struikelde.

Stap 1: Maak je OpenRouter-account en API-key aan

Ga naar openrouter.ai en maak een account aan. De registratie is eenvoudig — e-mailadres, wachtwoord, klaar. Geen creditcard nodig om te beginnen.

Zodra je binnen bent, navigeer naar Keys in je dashboard. Klik op Create Key. Geef het een beschrijvende naam — ik noem de mijne naar gebruiksdoel, zoals "claude-code-personal" en "claude-code-experiments" — zodat ik het gebruik later apart kan bijhouden.

Kopieer de API-key onmiddellijk. OpenRouter toont hem slechts één keer. Als je hem kwijtraakt, moet je een nieuwe genereren.

Pro tip: Stort meteen ongeveer $10 op je account, zelfs als je van plan bent gratis modellen te gebruiken. Dit is waarom — OpenRouter behandelt accounts zonder tegoed anders. Gratis modellen hebben strengere rate limits voor accounts zonder tegoed. Zelfs een klein saldo toevoegen signaleert aan OpenRouter dat je een echte gebruiker bent, en je zult merkbaar minder throttling ervaren. Ik leerde dit na drie frustrerende sessies waarin DeepSeek V3 steeds uitviel, en het toevoegen van $5 aan credits maakte alles op magische wijze soepeler. Je geeft die $5 niet uit aan gratis modellen — het blijft gewoon staan als vertrouwenssignaal.

Stap 2: Configureer de Anti-Gravity desktop-app

Als je Claude Code draait via de Anti-Gravity desktop-app — wat mijn gebruikelijke manier is voor het meeste werk — bevindt de configuratie zich in het instellingenpaneel van de app.

Open Anti-Gravity. Navigeer naar Settings > Model Provider (het exacte pad kan enigszins variëren afhankelijk van je versie). Je ziet velden voor:

• API Endpoint / Base URL: Stel dit in op https://openrouter.ai/api/v1
• API Key: Plak hier je OpenRouter API-key
• Model identifier: Dit is de tekenreeks die OpenRouter vertelt welk model het moet gebruiken

De model-identifier volgt een specifiek formaat. Bijvoorbeeld:

• Opus 4.6 Sonic: anthropic/claude-opus-4.6:sonic
• Gemini Flash: google/gemini-flash-1.5
• DeepSeek V3: deepseek/deepseek-chat

Je kunt de exacte model-identifier voor elk model vinden op OpenRouter's modeldirectory-pagina. Elk model heeft een "copy ID"-knop die je de benodigde tekenreeks geeft.

Stap 3: Wisselen tussen modellen

Hier wordt de workflow praktisch. Je hoeft niet alles opnieuw te configureren telkens wanneer je van model wilt wisselen. Het proces is:

1. Kopieer de model-identifier string voor het model dat je wilt
2. Plak het in het modelconfiguratieveld in Anti-Gravity
3. Herstart je terminalsessie (of open een nieuw terminalpaneel)

Die herstart is belangrijk. Claude Code laadt de modelconfiguratie bij het opstarten van de sessie. De configuratie wijzigen tijdens een sessie heeft geen effect tot je een nieuwe sessie start. Ik bewaar een tekstbestand op mijn bureaublad met al mijn veelgebruikte model-identifiers — één per regel — zodat wisselen letterlijk een kopieer-plak-herstart-operatie is.

# My OpenRouter Model Quick-Switch List
# Premium (client work)
anthropic/claude-opus-4.6:sonic

# Daily driver (personal projects)
google/gemini-flash-1.5

# Free experimentation
deepseek/deepseek-chat

# Budget bulk tasks
dro/dro-small-free

Stap 4: Verifieer je modelverbinding

Na het herstarten met een nieuw model, verifieer de verbinding voordat je aan echt werk begint. Vraag Claude Code "What model are you running on?" — de meeste modellen rapporteren hun identiteit nauwkeurig. Als je een samenhangend antwoord krijgt, is de verbinding actief.

Voor een grondigere test, vraag het om een eenvoudige agentische actie uit te voeren: "Read the current directory and list all files." Dit test de volledige tool-calling pipeline, niet alleen tekstgeneratie. Als het een bestandssysteemoperatie succesvol uitvoert, werkt het agentische framework met je nieuwe model.

Ik doe dit elke keer als ik wissel. Vijf seconden verificatie heeft me tientallen frustrerende debugsessies bespaard waarbij het eigenlijke probleem een verkeerd geconfigureerde modelstring was.

Als je wilt dat iemand een op maat gemaakte AI-agent setup zoals deze voor je bouwt — afgestemd op jouw workflow met de juiste modelmix vanaf het begin geconfigureerd — neem ik precies dit soort projecten aan. Bekijk wat ik heb gebouwd op fiverr.com/s/EgxYmWD.

Stap 5: Meerdere modellen tegelijkertijd beheren

Dit is een workflow-truc die mijn productiviteit aanzienlijk heeft verhoogd. Je hoeft niet één model per sessie te kiezen. Je kunt meerdere terminalpanelen draaien, elk geconfigureerd met een ander model.

Mijn typische opzet:

• Terminalpaneel 1: Opus 4.6 Sonic — voor de complexe architectuurtaak waar ik me op dat moment op richt
• Terminalpaneel 2: Gemini Flash — voor snelle hulptaken, documentatie en testgeneratie die parallel lopen
• Terminalpaneel 3: DeepSeek V3 of een gratis model — voor experimentele branches waarbij ik speculatieve benaderingen probeer die ik misschien weggooi

Drie panelen, drie modellen, drie verschillende kostenprofielen, allemaal gelijktijdig draaiend binnen dezelfde IDE. Het complexe redeneerwerk gebeurt op het premium model. Het routinewerk draait op het goedkope model. Het experimentele spul draait gratis.

Als je er zo over nadenkt, kies je niet tussen gratis en betaalde modellen. Je bouwt een team van AI-assistenten op verschillende prijspunten, elk toegewezen aan het werk dat past bij hun capaciteitsniveau. Dat is geen kostenbesparing — dat is resource-allocatie.

Skills werken ongeacht welke motor je draait

Iets wat ik vroeg in mijn testen moest bevestigen — en dit is een vraag die ik van meerdere mensen heb gekregen — is of Claude Code's skill-systeem nog werkt wanneer je van model wisselt.

Kort antwoord: ja. Volledig.

Skills in Claude Code zijn model-agnostisch door ontwerp. Een skill is in essentie een gedefinieerde capaciteit — een set instructies, API-integraties en tool-use patronen die de agent volgt. De skill zelf maakt het niet uit welk model de redenering aandrijft. Het is infrastructuur, geen intelligentie.

Bijvoorbeeld, ik heb een Bitly URL-verkortingsskill geconfigureerd in mijn Claude Code-setup. Wanneer ik zeg "shorten this URL," handelt de skill de Bitly API-aanroep af, verwerkt het antwoord en retourneert de verkorte link. Of het onderliggende model nu Opus 4.6, Gemini Flash of DeepSeek V3 is, de skill voert identiek uit. Het model levert de redenering om mijn verzoek te begrijpen en de skill aan te roepen. De skill doet het daadwerkelijke werk.

Ik heb dit getest op alle vijf modellen die ik eerder noemde. Elk model triggerde skills correct, gaf parameters nauwkeurig door en verwerkte skill-antwoorden zonder problemen. De modelkwaliteit beïnvloedt hoe goed het model genuanceerde skill-aanroepen begrijpt — een gratis model heeft misschien explicietere instructies nodig dan Opus — maar de skill-infrastructuur zelf is rotsvast, ongeacht het model.

Dit is belangrijk omdat het betekent dat je investering in het configureren van skills, het opzetten van integraties en het bouwen van aangepaste workflows perfect meegaat wanneer je van model wisselt. Niets breekt. Niets hoeft opnieuw geconfigureerd te worden. Je wisselt de motor, de auto blijft rijden, en alle aangepaste modificaties die je aan het chassis hebt gemaakt, blijven precies waar ze zijn.

Als je je Claude Code-setup hebt gebouwd rondom skills (en als je dat nog niet hebt gedaan, bekijk dan mijn agent skills guide voor de volledige uitleg), dan is deze portabiliteit een belangrijk voordeel van de OpenRouter-aanpak. Je investering in skills levert rendement op, ongeacht welk model je deze week draait.

De valse besparingsval — Wanneer gratis modellen je meer kosten

Hier komt het eerlijke deel. Het deel dat de meeste "gebruik AI gratis!"-artikelen handig overslaan.

Ik heb een middag besteed aan het bouwen van een matig complex Next.js-component met DeepSeek V3 op de gratis tier. Het component omvatte dynamische formuliergeneratie met validatie, conditionele veldzichtbaarheid en real-time preview. Niet triviaal, maar ook geen raketwetenschap — iets wat Opus in één keer zou afhandelen.

DeepSeek V3 had vier pogingen nodig. De eerste output had een subtiele state management-bug. De tweede loste die bug op maar introduceerde een renderprobleem. De derde werkte maar produceerde code die... laten we zeggen "creatief" was op manieren die een code review niet zouden overleven. De vierde poging leverde eindelijk iets op dat ik kon opleveren, maar pas nadat ik handmatig twee randgevallen had gecorrigeerd die het model had gemist.

Totale tijd op DeepSeek V3: ongeveer 45 minuten. Totale kosten: $0.

Toen ik de volgende dag dezelfde taak op Opus 4.6 draaide ter vergelijking: één poging, schone code, 6 minuten. Kosten: ruwweg $0,30 aan tokens.

Hier is de rekensom die ertoe doet. Als mijn tijd iets waard is — en die van jou ook — dan is 45 minuten besteden om $0,30 te besparen een verschrikkelijke deal. Dat is een effectief uurtarief van $0,40. Zelfs als je je tijd op minimumloon waardeert, heb je geld verloren op het "gratis" model.

Dit noem ik de valse besparingsval. Het model is gratis. Je tijd is dat niet. Als je 30 extra minuten besteedt aan het corrigeren van de fouten van een goedkoop model, heb je geen geld bespaard. Je hebt betaald met de duurste resource die je hebt.

Dus wanneer is gratis echt gratis? Wanneer de taak eenvoudig genoeg is dat het goedkope model het in de eerste poging goed doet. Wanneer je experimenteert en de outputkwaliteit er niet toe doet. Wanneer je aan het leren bent en het debugproces zelf leerzaam is. Wanneer je bulktaken draait waarbij je de prompt zo strak kunt templaten dat zelfs een matig model het niet kan verpesten.

Voor al het andere? Betaal voor het goede model. De tijdsbesparing alleen al rechtvaardigt de kosten.

Wanneer betalen en wanneer spelen: Mijn beslisframework

Na een paar weken met deze hybride opzet ontwikkelde ik een eenvoudig framework om te beslissen welk model welke taak krijgt. Het is niet ingewikkeld, maar het behoedt me voor de verkeerde keuze.

Gebruik altijd premium Claude (Max-abonnement of Opus via OpenRouter):

• Klantwerk. Punt uit. Geen uitzonderingen.
• Alle code die productiesystemen raakt
• Complexe architectuurbeslissingen of refactors over meerdere bestanden
• Beveiligingsgevoelige code (authenticatie, autorisatie, encryptie)
• Het debuggen van subtiele bugs waarbij het faalscenario niet voor de hand ligt
• Elke taak waarbij een fout meer kost om te herstellen dan de tokens kosten om het te voorkomen

Gebruik middenklasse modellen (Gemini Flash):

• Persoonlijke projecten waarbij kwaliteit ertoe doet maar urgentie niet
• Testgeneratie voor goed gedefinieerde functies
• Documentatie en README's maken
• Boilerplate-scaffolding (nieuwe componenten, standaard CRUD-endpoints)
• Code-opmaak en stijlrefactoring
• Alles met een duidelijke specificatie en een verifieerbare output

Gebruik gratis modellen (DeepSeek V3, Dro Small):

• Puur experimenteren en leren
• Wegwerpprototypes die je toch van plan bent te herschrijven
• Bulk repetitieve operaties met getempleerde prompts
• Pauzes opvullen wanneer je betaalde abonnement een rate limit heeft bereikt
• Testen of Claude Code's agentische framework een specifieke workflow aankan voordat je premium tokens eraan besteedt

Hier is de mindsetverandering die dit framework voor mij deed klikken: behandel je AI-abonnement als een mini digitale werknemer.

Een senior developer kost $8.000-$15.000 per maand. Een junior developer kost $3.000-$6.000. Je Claude Max-abonnement van $200/maand is, zelfs op zijn duurste, minder dan 3% van wat een junior developer kost. En het werkt om 2 uur 's nachts zonder te klagen.

Als je het zo bekijkt, is de vraag niet "hoe vermijd ik te betalen voor AI?" De vraag is "hoe verdeel ik mijn AI-budget over verschillende capaciteitsniveaus op dezelfde manier als een bedrijf werk verdeelt over senior en junior developers?"

Je wijst geen senior developer toe om boilerplate te schrijven. Je wijst geen junior developer toe om je gedistribueerde systeem te architecteren. Dezelfde logica geldt voor AI-modellen. Stem het modelniveau af op de taakcomplexiteit, en je geeft minder uit terwijl je meer gedaan krijgt.

De echte kracht: Flexibiliteit als workflowstrategie

De grootste les van dit hele experiment is niet een individuele modelvergelijking. Het is de flexibiliteit zelf.

Vóór OpenRouter zat ik vast aan één provider. Anthropic-storing? Mijn workflow stopte. Abonnementslimiet bereikt? Klaar voor de dag. Nieuwsgierig hoe een ander model een specifieke taak aanpakt? Een volledig aparte toolchain nodig.

Nu? Anthropic gaat down, ik schakel in dertig seconden over naar Gemini Flash. Rate limit bij het ene model, ik draai naar een ander. Benieuwd of DeepSeek een bepaald codeerpatroon beter aanpakt dan Claude? Vergelijking naast elkaar in parallelle terminalpanelen, geen workflowwijzigingen nodig.

Die flexibiliteit stapelt zich op. Ik heb taken ontdekt waarbij Gemini Flash daadwerkelijk beter presteert dan Claude — met name datatransformatiewerk waarbij Flash's patroonherkenning een verrassend voordeel heeft. Dat had ik niet ontdekt zonder de mogelijkheid om makkelijk te wisselen en vergelijken.

De veerkracht is ook belangrijk. Eén AI-provider betekent één single point of failure. OpenRouter als fallback betekent dat je agentische workflow elke slechte dag van een individuele provider overleeft.

Hoe mijn typische week er nu uitziet

Mijn $200 Max-abonnement dekt klantwerk van maandag tot en met woensdag — Opus 4.6 Sonic, directe Anthropic-infrastructuur, geen compromissen op beveiliging. Donderdag en vrijdag schakelen over naar OpenRouter: Gemini Flash voor persoonlijke projecten en documentatie, af en toe DeepSeek V3 als ik benieuwd ben naar hoe het specifieke patronen aanpakt. Weekenden zijn puur experimenteren op gratis modellen.

Totale maandelijkse kosten: het Max-abonnement plus ruwweg $15-$25 aan OpenRouter-credits voor al het andere. Vóór deze workflow betaalde ik ofwel $200 en liep ik tegen limieten aan, of brandde ik door API-credits tegen onvoorspelbare tarieven. De hybride aanpak is zowel goedkoper als productiever.

Als je wilt begrijpen hoe Claude Code's skill-systeem werkt onafhankelijk van welk model het aandrijft, dan legt mijn agent skills guide de volledige architectuur uit. En als je nieuw bent bij de Anti-Gravity IDE waar het meeste van deze configuratie plaatsvindt, heb ik de volledige setup behandeld in mijn Anti-Gravity IDE deep dive.

De vraag die je eigenlijk zou moeten stellen

De meeste mensen benaderen dit onderwerp met de vraag "Hoe gebruik ik Claude Code gratis?" Dat is de verkeerde vraag. Gratis is een middel, geen doel.

De juiste vraag is: "Hoe haal ik de maximale output uit mijn AI-ondersteunde ontwikkelworkflow terwijl ik alleen uitgeef wat elke taak waard is?"

Sommige taken zijn $15 per miljoen tokens waard. Sommige taken zijn $1,50 waard. Sommige zijn nul waard. De developers die de komende jaren het meest productief zullen zijn, zijn niet degenen die het goedkoopste model hebben gevonden — het zijn degenen die hebben geleerd om het juiste model aan de juiste taak te koppelen, naadloos, zonder frictie.

OpenRouter en Claude Code samen geven je die koppelingsmogelijkheid. Je krijgt Anthropic's best-in-class agentische framework — het bestandsbeheer, de terminaluitvoering, het skill-systeem, de meerstaps redenering — met de vrijheid om de intelligentielaag eronder te wisselen op basis van wat je nu aan het bouwen bent.

Dat gaat niet over zuinig zijn. Dat gaat over strategisch zijn. En strategie, naar mijn ervaring, wint het altijd van brute kracht.

Dus hier is je actie voor vanavond: ga dat OpenRouter-account aanmaken, stort er $10 op, configureer één gratis model naast je bestaande Claude-setup, en draai dezelfde taak op beide. Zie het verschil zelf. Zodra je hebt ervaren hoe het is om meerdere AI-engines op afroep beschikbaar te hebben — elk afgestemd op het werk dat het beste past — ga je niet meer terug naar een opzet met één model.

De Formule 1-auto was altijd in staat om met verschillende motoren te rijden. Nu weet je hoe je ze moet wisselen.

Veelgestelde vragen

Werkt Claude Code met elk model op OpenRouter?

Claude Code's agentische framework werkt met de meeste modellen op OpenRouter, maar de kwaliteit varieert aanzienlijk. Modellen moeten tool-calling en gestructureerde output betrouwbaar ondersteunen. Houd je aan bekende modellen zoals Gemini Flash, DeepSeek V3 of Anthropic's eigen aanbod voor consistente resultaten. Zie de stap-voor-stap sectie hierboven voor volledige instellingsdetails.

Is het veilig om gratis AI-modellen te gebruiken voor coderen?

Gratis modellen zijn veilig voor persoonlijke projecten en experimenten. Je code passeert de servers van OpenRouter en de infrastructuur van de modelprovider, dus vermijd het versturen van eigendomscode van klanten, inloggegevens of gevoelige bedrijfslogica via gratis tiers. Houd klantwerk op Anthropic's directe infrastructuur met een betaald abonnement.

Waarom stopt mijn gratis model steeds halverwege een taak?

Rate limiting is de meest voorkomende oorzaak. Gratis modellen op OpenRouter beperken verzoeken tijdens piekgebruiksuren. Het toevoegen van $5-$10 aan OpenRouter-credits vermindert throttling zelfs bij gratis modellen, omdat accounts met tegoed voorrang krijgen. Daluren (laat in de avond, vroeg in de ochtend in jouw tijdzone) hebben ook minder beperkingen.

Kan ik Claude Code-skills gebruiken met niet-Anthropic modellen?

Ja — skills zijn volledig model-agnostisch. Skills definiëren tool-integraties en workflows die onafhankelijk draaien van welk AI-model de redenering levert. Ik heb Bitly URL-verkorting, bestandsoperaties en aangepaste API-skills getest op vijf verschillende modellen zonder herconfiguratie. Zie de sectie over Skills hierboven voor details.

Wat is het beste gratis model voor Claude Code op dit moment?

Per maart 2026 biedt DeepSeek V3 de sterkste gratis codeerprestaties op OpenRouter — ruwweg 7,5-8 op 10 in mijn tests. De afweging is frequente rate limiting tijdens kantooruren. Voor een goedkoop alternatief met betere betrouwbaarheid is Gemini Flash tegen $1,50 per miljoen tokens de sterkste prijs-kwaliteitverhouding in het huidige aanbod.

Laten we samenwerken

Wil je AI-systemen bouwen, workflows automatiseren of je technische infrastructuur opschalen? Ik help je graag.

• Fiverr (custom builds & integraties): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise-oplossingen): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (beveiligingsdiensten): xcybersecurity.io