Pillar page

AI-softwareontwikkeling

Een beproefd proces voor het automatiseren van softwareontwikkeling met een team van AI-agenten — van requirements-analyse, via codering en meerlaags testen (unit, integratie, E2E, security, performance), tot productie-deployment met een volledige audit trail.

Laten we praten over een pilot Onze diensten

We beschikken over een team van gespecialiseerde AI-agenten dat deelneemt aan elke fase van de softwareontwikkelingscyclus — van requirements-analyse, via architectuurontwerp, codering en meerlaags testen, tot code review, documentatie en deployment met een volledige audit trail.

Zo bouwen we onze eigen ESKOM AI-producten — het multi-agent platform HybridCrew, het auditsysteem Compliance, de KRS+CRBR-microservice en een portfolio van integraties. Hetzelfde proces passen we toe in klantprojecten: zowel bij het bouwen van nieuwe microservices als bij de modernisering van legacysystemen.

Dit artikel beschrijft hoe het in de praktijk werkt: welke taken de agenten overnemen, welke aan de kant van de mens blijven, welke tests we uitvoeren en waarom dit proces herhaalbaar is.

Waarom ontwikkeling automatiseren?

Een klassieke softwareontwikkelingscyclus (analyse → code → tests → review → deploy) duurt in een volwassen team doorgaans 2-4 weken voor een gemiddelde feature. Het grootste deel van die tijd gaat naar repetitieve taken: boilerplate schrijven, unit-tests genereren, wijzigingen reviewen, documentatie bijwerken, databasemigraties genereren. Allemaal vatbaar voor automatisering.

Het doel van ons proces is eenvoudig: twee of drie mensen die met AI-agenten werken leveren de waarde van een team van 8-10 personen — zonder burn-out, met hogere kwaliteit (meer tests, betere code review, volledige documentatie) en een kortere time-to-market.

Dit is niet „AI vervangt ontwikkelaars". Dit is „ontwikkelaars met AI vervangen ontwikkelaars zonder AI". Ervaren engineers blijven onmisbaar — ze ontwerpen architectuur, nemen strategische beslissingen, reviewen complexe wijzigingen. De agenten nemen de routine over.

Zes fasen van het proces

De pipeline van requirements tot productie. Elke fase wordt uitgevoerd door gespecialiseerde AI-agenten, terwijl mensen toezicht houden en belangrijke beslissingen goedkeuren.

Requirements-analyse en architectuur

AI-agenten analyseren bedrijfsdocumentatie, klantgesprekken (uit transcripten) en bestaande code. Ze stellen een microservice-architectuur, databaseschema, lijst met endpoints en rechtenmodel voor. Een mens (CTO/architect) reviewt en keurt het voorstel goed voordat het coderen begint.

Code schrijven (TDD)

Eerst tests, dan implementatie. Een backend-agent schrijft API's in FastAPI/Express, een frontend-agent schrijft React-componenten. Elke wijziging is een aparte pull request met een nette commit-message. Coderingsstandaarden (Black, ESLint, Prettier) worden automatisch afgedwongen.

Meerlaags testen

Unit (pytest, Jest), integratie (testcontainers met echte PostgreSQL), E2E (Playwright), UI snapshot, security (OWASP, gitleaks, bandit), performance (k6/locust), toegankelijkheid (axe). Elke PR doorloopt de volledige pipeline — een gefaalde test blokkeert de merge.

AI-code review

Een SecurityReviewer-agent scant op OWASP Top 10-issues, een QualityReviewer-agent controleert leesbaarheid en patronen, een ArchitectureReviewer-agent verifieert consistentie met de rest van het systeem. Twijfelgevallen worden geëscaleerd naar een mens.

Documentatie en CHANGELOG

Elke wijziging in logica = versiebump + entry in CHANGELOG.md in het Keep a Changelog-formaat. API-documentatie (OpenAPI/Swagger) wordt automatisch gegenereerd. CLAUDE.md wordt na elke sessie bijgewerkt met nieuwe lessen.

Deployment met Change Request

Deployment gaat altijd via Git (NOOIT directe scp). Eerst de testomgeving met Playwright-verificatie, daarna productie na CR-goedkeuring. Het deployscript bevat een rollbackplan (<5 min) en health checks.

Wat wint het bedrijf?

Duizenden geautomatiseerde tests

Elk productieproject heeft enkele duizenden tot tienduizenden tests — unit, integratie, E2E, security, performance. Regressies worden in CI opgevangen voordat ze gebruikers bereiken.

Volledige audit trail

Elke wijziging in code, database of configuratie wordt vastgelegd: Git, audit log in de database, CHANGELOG, Change Request. Voldoet aan de eisen van ISO 27001, EU AI Act en AVG.

Schaalbaarheid van het team

Twee of drie mensen met AI-agenten leveren de waarde van een team van 8-10 personen. Zonder burn-out, met hogere kwaliteit en kortere timelines.

Escalatie naar sterkere modellen

LLM-routing kiest het juiste model per taak: kleine wijzigingen — lokale Ollama (kosten $0), complexe architectuur — Claude Opus. Kosten- en kwaliteitsoptimalisatie in één.

