Agentic coding: wanneer laat je AI meebouwen aan je applicatie?

Bij agentic coding zet je AI-agents in tijdens het ontwikkelen van software. Zo’n agent geeft niet alleen suggesties voor een stukje code, maar kan een complete ontwikkeltaak oppakken. Hij kan een bestaande codebase onderzoeken, meerdere bestanden aanpassen, tests uitvoeren, fouten opsporen en zijn eigen werk op basis daarvan weer verbeteren.

De developer bepaalt wat er moet gebeuren, geeft de agent de juiste context en beoordeelt het resultaat. Het verschil met gewone AI coding assistance is daarmee behoorlijk groot: je vraagt niet steeds om het volgende stukje code, maar delegeert een deel van het ontwikkelwerk.

Agentic coding is niet hetzelfde als vibecoding

Bij vibecoding beschrijf je vooral wat je wilt hebben en laat je AI dat vertalen naar een werkende applicatie zonder dat je bekend raakt met hoe het gemaakt is. Daardoor kun je razendsnel iets maken, ook zonder diepgaande programmeerkennis. Handig voor een prototype, experiment of eenvoudige interne tool.

Bij agentic coding zet je coding agents in binnen een professioneel softwareontwikkelproces. Je kunt complete ontwikkeltaken delegeren, en daarmee verandert je eigen rol. Je wordt in feite de engineering lead van een developmentteam. Je verdeelt het werk, bepaalt de technische koers en beoordeelt of alles wat de agents opleveren ook samen één goed systeem vormt.

Die rol vraagt om de ervaring van een senior developer die het vak in de volle breedte beheerst. Je moet kunnen beoordelen of een oplossing past bij de architectuur, of integraties blijven werken en of de software veilig en onderhoudbaar is. Ook als de agent meldt dat alle tests slagen, moet jij kunnen zien wat die tests over het hoofd zien.

Die ervaring gebruik je al vóór de agent begint. Welke architectuur en design patterns moet hij volgen? Aan welke security-eisen moet de software voldoen? En hoe ziet ‘klaar’ eruit? Met duidelijke engineeringprincipes en acceptatiecriteria geef je de agent genoeg richting om zelfstandig aan de slag te gaan. Jij kunt vervolgens beoordelen of het resultaat voldoet.

Daar hoort ook een werkomgeving bij waarin de agent de relevante code en architectuurkeuzes kan raadplegen, de build kan reproduceren en tests kan draaien. Zo’n omgeving heet vaak een harness. Daarin leg je ook grenzen vast. Welke bestanden en commando’s mag de agent gebruiken? Wanneer moet hij stoppen of hulp vragen? Productie-credentials houd je buiten zijn bereik.

Wanneer wordt agentic coding interessant?

De keuze tussen low-code en maatwerk met coding agents is niet simpelweg een keuze tussen een eenvoudige en een complexe applicatie. Een ingewikkeld bedrijfsproces kan uitstekend binnen een low-codeplatform passen. En een relatief kleine toepassing kan juist maatwerk vragen.

Kijk daarom naar drie dingen:

1. Wat heeft de applicatie nodig?
2. Welke eisen stelt je IT-landschap?
3. En: heb je de kennis en capaciteit in huis om de applicatie te bouwen én te beheren, of wil je die van buiten halen?

Biedt een platform de juiste integraties, toegangscontrole en mogelijkheden voor beheer en deployment? Dan heeft het weinig zin om die functionaliteit zelf opnieuw te bouwen. Maatwerk wordt interessanter wanneer belangrijke eisen moeilijk binnen zo’n platform passen. Bijvoorbeeld omdat je specifieke integraties nodig hebt, precieze controle wilt over performance of deployment, of vanwege gevoelige data precies wilt bepalen wat er onder de motorkap gebeurt.

Ook je bestaande IT-landschap stelt voorwaarden. Kan de applicatie aansluiten op je centrale identityprovider en moet hij binnen een privénetwerk of eigen cloudomgeving draaien? Bestaande API-contracten en deploymentpijplijnen beperken eveneens de keuze. Toets daarnaast welke broncode en data naar de AI-leverancier mogen.

