Agentic coding: context en kleine stappen maken het verschil tussen succes en frustratie

AI is in korte tijd een vast onderdeel geworden van de gereedschapskist van veel softwareontwikkelaars. Waar we eerst vooral experimenteerden met code suggesties en het genereren van losse functies, zien we tegenwoordig een nieuwe manier van werken ontstaan: agentic coding.

Met agentic coding bedoelen we in dit artikel dat je AI niet alleen vragen stelt, maar actief laat meewerken aan de ontwikkeling van je applicatie. Je werkt als ontwikkelaar samen met een AI-agent die code analyseert, bestanden aanpast, voorstellen doet en in sommige gevallen complete implementatiestappen uitvoert. Het resultaat is geen eenrichtingsverkeer meer, maar een vorm van co-creatie tussen mens en machine.

Daarbij is het belangrijk om onderscheid te maken tussen twee werkwijzen die tegenwoordig in onder andere GitHub Copilot en Visual Studio beschikbaar zijn: Ask mode en Agent mode.

In Ask mode stel je vragen, vergelijkbaar met hoe je een zoekmachine of chatbot gebruikt. Je vraagt bijvoorbeeld hoe je een bepaald design pattern implementeert of waarom een foutmelding optreedt. De AI geeft antwoord, maar jij bepaalt zelf wat je met dat antwoord doet.

In Agent mode krijgt de AI meer autonomie. De agent mag bestanden analyseren, wijzigingen voorstellen en soms zelfs direct uitvoeren. Dat voelt in eerste instantie bijna alsof je een extra ontwikkelaar in je team hebt zitten. Een ontwikkelaar die nooit moe wordt, razendsnel werkt en een indrukwekkende hoeveelheid kennis paraat heeft.

Maar zoals iedere ontwikkelaar weet: snelheid is niet hetzelfde als kwaliteit.

En precies daar begint het interessante deel van het verhaal.

De eerste stappen zijn vaak verrassend eenvoudig

Veel ontwikkelaars beginnen voorzichtig met AI ondersteunde softwareontwikkeling. Dat gold ook voor mij. In het begin gebruikte ik vrijwel uitsluitend Ask mode. Dat voelde veilig. Ik stelde vragen, kreeg antwoord en verwerkte die antwoorden vervolgens zelf in mijn code. De controle bleef volledig bij mij. Na verloop van tijd groeit echter het vertrouwen. Je merkt dat de AI goede suggesties doet, patronen herkent en soms verrassend slimme oplossingen aandraagt. Vroeg of laat komt dan het moment waarop je Agent mode gaat gebruiken. En eerlijk is eerlijk: voor kleine, gerichte opdrachten werkt dat vaak verbazingwekkend goed.

“Voeg validatie toe aan deze API.”

“Maak een unit test voor deze service.”

“Refactor deze methode naar een meer leesbare opzet.”

Binnen enkele seconden zijn de wijzigingen uitgevoerd. Dat is vaak het moment waarop je denkt: waarom heb ik dit niet eerder gedaan?

Totdat het complex wordt

Op een gegeven moment kom je echter bij opdrachten die verder gaan dan een eenvoudige refactoring of een extra validatieregel. Een migratie, een architectuurwijziging,  een verandering waarbij tientallen modellen, interfaces en processen geraakt worden. Dan zie je iets interessants gebeuren.

De AI begint aan de opdracht, maakt een paar aannames en kiest een richting. In eerste instantie lijkt alles logisch. Maar na enkele stappen bemerk je dat de gekozen route toch niet helemaal klopt. Als ontwikkelaar zie je het gebeuren. De AI niet. Tenminste, meestal niet vanzelf.

Sterker nog: de agent gaat vaak vrolijk verder op basis van de aannames die eerder zijn gedaan. Daardoor ontstaat een sneeuwbaleffect. Elke volgende wijziging bouwt voort op eerdere verkeerde conclusies.

Het resultaat?

Een grote hoeveelheid codewijzigingen die soms nog maar weinig relatie hebben met wat je oorspronkelijk wilde bereiken. Natuurlijk kun je alle wijzigingen terugdraaien. Maar probeer de AI daarna maar eens uit zijn denkpatroon te krijgen.

Meer dan eens heb ik meegemaakt dat vervolgvragen opnieuw teruggrepen op aannames die eerder al onjuist bleken te zijn. Alsof de agent een bepaalde overtuiging had ontwikkeld waar hij moeilijk van los kon komen.

De oorzaak blijkt meestal verrassend simpel:

• Te weinig context.
• Verkeerde context.
• Te grote wijzigingen in één keer.

De oplossing is dat eigenlijk ook. Meer context, meer samenwerking en kleinere stappen.

Meer context is vaak een gamechanger

Een van de grootste lessen die ik heb geleerd bij agentic coding is dat context belangrijker is dan prompting. We besteden vaak veel aandacht aan de perfecte prompt, terwijl het echte verschil meestal wordt gemaakt door de informatie die de AI tot zijn beschikking heeft.

Een mooi voorbeeld kwam ik tegen tijdens een complexe migratie. Een applicatie gebruikte een historisch XML-gebaseerd gegevensmodel dat moest worden vervangen door een nieuw JSON-formaat.

