Maatwerk was een vies woord

Maatwerk was lang de optie die je alleen koos als niets anders werkte. En terecht. Maar die rekensom klopt niet meer.

Jarenlang was maatwerk de optie die je alleen koos als niets anders werkte. En zelfs dan voelde het als een risico.

Wie "maatwerk" hoorde, dacht niet aan leverage. Die dacht aan gedoe. Aan een project dat veel te duur werd, veel te lang duurde, en daarna vooral spannend bleef om aan te raken.

Dat beeld kwam niet uit de lucht vallen.

Maatwerk was duur. Je had een heel team nodig. Developers, een architect, een projectmanager, testers. Elk uur tikte door. Elke wijziging werd een discussie. Elke discussie werd een factuur.

Maatwerk was fragiel. Zodra het live ging, begon de echte ellende. Updates. Bugfixes. Integraties die braken. Documentatie die nergens stond, behalve in de hoofden van mensen die er niet meer werkten.

Maatwerk was traag. Eerst weken specificeren. Dan maanden bouwen. Dan testen. En als het eindelijk af was, was het oorspronkelijke probleem vaak alweer verschoven.

Dat is de echte reden dat SaaS won.

Niet omdat standaardsoftware altijd beter was. SaaS won omdat maatwerk jarenlang de verkeerde rekensom was.

En precies die rekensom verandert nu.

Ik merkte dat niet doordat ik nóg een AI-chat probeerde, maar doordat ik mijn OpenClaw-account een eigen GitHub-user gaf.

Vanaf dat moment werd het ineens concreet. Niet in de zin van "AI kan misschien ooit helpen met software", maar in de zin van: dit account kan zelf code schrijven, wijzigingen voorstellen, pull requests maken, op issues reageren als ik dat vraag, en werk oppakken in bestaande applicaties. Voor de uitvoering gebruikt het vaak Claude Code of OpenAI Codex, afhankelijk van het soort taak.

En dan wordt meteen zichtbaar wat er echt veranderd is. Niet het model op zich, maar het feit dat je van losse AI-capaciteit naar uitvoerend vermogen gaat.

1. Bouwen is goedkoper geworden

Omdat AI-agents nu een groot deel van het uitvoerende werk kunnen oppakken, kun je veel sneller software neerzetten dan een paar jaar geleden.

Niet omdat developers ineens overbodig zijn. Wel omdat een groot deel van softwarebouw altijd al bestond uit herhaalbaar werk. Schermen opzetten. Standaardlogica uitwerken. Koppelingen maken. Refactors doen. Tests schrijven. Dat soort werk kan nu veel sneller uitgevoerd of voorbereid worden.

In mijn eigen praktijk ziet dat er heel nuchter uit. Ik kan OpenClaw een taak geven, die taak laten uitzetten naar Claude Code of Codex, en daarna een voorstel terugkrijgen in de vorm van code, comments of een pull request. Cursor cloud agents en GitHub Copilot coding agent laten zien dat dit geen nichepatroon meer is. Het is een nieuwe uitvoeringslaag voor softwarewerk.

De relevante verandering is dus niet alleen dat code sneller geschreven wordt. De relevante verandering is dat één persoon nu werk kan uitzetten naar meerdere agents tegelijk, zonder voor elke stap een apart mini-project te hoeven optuigen.

Daardoor verschuift het werk naar waar het eigenlijk om hoort te draaien: de architectuur, de logica en de aansluiting op het echte proces. Niet alleen de bouwkosten dalen. Vooral ook de coördinatiekosten.

Dat is een fundamenteel verschil.

Vroeger was maatwerk vaak duur omdat bijna alles handmatig geproduceerd moest worden. Nu is het veel realistischer om snel iets bruikbaars neer te zetten zonder meteen een heel projectapparaat op te tuigen.

2. Onderhoud is minder snel een nachtmerrie

Misschien is dit zelfs de grotere verandering.

Een van de klassieke bezwaren tegen maatwerk was niet alleen de bouwfase, maar vooral alles daarna. Kleine fixes bleven liggen. Integraties verouderden. Niemand had tijd om het netjes bij te houden. Zo werd elk intern systeem langzaam een probleem dat je vooruit schoof.

Ook daar verandert de rekensom.

AI-agents kunnen vandaag een deel van monitoring, foutdetectie, kleine aanpassingen en terugkerend onderhoud op zich nemen of voorbereiden. Wat vroeger bleef liggen omdat niemand tijd had, kan nu veel slimmer worden opgevangen dan voorheen.

Dit is ook waar het voor mij persoonlijk praktisch interessant wordt. Als ik mijn OpenClaw-account een dagelijkse instructie geef om te kijken of er bugs zijn geweest in applicaties die draaien, dan kan het niet alleen signaleren dat er iets stuk ging. Het kan ook alvast taken klaarzetten, context verzamelen en in sommige gevallen al een eerste uitvoeringsstap doen.

