Van code schrijven naar regie voeren: softwareontwikkeling herdefiniëren in het tijdperk van AI

Softwareontwikkeling draait niet langer uitsluitend om het schrijven van code. Steeds vaker gaat het om het definiëren van intenties, het aansturen van AI-systemen en het behouden van controle over de resultaten die deze systemen genereren. Deze verschuiving verandert nu al de manier waarop software wordt ontwikkeld en hoe de rol van de ontwikkelaar evolueert.

In dit artikel onderzoeken we wat deze transitie betekent, welke ontwikkelparadigma’s hieruit voortkomen en welke risico’s ontstaan wanneer AI wordt ingezet zonder voldoende ervaring en toezicht.

De context

Binnen dit steeds sterker door AI gedreven landschap verschuift de rol van ontwikkelaars. In plaats van uitsluitend bouwers van software worden zij steeds vaker besluitvormers en regisseurs van intelligente systemen.

Binnen softwareontwikkeling en het gebruik van AI ontstaan momenteel drie duidelijke paradigma’s:

• Assisted development

• Intent-driven (vibe) development

• Agentic development

Elk van deze paradigma’s vertegenwoordigt een andere manier van samenwerken met AI en, belangrijker nog, een andere balans tussen controle en autonomie.

In de volgende secties gaan we dieper in op deze drie concepten en bekijken we hoe zij softwareontwikkeling beïnvloeden.

Assisted development

Assisted development is momenteel de meest herkenbare en breed toegepaste vorm van AI binnen softwareontwikkeling.

Praktisch gezien is het vergelijkbaar met samenwerken met een zeer efficiënte collega: altijd beschikbaar, uitzonderlijk snel en in staat om direct suggesties aan te leveren. Net als bij iedere goede samenwerking blijft de verantwoordelijkheid echter bij de ontwikkelaar liggen.

Tools zoals GitHub Copilot, Claude Code, Cursor en Tabnine integreren rechtstreeks in de ontwikkelomgeving en bieden realtime ondersteuning. Ze kunnen volledige functies voorstellen, repetitieve code genereren of helpen bij het begrijpen van onbekende logica.

In de praktijk betekent dit dat ontwikkelaars minder tijd hoeven te besteden aan het schrijven van boilerplate-code en zich meer kunnen richten op het oplossen van daadwerkelijke vraagstukken. Een eenvoudige beschrijving van een functie kan bijvoorbeeld al voldoende zijn voor AI om een eerste implementatie te genereren. Ook bij het schrijven van tests of het refactoren van code kan AI een sterke basis bieden, waardoor routinematige werkzaamheden minder tijd kosten.

Het is echter belangrijk om te begrijpen wat dit paradigma van assisted development niet verandert. De ontwikkelaar blijft verantwoordelijk voor:

• De architectuur

• De bedrijfslogica

• De juistheid van de oplossing

Binnen deze context vervangt AI het besluitvormingsproces niet. Het versnelt vooral de uitvoering. Juist daarom sluit assisted development goed aan op bestaande ontwikkelprocessen. Code reviews, testen en architectuurdiscussies blijven net zo belangrijk als voorheen. Het verschil is dat ontwikkelaars sneller kunnen werken en meer aandacht kunnen besteden aan activiteiten met hogere toegevoegde waarde.

Tegelijkertijd kent dit model duidelijke beperkingen. AI-assistenten werken voornamelijk binnen een lokale context en begrijpen het volledige systeem niet volledig. Ze kunnen geen architectuurbeslissingen nemen en dragen geen verantwoordelijkheid voor complexe processen of afhankelijkheden.

In essentie draait assisted development om het versterken van de ontwikkelaar. Het is vooral een gecontroleerde versnelling van het softwareontwikkelproces.

Intent-driven development (Vibe coding)

Waar assisted development de ontwikkelaar controle laat houden over de implementatie, gaat dit paradigma een stap verder.

Het draait in essentie om het stoppen met het handmatig schrijven van code en het beschrijven van wat er bereikt moet worden.

Intent-driven development, soms ook aangeduid als “vibe coding”, verschuift de focus van implementatiedetails naar het gewenste resultaat. In plaats van systemen stap voor stap op te bouwen, definiëren ontwikkelaars hun intentie, waarna AI de bijbehorende oplossing genereert.

Met tools zoals Replit, Lovable, GitHub Copilot, Claude Code of Codex is het inmiddels mogelijk om binnen enkele minuten van een idee naar een werkend prototype te gaan.