Kijk verder dan de capaciteit om de eerste versie te bouwen. Heb je mensen die technische keuzes kunnen maken, het werk van agents kunnen beoordelen en na livegang updates, beveiliging en incidenten kunnen oppakken? Die kennis en capaciteit kun je zelf opbouwen of bij een externe partij beleggen. Welke expertise je structureel kunt organiseren, bepaalt hoeveel maatwerk je verantwoord kunt dragen en hoeveel je aan een platform wilt overlaten.

Vaak kom je ergens in het midden uit. Een low-codeapplicatie kan prima gebruikmaken van een custom API voor dat ene stuk waarvoor je volledige controle nodig hebt.

Agentic coding kan dat maatwerk vervolgens sneller en praktischer maken, doordat agents een flink deel van het uitvoerende ontwikkelwerk kunnen overnemen. Begin met afgebakende taken waarvan je het resultaat kunt toetsen. Is een codebase slecht gedocumenteerd en ontbreken betrouwbare tests? Dan moet je eerst in dat fundament investeren.

Een supersnelle agent heeft een supergoede engineer nodig

Een agent kan in korte tijd veel code produceren. Dat betekent ook dat hij in korte tijd veel verkeerde code kan produceren.

Daarom verschuift een deel van het werk van de developer. Minder tijd gaat naar iedere regel zelf schrijven; meer aandacht gaat naar het ontwerpen van de oplossing, het meegeven van context en het coördineren van werk. Dat vraagt de vaardigheden van een lead developer: taken afbakenen, architectuurfouten herkennen en beoordelen of wijzigingen op elkaar aansluiten.

Dat begint vóórdat de agent aan het werk gaat. Wat moet er precies gebeuren? Welke bestaande patronen moet hij volgen? Wat mag absoluut niet gebeuren? En hoe controleren we of het resultaat klopt?

Stel, je voegt een endpoint toe aan een bestaand klantportaal. Jij bepaalt het API-contract en de toegangsregels. Eén agent bouwt de wijziging; een andere kan de tests en uitzonderingen nalopen, zoals toegang tot gegevens van een andere klant. Jij bewaakt de afhankelijkheden en beoordeelt het geheel. Laat in CI geautomatiseerde tests en securitychecks draaien en vereis menselijke review vóór het samenvoegen. Een akkoord van een tweede agent vervangt die controles niet.

Wie voor maatwerk kiest, is bovendien eigenaar van de hele software development lifecycle. Agents kunnen helpen met bouwen, testen en documenteren, maar je team blijft verantwoordelijk voor deployment, monitoring, dependency-updates en incidenten. Een platform kan een deel van dat fundament leveren; bij maatwerk regel je dat zelf of via managed services. Sneller code schrijven neemt het werk na livegang niet weg.

Kies eerst wat je nodig hebt

Agentic coding kan maatwerk voor meer toepassingen interessant maken. Werk dat voorheen misschien te veel ontwikkeltijd kostte, kan met coding agents sneller worden uitgevoerd. Mits review en herstelwerk die winst niet weer opslokken.

Maar dat betekent niet dat je voortaan alles zelf moet bouwen. Soms bestaat de oplossing al. Soms past low-code uitstekend. Soms heb je maatwerk nodig. En regelmatig is een combinatie het slimst.

Neem daarin de volledige kosten mee. Een platformlicentie zie je op de factuur, maar daar zit ook wel alles in. De verborgen kosten van alles zelf hosten en onderhouden zie je altijd achteraf pas maar kunnen hoger uitvallen dan bij een platform.

Spreek budgetten en stopcriteria per taak af en meet AI-verbruik, reviewtijd en herstelwerk per geaccepteerde wijziging. Vergelijk zo de totale kosten van maatwerk, inclusief hosting en onderhoud, met de platformoptie. Zonder die grip kan een goedkope eerste versie alsnog duur maatwerk worden.

Begin daarom met vier vragen: wat heeft de business nodig, wat kunnen we hergebruiken, welke eisen zijn echt belangrijk en wie moet de applicatie straks beheren? Pas daarna bepaal je wat je bouwt en hoeveel van dat werk je aan AI kunt overlaten.

Welke aanpak past bij jou?

Agentic coding, low-code of vibecoding? Loop onze applicatiebeslisboom door en ontdek welke aanpak bij jouw app past.