Een slimme prompt alleen is niet voldoende om betrouwbare software te ontwikkelen met artificiële intelligentie. Volgens IBM ligt de sleutel tot succesvolle AI-gestuurde softwareontwikkeling in context: de juiste informatie over code, afhankelijkheden, tests en de bedoelingen van ontwikkelaars. Met context-aware coding verandert een AI-agent van een eenvoudige codegenerator in een digitale programmeerpartner die begrijpt wat hij doet.
Van slimme prompts naar intelligente programmeerpartners
Artificiële intelligentie verandert de manier waarop software wordt ontwikkeld. Waar programmeurs vroeger zelf elke regel code moesten schrijven, kunnen AI-agents vandaag complete functies ontwikkelen, fouten opsporen en bestaande toepassingen aanpassen. Toch blijft er een belangrijk probleem bestaan: zelfs de krachtigste AI-modellen kunnen verkeerde beslissingen nemen wanneer ze onvoldoende informatie krijgen.
In een video van IBM legt Legare Kerrison uit waarom een goede prompt slechts het begin is van succesvolle AI-gestuurde softwareontwikkeling. Het echte verschil wordt gemaakt door de context waarin een AI-agent werkt.
Een programmeeropdracht zoals 'voeg een nieuwe functie toe aan deze applicatie' lijkt op het eerste gezicht duidelijk. Maar zonder kennis van de bestaande softwarearchitectuur, gebruikte bibliotheken en technische vereisten moet een AI-agent belangrijke zaken zelf proberen te achterhalen. Dat kan leiden tot code die technisch correct lijkt, maar niet aansluit bij de rest van het project.
Context-aware coding moet dat probleem oplossen door AI-agents niet alleen instructies te geven, maar ook de informatie die nodig is om verstandige programmeerbeslissingen te nemen.
Waarom één prompt niet voldoende is
Traditionele AI-codegeneratie begint vaak met een eenvoudige opdracht. Een ontwikkelaar beschrijft wat hij wil bouwen, waarna het AI-model een mogelijke oplossing genereert. Die aanpak werkt relatief goed voor kleine, afzonderlijke programmeertaken. Bij complexe softwareprojecten wordt de situatie echter ingewikkelder.
Een moderne applicatie bestaat uit tientallen, honderden of zelfs duizenden bestanden die met elkaar samenwerken. Functies zijn afhankelijk van andere onderdelen, bibliotheken moeten compatibel blijven en bestaande architectuurkeuzes bepalen hoe nieuwe functionaliteiten worden toegevoegd. Wanneer een AI-agent uitsluitend de oorspronkelijke opdracht kent, ontbreekt een groot deel van dat technische verhaal.
Volgens Kerrison moeten AI-agents daarom toegang krijgen tot relevante projectinformatie. Niet om zoveel mogelijk gegevens te verzamelen, maar om precies te begrijpen welke onderdelen van de software belangrijk zijn voor de gevraagde wijziging. Het resultaat is een fundamenteel andere manier van programmeren: AI genereert niet zomaar code, maar probeert eerst te begrijpen hoe die code binnen het bestaande systeem moet functioneren.
De repository als digitale landkaart
Een van de belangrijkste informatiebronnen voor een AI-programmeeragent is de repository: de centrale verzameling bestanden waarin de broncode van een softwareproject wordt beheerd. De structuur van die repository vertelt veel over de manier waarop een applicatie is opgebouwd. Ze laat bijvoorbeeld zien waar specifieke functies zich bevinden, hoe modules met elkaar communiceren en welke programmeerpatronen binnen het project worden gebruikt.
Een AI-agent die deze structuur begrijpt, kan gerichter werken. In plaats van willekeurig nieuwe bestanden aan te maken of bestaande onderdelen te dupliceren, kan hij bepalen waar een wijziging logisch thuishoort. Ook het selecteren van relevante codefragmenten speelt een belangrijke rol. Een agent hoeft immers niet de volledige repository te analyseren wanneer slechts enkele bestanden betrokken zijn bij een specifieke opdracht.
Door gericht de juiste onderdelen beschikbaar te maken, ontstaat een efficiëntere samenwerking tussen ontwikkelaar en AI.
Dependency-versies voorkomen technische verrassingen
Softwareontwikkeling draait niet uitsluitend om zelfgeschreven code. Vrijwel iedere moderne applicatie maakt gebruik van externe bibliotheken, frameworks en andere afhankelijkheden. Die afhankelijkheden veranderen voortdurend. Een programmeerfunctie die perfect werkt in een recente versie van een framework, kan ontbreken in een oudere versie. Ook kunnen configuraties, API's en aanbevolen werkwijzen tussen versies verschillen.
Voor AI-agents vormt dat een belangrijk risico. Wanneer een model code genereert op basis van algemene programmeerkennis, kan het onbewust functies gebruiken die niet beschikbaar zijn binnen het bestaande project.
IBM benadrukt daarom het belang van concrete dependency-informatie. Door een AI-agent inzicht te geven in de werkelijk geïnstalleerde versies van bibliotheken en frameworks, kan hij oplossingen voorstellen die beter aansluiten bij de technische omgeving. Dat verkleint de kans op compatibiliteitsproblemen en voorkomt dat ontwikkelaars achteraf onnodig veel tijd moeten besteden aan het herstellen van gegenereerde code.
Tests veranderen AI-programmeren in een leerproces
Een andere belangrijke bouwsteen van context-aware coding is het gebruik van tests. Softwaretests controleren of specifieke onderdelen van een applicatie correct functioneren. Ze kunnen bijvoorbeeld nagaan of een berekening het verwachte resultaat oplevert, of een API correct reageert en of bestaande functies blijven werken na een wijziging.
Voor AI-agents vormen deze tests een waardevolle feedbackbron. Een agent kan code genereren, de relevante tests uitvoeren en vervolgens de resultaten analyseren. Wanneer een test mislukt, krijgt de agent concrete informatie over wat er fout loopt. Op basis daarvan kan hij zijn oplossing aanpassen en opnieuw controleren. Zo ontstaat een iteratief ontwikkelproces waarin codegeneratie, verificatie en verbetering elkaar voortdurend opvolgen.
Tests bieden daarbij meer dan alleen technische controle. Ze maken ook duidelijk welk gedrag de software moet vertonen. Een goed ontworpen test vertelt een AI-agent niet alleen wanneer iets fout is, maar helpt ook verduidelijken wat een correcte oplossing inhoudt.
Toch blijven menselijke beoordeling en aanvullende controles noodzakelijk. Een geslaagde test betekent immers niet automatisch dat alle mogelijke fouten of beveiligingsrisico's zijn uitgesloten.
Documentatie geeft AI inzicht in menselijke bedoelingen
Niet alle belangrijke softwarekennis bevindt zich rechtstreeks in de broncode. Ontwikkelaars maken voortdurend keuzes die voortkomen uit zakelijke vereisten, gebruikersbehoeften, beveiligingsafspraken of eerdere technische beslissingen. Die achterliggende redenen zijn niet altijd zichtbaar wanneer een AI-agent uitsluitend codebestanden analyseert.
Daarom speelt documentatie een centrale rol. Technische handleidingen, architectuurbeschrijvingen en projectrichtlijnen kunnen uitleggen waarom bepaalde onderdelen op een specifieke manier zijn ontwikkeld. Dat helpt AI-agents om niet alleen te begrijpen hoe een systeem werkt, maar ook waarom het zo is opgebouwd.
Een bepaalde functie kan bijvoorbeeld bewust eenvoudig zijn gehouden om onderhoud te vergemakkelijken. Zonder die context zou een AI-agent kunnen voorstellen om de functie ingrijpend te herschrijven, terwijl dat helemaal niet de bedoeling is. Door documentatie en ontwikkelaarsintenties mee te nemen, kunnen AI-agents beter rekening houden met de langetermijndoelstellingen van een softwareproject.
AI-agents moeten ook vragen durven stellen
Een opvallend onderdeel van de aanpak die IBM beschrijft, is dat AI-agents niet altijd onmiddellijk met programmeren moeten beginnen. Soms ontbreekt essentiële informatie. In plaats van aannames te maken, kan een agent dan gerichte vragen stellen aan de ontwikkelaar.
Moet een nieuwe functie compatibel blijven met oudere systemen? Zijn er specifieke beveiligingsvereisten? Welke onderdelen mogen worden aangepast en welke moeten onaangeroerd blijven? Dergelijke vragen lijken misschien een vertraging, maar kunnen uiteindelijk veel ontwikkeltijd besparen. Een foutieve aanname aan het begin van een project kan immers leiden tot uitgebreide codewijzigingen die later opnieuw moeten worden uitgevoerd.
Door ontbrekende context actief op te vragen, wordt de samenwerking tussen mens en AI nauwkeuriger. De ontwikkelaar blijft verantwoordelijk voor de richting en de doelstellingen, terwijl de AI-agent helpt om die beslissingen technisch uit te voeren.
Eerst onderzoeken en plannen, daarna programmeren
Context-aware coding verandert ook de volgorde waarin programmeerwerk wordt uitgevoerd. Waar traditionele AI-codegeneratie vaak onmiddellijk begint met het schrijven van code, ontstaat nu een aanpak waarin voorbereiding een grotere rol krijgt. IBM beschrijft een werkwijze waarbij een AI-agent eerst de opdracht verduidelijkt, vervolgens de relevante code onderzoekt en daarna een uitvoeringsplan opstelt.
Pas wanneer voldoende duidelijk is wat er moet gebeuren, begint het eigenlijke programmeerwerk. Deze aanpak kan vooral waardevol zijn bij complexe wijzigingen. Een agent die bijvoorbeeld een nieuwe betaalfunctie moet toevoegen, kan eerst onderzoeken hoe gebruikersaccounts, transacties en bestaande API's zijn georganiseerd. Vervolgens kan hij bepalen welke onderdelen moeten veranderen en welke tests nodig zijn om de nieuwe functionaliteit te controleren.
Door vooraf een plan op te stellen, worden mogelijke conflicten sneller zichtbaar en kunnen ontwikkelaars de voorgestelde aanpak beoordelen voordat ingrijpende wijzigingen plaatsvinden.
Meer context betekent niet automatisch betere AI
Hoewel context essentieel is, waarschuwt IBM ook voor een veelvoorkomende misvatting: hoe meer informatie een AI-agent krijgt, hoe beter hij zal presteren. In werkelijkheid kan een overdaad aan context juist problemen veroorzaken. AI-modellen beschikken over een contextvenster waarin ze instructies, code, documentatie en andere informatie verwerken. Dat venster heeft een beperkte capaciteit.
Wanneer een agent wordt overspoeld met irrelevante bestanden, uitgebreide documentatie en historische gegevens, kan belangrijke informatie ondergesneeuwd raken. Bovendien kan het verwerken van grote hoeveelheden context extra tijd en rekenkracht kosten. De oplossing ligt daarom niet in het onbeperkt toevoegen van informatie, maar in het zorgvuldig selecteren van relevante gegevens.
Een AI-agent die een fout in één specifieke module moet oplossen, heeft doorgaans meer aan enkele gerichte codefragmenten, relevante afhankelijkheden en bijbehorende tests dan aan een volledige kopie van het softwareproject. De kwaliteit van de context is belangrijker dan de hoeveelheid.
De toekomst van agentic coding draait om begrip
De ontwikkelingen rond context-aware coding laten zien hoe de rol van AI binnen softwareontwikkeling verandert. De eerste generatie AI-programmeerhulpmiddelen richtte zich vooral op het aanvullen van code en het genereren van afzonderlijke functies. Nieuwere AI-agents kunnen uitgebreidere taken uitvoeren, meerdere bestanden aanpassen, tests gebruiken en zelfstandig door ontwikkelprocessen navigeren.
Maar naarmate die autonomie toeneemt, wordt betrouwbare context steeds belangrijker. Een agent die zelfstandig wijzigingen mag doorvoeren, moet immers weten welke technische grenzen gelden, welke afhankelijkheden behouden moeten blijven en wanneer menselijke tussenkomst noodzakelijk is.
Dat maakt contextbeheer tot een belangrijk onderdeel van moderne softwarearchitectuur. Voor organisaties betekent dit dat investeren in AI-programmeeragents niet uitsluitend draait om het kiezen van het krachtigste AI-model. Ook goed georganiseerde repositories, actuele documentatie, betrouwbare tests en duidelijke ontwikkelrichtlijnen worden steeds belangrijker.
Van codegenerator naar betrouwbare digitale collega
De belangrijkste boodschap van IBM is dat succesvolle AI-gestuurde softwareontwikkeling niet begint bij een steeds langere prompt, maar bij een beter begrip van de werkomgeving. Wanneer AI-agents toegang krijgen tot de juiste code, repositorystructuur, dependency-versies, tests en ontwikkelaarsintenties, kunnen ze gerichter en betrouwbaarder functioneren.
Tegelijkertijd moeten ze leren omgaan met ontbrekende informatie, relevante vragen stellen en voorkomen dat hun contextvenster wordt gevuld met overbodige gegevens. Daarmee ontstaat een nieuwe fase in softwareontwikkeling waarin AI niet langer uitsluitend antwoorden genereert, maar actief deelneemt aan het volledige ontwikkelproces.
De toekomst van agentic coding wordt dan ook niet alleen bepaald door hoeveel code een AI-agent kan schrijven, maar vooral door hoe goed hij begrijpt welke code nodig is, waarom die nodig is en hoe ze veilig binnen het bestaande systeem past.