Een ontwikkelaar kan bijvoorbeeld beginnen met een eenvoudige instructie zoals: "Bouw een dashboard met filterfunctionaliteit, grafieken en exportmogelijkheden."

Op basis hiervan kan AI vervolgens het volgende genereren:

• Componenten voor de gebruikersinterface

• Backend-punten

• Datamodellen

De ontwikkelaar werkt daarna verder op dit resultaat door functionaliteit te verfijnen, edge cases af te handelen en integraties met bestaande systemen toe te voegen.

Deze aanpak verhoogt de ontwikkelsnelheid aanzienlijk, vooral in de vroege fasen van softwareontwikkeling. Het verlaagt de instapdrempel en stelt teams in staat om sneller te experimenteren en ideeën te valideren dan voorheen.

Deze snelheid brengt echter ook afwegingen met zich mee. Naarmate het abstractieniveau stijgt, neemt de zichtbaarheid af. Ontwikkelaars begrijpen de gegenereerde code mogelijk niet volledig, en soms helemaal niet, terwijl het behouden van architecturale consistentie steeds moeilijker wordt. Op de langere termijn kan dit leiden tot kwetsbare systemen en oplopende technische schuld.

Daarom is intent-driven development vooral geschikt voor:

• Prototyping

• Experimenteren

Het is een krachtige aanpak, maar wel een aanpak die discipline vereist bij de overgang naar productieomgevingen.

Agentic development

De meest ingrijpende verschuiving ontstaat wanneer AI verder gaat dan ondersteunen of genereren en zelfstandig begint te handelen. Agentic softwarontwikkeling introduceert systemen die taken namens ontwikkelaars kunnen uitvoeren. Deze systemen reageren niet alleen op prompts, maar opereren met een bepaalde mate van autonomie.

Een agentic systeem kan:

• Doelstellingen begrijpen

• De vereiste stappen plannen

• Taken uitvoeren

• Resultaten evalueren

• Herhalen totdat de doelstelling is bereikt

Om dit beter te begrijpen, helpt het om een vergelijking te maken met traditionele automatisering. Een CI/CD-pipeline, zoals GitHub Actions, voert vooraf gedefinieerde stappen uit wanneer deze worden geactiveerd. Het systeem volgt instructies exact zoals ze zijn vastgelegd.

Een agentic systeem werkt fundamenteel anders. In plaats van alleen tests uit te voeren, kan het bijvoorbeeld fouten analyseren, code aanpassen en de pipeline opnieuw uitvoeren totdat het probleem is opgelost.

Dit is het essentiële verschil: automatisering voert uit, terwijl agentic systemen beslissingen nemen en zich aanpassen aan de situatie.

De rol van context

De basis van agentic systemen is context. AI-systemen begrijpen architectuur, coding standards of businessregels niet automatisch. Zonder specifieke en gerichte aansturing kunnen zij oplossingen genereren die technisch correct en zelfs schaalbaar en robuust lijken, maar niet aansluiten op het systeem waarvoor ze bedoeld zijn.

Daarom leggen moderne benaderingen steeds meer nadruk op het aanbieden van gestructureerde context aan AI-agents. Dit kan onder andere bestaan uit:

• Architectuurdocumentatie

• Richtlijnen voor codering

• Repository-specifieke instructies

• Referentie-implementaties

Binnen platforms zoals GitHub krijgt dit inmiddels concreet vorm via mechanismen zoals repository-level instruction files, waarmee organisaties kunnen bepalen hoe AI zich binnen een project moet gedragen.

Met de juiste context worden agents aanzienlijk betrouwbaarder en beter afgestemd op het systeem waarin zij opereren. Zonder deze context blijven ze krachtig, maar moeilijk voorspelbaar.

De agentic stack (hoe het allemaal samenkomt)

Agentic development wordt vaak gezien als één enkele tool of een geavanceerdere assistent. In werkelijkheid bestaat het uit meerdere lagen, waarbij iedere laag verantwoordelijk is voor een specifiek onderdeel van het systeem.

Om dit beter te begrijpen, helpt het om een agentic systeem niet te zien als een tool, maar als een kleine softwareorganisatie. Net als binnen een echt team geldt namelijk dat:

• Iemand bepaalt wat er moet gebeuren

   

• Iemand het werk uitvoert

• Een systeem de resultaten controleert

• Iemand  build- en deploymentprocessen beheert 

Binnen een agentic systeem worden deze rollen ingevuld door verschillende technologische lagen.

Bovenaan bevindt zich de orchestration layer, ondersteund door frameworks zoals LangChain, Microsoft Semantic Kernel en steeds vaker ook tools zoals GitHub Copilot en Claude Code, die zich momenteel ontwikkelen van assistenten naar multi-agent orchestration platforms.

