De meeste softwareontwikkelaars, tech leads en DevOps-engineers beginnen hun loopbaan als bouwers.

Ze bouwen systemen, apps, componenten, thema's, patronen, modules en pipelines. Ze optimaliseren lay-outs, lossen randgevallen op, bewaken de compatibiliteit en brengen systemen commit voor commit vooruit. Het werk is nauwkeurig, praktisch en diep technisch.

Maar op een bepaald moment verschuift er iets.

De beste vakmensen stoppen niet met bouwen, maar ze gaan in systemen denken.

Van bouwer naar systeemdenker

De verschuiving: van resultaat naar regels

Als bouwer richt je je op het resultaat: componenten, templates, pagina's, functies, bibliotheken, applicaties.

Als systeemdenker verschuift die focus naar regels: beperkingen, interacties, feedbackloops.

In plaats van te vragen "Hoe ziet dit component eruit?" stellen systeemdenkers andere vragen: welke regels sturen dit component? Waarmee mag het samenwerken? Hoe gedraagt het zich bij verandering? Hoe blijft de intentie behouden in de loop van de tijd?

Die verschuiving leidt vanzelf naar agentische systemen.

Wanneer ontwerp stopt statisch te zijn

Moderne designsystemen leggen al logica vast: tokens bepalen beperkingen, componenten bepalen structuur, patronen bepalen gedrag.

Toch zijn de meeste systemen nog altijd afhankelijk van veel menselijke regie.

AI-agents brengen een ander model: systemen die hun eigen regels kunnen afdwingen, beslissingen voortdurend valideren, op context reageren en intern onderling afstemmen.

Hier groeit ontwerp van documentatie uit tot uitvoerbare logica.

Waar dit naartoe gaat

De focus ligt nu op het toepassen van deze ideeën in echte, werkende systemen, niet als experimenten maar als fundament.

1. Diepere integratie van AI-agents met ontwerptools (Figma)

Op weg naar agentische designsystemen

Ontwerptools mogen geen passieve canvassen zijn.

Het doel is AI-agents in Figma te integreren die designtokens en componentbeperkingen begrijpen, beslissingen realtime valideren, ontwerpintentie vertalen naar regels op systeemniveau en optreden als medewerkers, niet als exporteurs.

Zo verschuift ontwerp naar de bron, waar de intentie behouden blijft in plaats van later te worden afgeleid.

2. Schaalbaar beheer van AI-agents

Doel: 150 agents, één per component

In plaats van één AI voor alles, bewegen teams zich naar veel gespecialiseerde agents.

Elk component krijgt zijn eigen agent met vastgelegde verantwoordelijkheden, duidelijke grenzen en kennis van verwante componenten.

Zo schalen gezonde systemen: door specialisatie, afstemming en heldere afspraken.

3. Agents met echte vaardigheden, tools en plug-ins

Agents moeten kunnen handelen.

Dat betekent dat ze worden uitgerust met vaardigheden (redeneren over toegankelijkheid, ontwerpvalidatie, oog voor prestaties), tools (linters, testrunners, design-API's) en plug-ins (Storybook, Drupal, CI-pipelines, Figma-integraties).

Een agent zonder tools blijft theorie. Een agent met tools wordt onderdeel van het systeem zelf.

4. Slimmer geautomatiseerd functioneel acceptatietesten

AI-gestuurd en bewust van intentie

Traditioneel testen controleert de uitvoer. Testen met agents begrijpt gedrag.

De focus ligt op AI-agents die redeneren over gebruikersreizen, functionele tests die de intentie begrijpen in plaats van alleen selectors, systemen die tests meegroeien met componenten, en het terugdringen van breekbare tests terwijl het semantische vertrouwen toeneemt.

Testen wordt een extra laag van systeemintelligentie.

TDD & BDD in het tijdperk van AI: waarom AI-agents 100% meer test-first ontwikkelen vragen

Waarom dit ertoe doet

Teams bouwen systemen die hun makers overleven, zich voortdurend aanpassen en langetermijnbeslissingen over ontwerp meedragen.

In zo'n wereld schaalt handmatige controle niet. Goed gedefinieerde regels wel.

Ontwerpers, ontwikkelaars en AI-agents moeten binnen hetzelfde logische kader werken: één gedeeld systeem van beperkingen en intentie.

De stap van bouwer naar systeemdenker betekent niet dat je de uitvoering loslaat. Het gaat erom systemen te zien als meer dan een verzameling onderdelen.

De volgende stap is het ontwerpen van de regels waarmee systemen kunnen redeneren, zich aanpassen en evolueren.

Softwareontwikkelaars, tech leads en DevOps-engineers die deze stap zetten, bouwen niet alleen: ze scheppen de voorwaarden waaronder systemen zichzelf bouwen.