Van developer naar orchestrator

Wat een jaar software ontwikkelen met AI veranderde aan onze werkwijze

Een jaar geleden schreef ik een blogpost over context engineering. Die eindigde met een belofte: we zouden uitzoeken hoeveel van ons werk we echt aan AI konden overlaten, en "daar later op terugkomen".

Dit is later.

In één jaar is de manier waarop developers bij Blastic werken meer veranderd dan in de tien jaar daarvoor. Niet omdat de tools slimmer werden (dat werden ze wel), maar omdat we veranderden wat we ze geven. Dit artikel gaat over die verschuiving in hoe we software ontwikkelen met AI: van zelf code schrijven naar het orkestreren van de mensen, de kennis en de tools die de code maken.

Een jaar geleden schreven we code

Het grootste deel van mijn loopbaan volgde ontwikkeling een voorspelbare lus. Er kwamen requirements binnen, daarna een design, wij analyseerden en schreven de code, testten, verbeterden en zetten live. Frameworks evolueerden, build pipelines werden sneller, browsers beter. Maar de relatie tussen developer en code bleef dezelfde: als een regel code bestond, had iemand hem getypt.

AI was er toen al. We gebruikten het zoals de meeste teams: als slimmere autocomplete, of als chatvenster om een foutmelding in te plakken. Handig, maar het stond naast het werk, niet erin.

Vandaag orchestreren we

Vandaag wordt het grootste deel van de code in onze projecten gegenereerd. Een developer beschrijft de wijziging, wijst de juiste bestanden, tickets en designs aan en beoordeelt wat terugkomt. De AI leest de codebase, past bestanden aan, draait de build en schrijft de documentatie.

Dat klinkt alsof de developer minder doet. In de praktijk beslist de developer meer. Elke gegenereerde wijziging moet nog altijd begrepen, getoetst aan de architectuur, getest en goedgekeurd worden, door iemand die weet wat "goed" betekent voor dit product en deze klant. Wat veranderde, is waar de tijd naartoe gaat: minder typen, meer nadenken, nakijken en beslissen.

Hoe we het aanpakken: eerst de context

Het grootste voordeel dat we meteen merkten: de kwaliteit van de output hangt veel minder af van het model dan van de context die je meegeeft. Een AI die je architectuur, je afspraken of de beslissingen van vorige week niet kent, schrijft code die er juist uitziet en het niet is.

Daarom behandelen we context als een deel van het project, met versiebeheer naast de code:

  • Projectinstructies beschrijven de architectuur, de buildcommando’s, de afspraken en wat nooit mag veranderen.
  • Een taakbestand per ticket legt het doel vast, de gewijzigde bestanden en de beslissingen onderweg. De volgende taak start van dat verslag, niet van wat iemand zich nog herinnert.
  • Regels uit fouten. Telkens als de AI iets fout doet dat opnieuw kan gebeuren, wordt de les een regel. Dezelfde fout gebeurt zelden twee keer.
  • Gekoppelde bronnen. Tickets, designs en het CMS zijn niet langer iets waar een developer tekst uit kopieert. De AI leest ze rechtstreeks, via standaardkoppelingen.

Niets daarvan vervangt de kennis van het team. Het maakt die kennis beschikbaar, op het moment dat ze nodig is, voor een tool die anders zou gokken.

Hoe context engineering evolueert

De term "context engineering" brak door in juni 2025, toen Shopify-CEO Tobi Lütke en Andrej Karpathy stelden dat hij de echte vaardigheid beter beschrijft dan "prompt engineering". Karpathy omschreef het als de kunst en wetenschap om het contextvenster te vullen met precies de juiste informatie voor de volgende stap. Ons eerste artikel ontstond in die periode.

Een jaar later zie ik drie verschuivingen:

  1. Van prompts naar systemen. Een goede prompt helpt één keer. Een goede context helpt bij elke taak daarna. Het werk verschoof van berichten opstellen naar een structuur bouwen die het hele team gebruikt.
  2. Van kopiëren naar koppelen. Het Model Context Protocol (MCP) gaf AI-tools één standaardmanier om andere systemen te bereiken: tickets, designbestanden, een CMS, een database. Sinds december 2025 valt het onder de nieuwe Agentic AI Foundation van de Linux Foundation, gesteund door de grote AI-spelers. Dat is belangrijk: het wordt infrastructuur, geen functie van één leverancier.
  3. Van context naar harnas. De context is nu deel van een groter harnas: instructies, herbruikbare vaardigheden, controles en reviewstappen rond de AI. Het eerste project betaalt de opbouw. Elk project daarna start verder.

Hoe onze werkwijze evolueert

Onze werkwijze lijkt nu minder op een productielijn en meer op een feedbacklus:

  1. Intentie: een mens beslist wat er moet gebeuren en waarom.
  2. Context: de juiste tickets, designs, code en eerdere beslissingen worden beschikbaar gemaakt.
  3. Generatie: de AI stelt de wijziging voor.
  4. Review en testen: een mens toetst ze aan de architectuur, het design en de realiteit van de klant.
  5. Vastleggen: beslissingen en lessen gaan terug in de context.