Je ziet dat heel concreet bij Sentry Seer Autofix, dat issues analyseert, root cause analysis doet, en codefixes of zelfs een PR kan voorstellen. En aan de workflowkant zie je hetzelfde bij Linear Agents en de Codex-integratie in Linear: agents zijn daar geen gimmick, maar volwaardige uitvoerders in het werkproces, terwijl de mens accountable blijft.

Dat is belangrijker dan het misschien klinkt. Onderhoud verschuift daarmee van "iemand moet hier later nog eens induiken" naar een operationele loop waarin signalering, analyse en eerste uitvoering al voor een groot deel zijn georganiseerd.

Niet volledig automatisch. Niet zonder toezicht. Maar wel genoeg om het verschil tussen "maatwerk" en "onderhoudsprobleem" een stuk kleiner te maken.

Dat alleen al haalt veel van de oude angst uit het gesprek.

3. Leren is sneller geworden

De derde verschuiving is misschien de belangrijkste.

Omdat AI-agents ook helpen bij prototyping, itereren en testen, kun je in een dag een prototype neerzetten en in een week een eerste interne tool testen op echte data. Daardoor wordt falen goedkoper.

Voor leren en valideren zijn de voorbeelden misschien nog overtuigender. Met Codex of Claude Code kun je snel meerdere iteraties laten uitvoeren, Cursor background agents parallel laten bouwen en testen, en via OpenClaw zulke agent-runs vanuit chat of operationele workflows orkestreren.

En precies daardoor kun je veel persoonlijker en pragmatischer bouwen. Niet eerst een dikke requirementsfase, maar eerst iets werkends. In mijn wereld betekent dat vaak niet: een hele nieuwe applicatie bouwen. Het betekent: een dunne system-of-action laag neerzetten bovenop bestaande systems of record, en dan kijken of het echte werk er sneller, beter of consistenter van wordt.

Voor B2B-teams is dat misschien de echte omslag. Je hoeft niet eerst een complete applicatie uit te denken en uit te rollen. Je kunt beginnen waar de frictie zit, in routing, uitzonderingen, handoffs, triage en uitvoering, en dan in dagen zien of het proces er echt beter van wordt.

Je hoeft niet eerst een half jaar budget, planning en politiek commitment op te bouwen om erachter te komen dat je aanname niet klopt. AI-agents maken het makkelijker om sneller iets werkends tegenover de werkelijkheid te zetten. Je ziet dus sneller wat klopt. En stuurt sneller bij.

En dat verandert niet alleen hoe je bouwt. Het verandert hoe je beslist.

Want zodra experimenteren goedkoper wordt, kun je ook veel scherper kiezen wat het waard is om echt door te zetten.

Dat sluit ook aan op hoe Anthropic het zelf beschrijft in Building effective agents: de doorbraak zit niet alleen in het model, maar in systemen waarin modellen tools gebruiken, stappen uitvoeren en iteratief werk afmaken.

Dat betekent niet dat je nu alles zelf moet bouwen

Dat zou gewoon de volgende slechte reflex zijn.

De les is niet dat SaaS dood is. De les is ook niet dat elk bedrijf nu een intern softwarebedrijf moet worden.

Sterker nog, juist nu wordt de build-vs-buy vraag scherper. Systems of record koop je meestal nog steeds. Daar zit de standaardisatie. Daar zit de schaal. Maar systems of action, de laag waarin je eigen processen, beslisregels, uitzonderingen en interne workflows samenkomen, worden veel realistischer om zelf te bouwen en te blijven aanpassen.

De echte les is dat maatwerk niet meer automatisch de dure, trage en risicovolle optie is die het lang was.

Voor processen die je echt onderscheiden, kan maatwerk inmiddels juist de verstandigste keuze zijn.

Omdat het sneller te valideren is.

Omdat het beter past op hoe je bedrijf echt werkt.

En omdat een zware SaaS-implementatie in de praktijk vaak óók duur, traag en lastig te onderhouden blijkt, alleen op een andere manier.

Niet omdat agents magisch zijn. Wel omdat ze precies dat werk goedkoper maken waar maatwerk vroeger op vastliep: uitvoeren, aanpassen, testen en terugkoppelen.

Dat is in ieder geval hoe ik er nu naar kijk. Niet als theorie, maar omdat ik inmiddels in mijn eigen stack zie wat er gebeurt zodra een agent niet alleen mag meedenken, maar ook echt werk mag doen.

Maatwerk was lang een vies woord.

Voor veel bedrijven is het tijd om dat oordeel opnieuw te bekijken.

Verder lezen

• OpenClaw docs, ACP Agents
• Anthropic, Claude Code overview
• OpenAI Developers, Codex
• Cursor docs, Cloud Agents
• GitHub Docs, About GitHub Copilot coding agent
• Sentry docs, Seer Autofix
• Sentry blog, Seer is generally available
• Linear docs, Agents in Linear
• Linear, Codex integration
• OpenAI, Codex for Linear
• Anthropic Engineering, Building effective agents