Deze laag fungeert als het “brein” van het systeem: het ontvangt een doelstelling, splitst deze op in kleinere taken en bepaalt welke acties vervolgens uitgevoerd moeten worden.

Daaronder bevindt zich de execution layer, die direct interacteert met de ontwikkelomgeving. Tools zoals OpenAI Codex of Cursor kunnen bestanden uitlezen, code aanpassen en commando’s uitvoeren. Dit is de laag waarin daadwerkelijke codewijzigingen plaatsvinden.

Daarnaast zijn validatie- en feedbacksystemen essentieel, zoals GitHub Actions of GitLab CI/CD. Deze systemen nemen zelf geen beslissingen, maar zorgen ervoor dat het uitgevoerde werk correct is. Ze voeren tests uit, bouwen applicaties en leveren feedback die de agent kan gebruiken om het gedrag bij te sturen.

In de kern van het geheel bevinden zich de reasoning models, zoals GPT-4 of Claude. Deze modellen leveren de intelligentie die nodig is om taken te begrijpen, oplossingen te genereren en beslissingen te nemen.

Wanneer deze lagen samenkomen, ontstaat een iteratieve workflow waarin analyse, uitvoering, validatie en aanpassing continu op elkaar aansluiten.

Juist deze feedbackloop transformeert een statisch systeem naar een adaptief systeem. Samen vormen deze lagen systemen die niet alleen ontwikkelaars ondersteunen, maar in gecontroleerde en iteratieve processen ook namens hen kunnen handelen.

Uitdagingen en overwegingen

Ondanks het potentieel brengt agentic development ook nieuwe uitdagingen met zich mee. Systemen worden complexer en debugging beperkt zich niet langer uitsluitend tot code, maar strekt zich ook uit tot besluitvormingsprocessen. Het waarborgen van betrouwbaarheid vereist daarom sterke governance, duidelijke beperkingen en continue monitoring.

Het toepassen van AI binnen softwareontwikkeling, en met name binnen het agentic paradigma, vermindert de behoefte aan ervaren engineers dan ook niet, maar vergroot deze juist. Hoe meer autonomie aan AI wordt gedelegeerd, hoe belangrijker het wordt om te beschikken over hooggekwalificeerde en goed getrainde ontwikkelaars die daadwerkelijk begrijpen wat er wordt gegenereerd, hoe systemen worden georkestreerd en hoe agents gecontroleerd kunnen worden.

Zonder dit niveau van expertise ontstaat niet alleen het risico op incorrecte code, maar ook op verlies van controle over het volledige systeem. Denk hierbij aan inconsistente architectuur, verborgen fouten en onvoorspelbaar gedrag.

AI kan softwareontwikkeling aanzienlijk versnellen, maar alleen wanneer het wordt ingezet door engineers die in staat zijn om de technologie aan te sturen, te begrenzen en verantwoordelijkheid te nemen voor de output ervan.

Daarnaast speelt vertrouwen een belangrijke rol. Autonome systemen moeten hun betrouwbaarheid over langere tijd bewijzen voordat zij volledig kunnen worden ingezet binnen bedrijfskritische processen. Daarom is het verstandig om agentic development gefaseerd te introduceren, beginnend met duidelijk afgebakende en gecontroleerde scenario’s.

Conclusie

Het is belangrijk om te begrijpen dat de drie paradigma’s die in dit artikel zijn besproken — Assisted development, Vibe (Intent-driven) development en Agentic development — geen concurrerende benaderingen zijn, maar elkaar juist aanvullen. Elk paradigma heeft zijn eigen rol:

• Assisted development verhoogt de productiviteit binnen bestaande workflows.

• Vibe (intent-driven) development versnelt verkenning en prototyping.

• Agentic ontwikkeling maakt grootschalige automatisering mogelijk.

De meest effectieve teams zullen deze drie benaderingen combineren en inzetten waar ze de meeste waarde toevoegen.

Softwareontwikkeling ondergaat daarmee een fundamentele transformatie. Het draait niet langer uitsluitend om het schrijven van code, maar steeds meer om het definiëren van intenties, het beheersen van systemen en het orkestreren van intelligente workflows.

Tegelijkertijd evolueert de rol van ontwikkelaars van pure bouwers van software naar:

• Systeemontwerpers

• Besluitvormers

• Coördinatoren van AI-gestuurde processen

De verschuiving is eenvoudig samen te vatten, maar heeft een grote impact: van code naar controle.