Herhaalbaarheid en standaarden

Elk project hanteert dezelfde standaarden: feature branch workflow, squash merge, Conventional Commits, CHANGELOG, EU AI Act, AVG. Een nieuwe ontwikkelaar begrijpt de structuur op dag één.

Security by default

Gitleaks op pre-commit + CI, secrets in HashiCorp Vault, private repositories, Keycloak SSO, Tailscale VPN voor interne services. Geen concessies aan snelheid.

Meerlaags testen — het fundament van kwaliteit

Elke wijziging in productiecode doorloopt een volledige testpipeline. Geen uitzonderingen — zelfs een typefout in een commentaar herstellen triggert CI, omdat de testpipeline wordt afgedwongen door een Git hook, niet door een politieke beslissing van een ontwikkelaar.

Unit-tests: pytest, Jest, vitest. Dekken individuele functies en klassen. >80% dekking op kritieke code.
Integratietests: testcontainers met echte instances van PostgreSQL, Redis, Vault. Mocks alleen voor externe third-party API's.
End-to-end (E2E)-tests: Playwright in Firefox (standaard), Chrome (optioneel). Simuleren volledige gebruikerspaden: login → actie → verificatie.
UI-tests (snapshot, toegankelijkheid): Playwright + axe-core. WCAG 2.0 AA als baseline, Lighthouse 100/100/100/100 als doel.
Security-tests: OWASP Top 10 (semgrep, bandit, eslint-plugin-security), gitleaks (secret scanning op pre-commit en CI), trivy (Docker-image scanning).
Performance-tests: k6 of locust voor load-tests, controle van p95/p99-responstijden onder belasting.
Regressietests: de volledige suite draait voor elke productie-deploy. Elke gemelde bug wordt een regressietest.
Smoke-tests: een minimale set van 5-10 tests die na de productie-deploy worden uitgevoerd (is de applicatie überhaupt opgekomen).
Acceptatietests: bedrijfstests (Cucumber/Gherkin) die bevestigen dat aan de eis is voldaan.

Een gefaalde test = geblokkeerde merge. Geen uitzonderingen. Als een test „flaky" is (instabiel), analyseert een diagnostische agent de oorzaak en repareert de test of de code, maar verwijdert nooit een test zonder beslissing van een mens.

Typische use cases

De patronen die we het vaakst toepassen. Elk komt met zijn eigen set agenten, tools en templates. Time-to-value gemeten in weken, niet in maanden.

Modernisering van legacysystemen

•Oude monolithische applicatie (PHP/.NET, geen tests, moeilijk te onderhouden)
•Agenten splitsen de monoliet op in microservices (incrementeel proces, zonder downtime)
•Genereren karakteriseringstests (vastleggen van huidig gedrag) voor refactoring
•Datamigratie met volledige audit trail en rollbackplan

Nieuwe enterprise microservice

•Specificatie aan de input (Jira ticket, PRD-document, vergadertranscript)
•Architectuur → code → tests → review → deploy in 2-3 weken
•Integratie met bestaande SSO (Keycloak), audit log, monitoring
•Volledige naleving van EU AI Act en AVG vanaf de eerste regel code

Systeemintegratie