Stap 5 slaan de meeste teams over, en net die stap maakt de volgende lus sneller.

Content wacht niet meer, en houdt de ontwikkeling niet meer op

Eén verandering verraste ons het meest: hoe we met content in een CMS omgaan.

Vroeger hing ontwikkeling af van content. Om een paginasjabloon te bouwen, moest iemand eerst pagina’s aanmaken, velden invullen en afbeeldingen uploaden in het CMS, vaak met tijdelijke tekst die later weer opgeruimd moest worden. Developers wachtten op content, of maakten die zelf met de hand.

Vandaag koppelt de AI via MCP met het CMS. Hij leest het contentmodel en maakt dan zelf content aan, op basis van het design: de structuur, titels en componenten uit het designbestand worden echte content-items in het CMS. Ontwikkeling en content lopen nu naast elkaar, en testcontent is consistent, volledig en makkelijk te vervangen. Dezelfde koppeling werkt ook na de lancering: metabeschrijvingen over een hele site bijwerken, een pagina herstructureren of elke pagina nakijken op foute opmaak wordt een taak van minuten, nagekeken door een mens voor het live gaat.

Waarom de scope sneller verwerkt wordt

Wat vroeger de meeste tijd kostte in een project, was niet het typen van code. Het was alles eromheen: een ticket lezen en de drie tickets waarnaar het verwijst, uitzoeken waar een wijziging thuishoort, nagaan wat ze nog raakt, achteraf de documentatie schrijven.

Net daar is AI met de juiste context het sterkst. Hij kan een volledige codebase, de tickethistoriek en het design lezen voor hij één regel schrijft. Een wijziging in tien bestanden is niet langer tien keer zoveel werk. Analyse die een ochtend kostte, duurt nu minuten. Daardoor kunnen we meer scope aan in dezelfde sprint, ook scope die we vroeger uitstelden: toegankelijkheid, gestructureerde data, securityheaders, het opruimwerk waar niemand aan toekomt.

Waarom developers grote snelheidswinst zien

Vraag het aan developers en de meesten zeggen dat ze veel sneller werken. In een enquête van METR uit 2026 bij 349 technische medewerkers was de mediaan van de zelf gerapporteerde snelheidswinst 3x. En zo voelt het ook: code verschijnt in seconden, het herhaalwerk is weg, en een taak die op een dag werk leek, is klaar voor de lunch.

Voor afzonderlijke taken, zeker duidelijk omschreven taken in een goed gedocumenteerde codebase, is die winst echt. We zien ze elke dag.

Waarom we die winst (nog) niet overal zien

En toch zijn projecten niet drie keer sneller klaar. Daar zijn goede redenen voor.

De perceptie loopt voor op de meting. In een gerandomiseerde studie van METR uit 2025 deden ervaren open-source developers er met AI-tools 19% langer over, terwijl ze dachten dat ze 20% sneller waren geweest. METR noemt dat resultaat intussen achterhaald: developers zijn nu waarschijnlijk wel sneller, maar de nieuwe gegevens geven geen betrouwbaar beeld van hoeveel. In hun enquête merken dezelfde onderzoekers op dat de waarde die mensen rapporteren (een mediaan van 1,4 tot 2x) een stuk lager ligt dan de snelheid die ze rapporteren (3x). De eerlijke conclusie: het gevoel van snelheid is geen meting.

Het knelpunt verschuift naar begrijpen. Het is verleidelijk om AI de analyse en het bouwen in één keer te laten doen. Op papier is dat de snelste weg, in de praktijk loopt het daar mis. Sla je de review ertussen over, dan maakt de AI keuzes die je nooit zag, op basis van uitdagingen die je niet kent. Staat het resultaat er, dan moet je het begrijpen inhalen in de laatste stap en corrigeren wat jij anders had gedaan, in code die al gebouwd is. In onze ervaring kost dat vaak evenveel tijd als eerst de analyse nakijken, of meer. Dus kijken we elke analyse na voor we bouwen, in korte lussen, en testen we voor we live gaan. Van buitenaf lijkt het werk klaar zodra de output er staat. Dat is het niet: snelle output verliest de connectie met het begrijpen. En wat AI krijgt, is al onze vertaling van wat een klant wil. Developers zijn vertalers van verwachtingen en emoties. Dat kost nog altijd tijd, maar die tijd is verschoven naar het allereerste begin: context, analyse en begrijpen.

AI versterkt wat er al is. Het DORA-rapport 2025 van Google zegt het helder: AI lost de problemen van een team niet op, het versterkt wat er al is. Sterke teams worden beter, teams die het moeilijk hebben zien hun problemen groter worden. Het rapport koppelt AI-gebruik aan meer doorvoer, maar ook aan minder stabiele releases als testen en snelle feedback ontbreken.