Het oude model stamde uit de begintijd van .NET en bevatte naamgeving waar moderne ontwikkelaars spontaan hoofdpijn van krijgen. Klassen met namen als DataModuleDataModuleVeldenVeld waren bepaald geen uitzondering. Voor een ontwikkelaar die het systeem jarenlang kent is zo’n model nog te begrijpen. Voor een AI-agent niet.

Hoe leg je uit dat tientallen XML-structuren moeten worden geconverteerd naar een compleet andere JSON-structuur? Hoe maak je duidelijk welke velden overeenkomen, welke uitzonderingen bestaan en welke regels daarbij gelden? Dat lukt niet met een serie losse prompts. Wat uiteindelijk werkte was veel eenvoudiger.

We hebben de migratieregels vastgelegd in een README.md-bestand binnen de repository. Niet alleen de technische mappings, maar ook de achterliggende reden achter die mappings. Welke keuzes waren gemaakt? Welke uitzonderingen bestonden er? Wat waren bekende valkuilen?

Plotseling veranderde het gesprek volledig. De AI hoefde niet langer te raden. De context was aanwezig.

Meer samenwerking, minder verrassingen

Goede context is een belangrijke eerste stap, maar nog geen garantie voor succes. Het is verleidelijk om na het aanleveren van context direct te zeggen: “Prima. Implementeer het maar.”

Dat werkt soms. Maar vaak niet. Wat ik inmiddels vrijwel standaard doe, is eerst controleren of de AI de context daadwerkelijk begrijpt.

Ik vraag bijvoorbeeld:

“Kun je deze context samenvatten?”

“Zie je risico’s in deze aanpak?”

“Welke onderdelen zijn volgens jou nog onduidelijk?”

“Hoe zou jij deze migratie uitvoeren?”

De reacties zijn regelmatig verrassend waardevol. Soms wijst de AI op onduidelijkheden in de documentatie. Soms signaleert hij afhankelijkheden waar ik zelf nog niet aan had gedacht. En soms stelt hij een implementatievolgorde voor die beter blijkt te zijn dan mijn oorspronkelijke plan.

Het mooie hiervan is dat je nog steeds in gesprek bent voordat er één regel code is gewijzigd.

In plaats van achteraf op de rem te moeten trappen, stuur je vooraf bij. Dat scheelt frustratie, tijd en heel veel onnodig heen en weer ping-pongen.

Kleine stappen winnen bijna altijd

Wanneer de context helder is en het plan gezamenlijk is gevalideerd, ontstaat de volgende stap vanzelf. Niet vragen om de implementatie. Vragen om een plan.

Sommige AI-agents doen dit tegenwoordig automatisch. Andere moeten er expliciet om gevraagd worden. Maar uiteindelijk wil je hetzelfde bereiken: een overzicht van kleine, beheersbare stappen. Zodra dat plan er ligt, kun je de uitvoering opdelen in overzichtelijke stukken. Deze aanpak heeft een groot voordeel.

Wanneer de AI ergens een verkeerde conclusie trekt, merk je dat vrijwel direct. Je hoeft niet tientallen bestanden terug te draaien. Je corrigeert de koers op één klein onderdeel en gaat verder.

Dat maakt agentic coding niet alleen betrouwbaarder, maar ook veel prettiger om mee te werken.

Het mooie is: het is vaak nog goedkoper ook

Naast een lagere frustratiefactor heeft deze manier van werken nog een onverwacht voordeel. De nieuwste generatie AI-modellen varieert sterk in prijs. Geavanceerde modellen zijn vaak duurder, maar blinken uit in redeneren, plannen en analyseren.

Lichtere modellen zijn goedkoper en uitstekend geschikt voor relatief eenvoudige uitvoeringsstappen. Wanneer je AI eerst een implementatieplan laat maken en daarna de uitvoering opdeelt in kleine taken, ontstaat een natuurlijke scheiding tussen denkwerk en uitvoerend werk. Het plan kan worden opgesteld door een krachtiger model, terwijl de daadwerkelijke implementatiestappen vaak kunnen worden uitgevoerd door goedkopere modellen. Doordat de opdrachten kleiner en beter afgebakend zijn, neemt bovendien de kans toe dat goedkopere modellen direct het juiste resultaat opleveren.

Het gevolg: minder tokens, minder correctierondes en vaak een lagere rekening.

Conclusie

Agentic coding is voor veel ontwikkelaars de volgende stap in AI-ondersteunde softwareontwikkeling. De productiviteitswinst kan indrukwekkend zijn, maar de ervaring leert dat succes niet wordt bepaald door hoe slim het model is.

Succes wordt bepaald door hoe je ermee samenwerkt. Wie een AI-agent zonder context loslaat op een complexe codebase, krijgt vroeg of laat te maken met verkeerde aannames, ongewenste wijzigingen en frustratie.

Wie investeert in context, de AI betrekt bij het plan en de uitvoering opsplitst in kleine stappen, krijgt iets heel anders terug: een waardevolle samenwerkingspartner. Niet omdat de AI alles begrijpt. Maar omdat je ervoor zorgt dat hij steeds genoeg begrijpt om de volgende stap goed te zetten. En uiteindelijk blijkt dat vaak precies het verschil tussen een productieve middag en een avond vol reverts.