•Koppelen van ERP, CRM, KRS, Microsoft Graph, IBM, Cisco, externe partners
•Agenten schrijven adapters, mappings, retry/backoff, idempotentie
•Integratietests op echte endpoints (sandbox-API's)
•Monitoring (Prometheus + Grafana) en alerts (Sentry) automatisch aangesloten

Multi-tenant platforms

•Multi-client SaaS met volledige data-isolatie (per-tenant schema of row-level security)
•Geautomatiseerde klant-onboarding (Keycloak provisioning, database, rollen)
•Billing op basis van SSO Billing SDK (token usage tracking, fail-open)
•Compliance: AVG, ISO 27001, EU AI Act audit-ready

Vergelijking: klassiek team vs. AI-gedreven proces

Aspect	Klassiek team (8-10 personen)	Team met AI-agenten (2-3 personen)
Time-to-market (gemiddelde feature)	2-4 weken	3-7 dagen
Testdekking	40-60% (als het team tijd heeft)	>80% standaard (tests gegenereerd samen met code)
Code review	1 persoon, gemiddeld 30-60 min	3 agenten (security, quality, architecture) + mens bij complexe wijzigingen
Documentatie	Vaak onvolledig, „achteraf bijgewerkt"	Gegenereerd samen met code (OpenAPI, README, CHANGELOG)
Audit trail	Git history	Git + audit log in database + CHANGELOG + Change Request
Schaling	Lineair (meer mensen = hogere communicatiekosten)	Niet-lineair (meer agenten = hetzelfde aantal mensen houdt toezicht)
Compliance (EU AI Act, AVG, ISO 27001)	Vaak externe audit achteraf	Vanaf de eerste regel code in het proces ingebouwd

Veelgestelde vragen

Wat is geautomatiseerde AI-softwareontwikkeling?

Het is een proces waarin gespecialiseerde AI-agenten deelnemen aan elke fase van de softwareontwikkelingscyclus: van requirements-analyse, via architectuurontwerp, codering, geautomatiseerde tests (unit, integratie, E2E, security, performance, regressie), tot code review en productie-deployment. Mensen houden nog steeds toezicht op het proces en nemen belangrijke beslissingen, maar routinetaken (code schrijven, tests genereren, refactoring, documentatie) worden uitgevoerd door AI-agenten met behoud van de afgesproken kwaliteitsstandaarden.

Hoe verschilt dit proces van klassiek programmeren met Copilot?

Copilot is autocomplete — het helpt bij het schrijven van individuele regels code. AI-softwareontwikkeling is volledige orkestratie: één agent plant de architectuur, een tweede schrijft de code, een derde schrijft de tests, een vierde doet code review, een vijfde deployt. Elk heeft zijn eigen specialisatie, episodisch geheugen (het leert van eerdere projecten), tools en context. Het resultaat: een veel grotere schaal van automatisering dan met een enkele Copilot, met behoud van enterprise-standaarden (tests, security, audit trail).

Welke soorten tests draait dit proces?

Elke soort test die volwassen ontwikkelteams gebruiken: unit, integratie, end-to-end (E2E), UI (Playwright), security (OWASP Top 10, gitleaks), performance (load), regressie, smoke en acceptatie. Tests worden geschreven voor of parallel aan de code (TDD), en elke wijziging moet de volledige pipeline doorlopen.

Deployt AI zelfstandig code naar productie?

Nee, niet automatisch. Productie-deployments vereisen een goedgekeurde Change Request (CR) en een menselijke beslissing. AI-agenten bereiden wijzigingsdocumentatie voor, voeren regressietests uit, genereren deployscripts met rollbackplannen, maar de uiteindelijke productie-uitrol vereist goedkeuring van een operator. Deze regel is bewust — hij minimaliseert het risico op onverwachte gevolgen en behoudt een volledige audit trail.

Werkt dit proces voor enterprise-projecten?

Ja. We gebruiken het in onze eigen producten, waaronder het multi-agent platform HybridCrew, het consultingplatform met SSO, microservices op PostgreSQL, integraties met externe systemen (KRS, MS Graph, IBM, Keycloak). Elk project heeft zijn eigen CI/CD-pipeline, dev/test/prod-omgevingen, monitoring en audit log. Het proces schaalt van een enkele microservice tot een multi-container platform.

Hoe lang duurt het om dit proces in ons bedrijf uit te rollen?

Het hangt af van de context. Voor een klein team (1-3 ontwikkelaars) duurt integratie met het bestaande repository en CI/CD-pipeline doorgaans 2-4 weken: audit, agentconfiguratie, afstemming op coderingsstandaarden, training. Voor grotere organisaties duren pilotprojecten (één team, één microservice) 6-8 weken, gevolgd door geleidelijke uitbreiding naar extra teams.

Hoe zit het met de beveiliging van de broncode?

Repositories van de klant verlaten nooit zonder expliciete toestemming naar externe diensten. Standaard draait het hele proces (AI-agenten, LLM-modellen, vector database, audit log) in de infrastructuur van de klant of in de private cloud van ESKOM AI met volledige isolatie. Secrets worden beheerd via HashiCorp Vault, code wordt voor elke commit gescand met gitleaks, en alle repositories zijn standaard privé.

Vervangt u ons ontwikkelteam?

Nee. Ervaren ontwikkelaars zijn onmisbaar — ze ontwerpen architectuur, nemen beslissingen, reviewen complexe wijzigingen, lossen ongewone problemen op. AI-agenten nemen repetitieve, voor automatisering geschikte taken over: boilerplate schrijven, tests genereren, documentatie, refactoring, eerstelijns code review. Het doel: twee of drie mensen met AI leveren de waarde van een team van 8-10 personen — zonder burn-out, met hogere kwaliteit en een volledige audit trail.

Wat kost AI-softwareontwikkeling?

Prijzen zijn altijd projectspecifiek en hangen af van de schaal, het factureringsmodel (platformabonnement vs. dedicated project), de benodigde integraties en of de agenten draaien op lokale LLM-modellen (Ollama op de GPU van de klant — lagere operationele kosten) of in de cloud (Anthropic, OpenAI — hogere flexibiliteit). In pilots streven we naar return on investment binnen het eerste kwartaal na volledige livegang.

Wat zijn typische signalen dat een bedrijf klaar is voor dit proces?

De beste resultaten komen van teams die al hebben: een versiebeheerd repository (Git), gedefinieerde coderingsstandaarden, een basis CI/CD-pipeline, duidelijk gedocumenteerde requirements (Jira/Linear/eigen tool) en een code review-cultuur. Het ontbreken van een van deze elementen blokkeert de uitrol niet — we beginnen dan met een audit en fundamenteel werk. De minst volwassen organisaties zijn die zonder versiebeheer of met productiecode die niemand test.

Klaar voor een pilot?

We beginnen met een audit van het bestaande proces en een pilot op een geselecteerde microservice. Eerste resultaten zichtbaar binnen 2-4 weken. Geen langetermijncontracten vereist.

Plan een gesprek Bekijk onze producten