Vertrouwen moet verdiend worden. In de Stack Overflow Developer Survey 2025 gebruikt of plant 84% van de developers AI-tools, maar meer van hen wantrouwen de juistheid van de output (46%) dan dat ze die vertrouwen (33%). Dat herkennen we: de review kun je niet overslaan.

De rest van het project ging niet sneller. Feedbackrondes, goedkeuringen, contentbeslissingen en meetings gaan aan hetzelfde tempo als vroeger. Een developer die twee keer zo snel werkt, maakt een project niet twee keer zo snel.

Waar zit de winst dan? Niet in snelheid, maar in breedte. Neem een gemiddelde feature, als voorbeeld uit ervaring: vroeger deden we drie dagen over het bouwen, voor een redelijk resultaat. Vandaag duurt het bouwen anderhalve dag, en is het resultaat beter. Maar de tijd die we winnen, gaat meteen naar een nieuwe feedbacklus: geautomatiseerde tests, triage en herwerk, en documentatie. Zo komen we weer op drie dagen uit. Het gaat niet sneller, het gaat breder. En je krijgt een rijker product.

Wat we in één jaar bereikten

Terugkijkend op het jaar is de winst niet één getal. Het is een ander vertrekpunt:

  • Elk project heeft een contextlaag: instructies, taakverslagen en regels waarop het hele team, en zijn tools, verder bouwt.
  • Kwaliteitscontroles die vroeger "mooi meegenomen" waren, zijn routine: securityheaders, toegankelijkheid, prestaties en gestructureerde data worden bij elke wijziging gecontroleerd, niet één keer voor de lancering.
  • Content en ontwikkeling wachten niet meer op elkaar.
  • Kennis verdwijnt niet met een gesprek of een persoon. Ze blijft in het project.
  • En developers bij Blastic besteden hun tijd waar het meest telt: het probleem begrijpen, de beslissingen nemen en het resultaat controleren.

Het eerste project droeg de kost van het uitzoeken van deze werkwijze. De projecten daarna startten verder.

Waar dit naartoe gaat

Voorspellingen in dit vak verouderen snel, dus ik hou het bij wat ik de komende jaren waarschijnlijk vind:

  • Langere, zelfstandigere taken. AI neemt werk op zich dat uren duurt in plaats van minuten: een volledige migratie, een complete testsuite, een toegankelijkheidsronde over een hele site. De rol van de mens schuift verder op naar het bepalen van de intentie en het beoordelen van het resultaat.
  • Context wordt een product. Teams onderhouden hun context even zorgvuldig als hun code: nagekeken, met versiebeheer en gedeeld over projecten heen.
  • Alles raakt gekoppeld. Met een open standaard als MCP wordt elk systeem dat een project raakt (tickets, design, CMS, analytics, hosting) iets waaruit een AI kan lezen en waarin hij kan handelen, binnen de grenzen die jij stelt.
  • Het meten haalt het in. Vandaag hebben we vooral zelfrapportering en kleine studies. Teams leren meten wat echt telt: doorlooptijd, kwaliteit en stabiliteit, niet het aantal regels code.
  • De developer wordt orchestrator. Technische kennis wordt niet minder belangrijk. Ze wordt net wat een veel grotere set tools en informatie laat samenwerken. Weten welk instrument je gebruikt, wanneer, met welke input, en wanneer je het niet vertrouwt: dat is het werk.

De mens blijft in de lus

Het doel was nooit de developer weg te werken. Het doel is het systeem rond de developer sterker te maken, en het met elk project verder te verbeteren.

Een jaar geleden schreven we de code. Vandaag beslissen we wat er gebouwd wordt, geven we onze tools de context om het te bouwen, en nemen we de verantwoordelijkheid voor het resultaat. Dat is niet minder werk. Het is ander werk, en ik zou niet meer terug willen.

Contacteer ons

Benieuwd wat een werkwijze met AI kan betekenen voor jouw team of platform? Neem contact op.

Laten we jouw volgende project genereren

Van design tot headless CMS, met mensen die elke beslissing nemen

We bouwden onlangs zo een multibrandplatform: AI las de designs, maakte de tickets aan en genereerde de componenten, terwijl developers bij Blastic de architectuur bepaalden en elke stap nakeken.

Halverwege vond de klant het tempo tegenvallen. Het resultaat overtuigde hen, en hun volgende project volgde.

Benieuwd wat dit voor jouw project kan betekenen? Vertel ons erover.

Velden met * zijn verplicht.

Liever bellen? Bel ons op +32 (0) 3 318 65 60

Cookie Policy

Onze site maakt gebruik van cookies om de website-ervaring te verbeteren. Door onze website te gebruiken, gaat u akkoord met ons gebruik van cookies.

Voorkeur opslaan