Hoe we ons hele platform vertaalden met AI (en wat Agile ermee te maken had)

Eind 2025 bestond het Agile Academy-platform in twee talen: Duits en Engels. Vier maanden later was het beschikbaar in acht talen. We hebben geen vertaalbureau ingehuurd. We gebruikten AI. En agile principes maakten het verschil.

Het uitgangspunt

Eén platform, twee codebases, twee talen en een groeiend internationaal publiek.

De Agile Academy is geen enkele applicatie. Het is een ecosysteem:

• Kirby CMS Knowledge Base: 440+ artikelen verdeeld over 10 secties, elk met complexe Layout JSON, kruisverwijzingen en URL-routering per taal
• Ruby on Rails Platform: Trainingsboekingspagina's, e-learningcursussen, afrekenflows, productpagina's, met locale-bestanden en views
• Backendsystemen: Mailingtemplates, facturering, transactionele e-mails
• UI-vertalingen: Menu's, footers, breadcrumbs, knoppen en de taalschakelaar zelf, over beide platformen

Dit alles bestond alleen in het Duits en Engels. Ondertussen konden we geen gecureerde content aanbieden aan niet-Engelstalige of niet-Duitstalige sprekers, een groeiend deel van ons publiek.

Dit vertalen was niet alleen een contenttaak. Elke taal vereiste:

• Nieuwe routes in Kirby's PHP-configuratie (artikeloverzichten, sectie-slug-herschrijvingen, redirects)
• Sectieniveau-contentbestanden met gelokaliseerde URL-slugs
• Overzichtspagina's, landingspagina's en structurele pagina's (juridisch, evenementen, auteurspagina's)
• ROR locale-bestanden voor menu's, footer, trainingspagina's, e-mails
• Mailingtemplates in de backend
• Cross-systeem consistentie: hetzelfde woord "artikelen" in URL's, dezelfde juridische paginakoppelingen, dezelfde menustructuur

Een traditioneel vertaalbureau zou de artikeltekst kunnen behandelen. Maar niemand ging onze PHP-routes schrijven, onze JSON-layouts repareren of onze Rails locale-bestanden bijwerken. We hadden een andere aanpak nodig.

Iteratie 1: Spaans

Kopiëren en plakken, handmatige codewijzigingen en een maand zwoegen. De waterval-aanpak.

Spaans was onze eerste uitbreidingstaal. Het proces zag er als volgt uit:

1. De tekst van een artikel kopiëren naar ChatGPT of Claude
2. De vertaling terugplakken in een nieuw bestand
3. Handmatig de Layout JSON repareren (in de hoop niets te breken)
4. 440 keer herhalen voor alleen Kirby
5. Apart ROR locale-bestanden, views en mailingtemplates vertalen
6. Handmatig routes, sectiebestanden en overzichtspagina's toevoegen in Kirby
7. Handmatig locale-bestanden en routes bijwerken in ROR
8. Handmatig mailingtemplates aanmaken in de backend

Het duurde ongeveer een maand. Alleen de belangrijkste pagina's werden vertaald in beide systemen. De kwaliteit was inconsistent. Sommige artikelen gebruikten een formele toon, andere informeel. Agile termen werden soms vertaald, soms niet. Kruisverwijzingen tussen artikelen wezen naar niet-bestaande pagina's.

Het infrastructuurwerk was nog pijnlijker. Elke route moest met de hand geschreven worden. Elk sectiebestand moest helemaal opnieuw aangemaakt worden. URL-slugs waren inconsistent. De ROR- en Kirby-platformen moesten gesynchroniseerd blijven (dezelfde menukoppelingen, dezelfde footer, dezelfde juridische pagina's), en bijhouden wat waar gedaan was, was een spreadsheet-nachtmerrie.

In agile termen was dit een klassieke waterval-oplevering: één grote batch, beperkte feedbackloops, geen automatisering, geen gedeelde standaarden. We leverden het op, maar we wisten dat we deze aanpak niet konden opschalen naar nog zes talen.

Iteratie 2: Portugees

Eerste automatisering, eerste scripts, eerste gebruik van Claude Code. Een week in plaats van een maand.

Voor Portugees veranderden we de aanpak. In plaats van één artikel tegelijk te kopiëren en plakken, schreven we scripts die de vertaling automatiseerden via API-aanroepen. Voer de Engelse bron in, krijg het vertaalde Kirby-bestand terug.

Nog belangrijker: we begonnen Claude Code te gebruiken, niet alleen voor artikelinhoud, maar voor het infrastructuurwerk. Claude Code kon onze bestaande Spaanse routes lezen en de Portugese equivalenten genereren. Het kon sectiebestanden, overzichtspagina's aanmaken en configuratiebestanden bijwerken.

Aan de ROR-kant genereerde Claude Code locale-bestanden door te refereren aan de bestaande Spaanse vertalingen. Het werkte mailingtemplates bij, creëerde nieuwe views waar nodig, en hield de cross-systeem referenties consistent.

Het resultaat: ongeveer een week in plaats van een maand. Maar het foutenpercentage was nog steeds hoog.

De scripts begrepen geen context. Ze vertaalden "Sprint" naar het Portugees. Ze braken Layout JSON door regelafbrekingen toe te voegen binnen strings. URL-slugs klopten soms niet omdat de AI onze routeringsconventies voor beide platformen niet kende.

We besteedden aanzienlijke tijd aan beoordelen en repareren. Maar cruciaal: we waren nu aan het inspecteren en aanpassen. Elke fout die we vonden werd een regel voor de volgende iteratie. We begonnen een woordenlijst. We verfijnden de vertaalprompt. We documenteerden de URL-conventies die beide platformen moesten volgen.

Iteraties 3–6: Frans, Italiaans, Nederlands, Pools

Gespecialiseerde agents, institutionele kennis en twee dagen per taal.

Tegen de tijd dat we bij Frans waren, was het systeem aanzienlijk volwassener geworden. Wat echt het verschil maakte was het opsplitsen van het werk.

In plaats van één groot AI-context dat alles probeerde te verwerken, creëerden we gespecialiseerde agents, elk gericht op één deel van het systeem:

• Contentvertaalagents die batches van Kirby-artikelen verwerkten, volgens de vertaalprompt en woordenlijst
• Infrastructuuragents die routes, sectiebestanden en overzichtspagina's aanmaakten in Kirby
• ROR locale-agents die locale-bestanden voor het Rails-platform vertaalden en aanmaakten
• Verificatieagents die scripts draaiden om kapotte JSON, verkeerde URL-slugs en ontbrekende velden op te sporen

Elke agent had een verkleind contextvenster gericht op zijn specifieke taak. Dit leverde veel betere resultaten op dan één agent die het hele platform in het geheugen probeerde te houden.

De institutionele kennis was nu vastgelegd:

• Een vertaalprompt (TRANSLATION_PROMPT.md) definieerde toon, format, URL-regels en de vereiste AI-melding
• Een woordenlijst (glossary.json) hield agile termen consistent over alle talen
• Verificatiescripts vingen fouten op voordat ze productie bereikten: kapotte Layout JSON, verkeerde hreflang-verwijzingen, ontbrekende verplichte velden
• Een checklist in CLAUDE.md documenteerde elke infrastructuurstap die nodig was voor een nieuwe taal (routes, sectiebestanden, overzichtspagina's, structurele pagina's, menu/footer-synchronisatie)
• Cross-systeem consistentiecontroles zorgden ervoor dat Kirby en ROR gesynchroniseerd bleven

Italiaans duurde twee dagen. Nederlands duurde twee dagen. Pools duurde twee dagen. Elke iteratie was sneller en betrouwbaarder. Het foutenpercentage daalde met elke taal omdat het systeem leerde van elke eerdere fout.

Ervoor en erna

Dezelfde taak. Een fundamenteel ander systeem.

De agile principes in de praktijk

Dit was niet alleen een vertaalproject. Het waren zes Sprints van organisatorisch leren.

Iteratieve verbetering

Elke taal was een Sprint. Spaans was Sprint 1: langzaam, handmatig, vol leermomenten. Pools was Sprint 6: snel, geautomatiseerd, verfijnd. De verbetering was exponentieel. Elke iteratie voegde niet alleen een taal toe. Het verbeterde het systeem voor alle toekomstige talen.

Inspecteren en aanpassen

Elke fout in één taal werd een preventieregel voor de volgende. Kapotte JSON? Voeg een JSON-validator toe aan het verificatiescript. "Sprint" vertaald naar het Portugees? Voeg het toe aan de woordenlijst. Verkeerde URL-slug-conventie? Documenteer het in de checklist. Het systeem werd slimmer omdat we feedbackloops erin bouwden.

Zelforganiserende teams

De gespecialiseerde agents waren in feite zelforganiserende teamleden. Elk had een duidelijke verantwoordelijkheid, de juiste context voor zijn taak en gedefinieerde interfaces met de anderen. De content-agent hoefde niets te weten van PHP-routes. De infrastructuur-agent hoefde geen Layout JSON te parsen. Scheiding van verantwoordelijkheden. Het werkt voor software en voor teams.

Werkende software boven documentatie

De vertaalprompt, de woordenlijst, de verificatiescripts. Niets hiervan was vooraf ontworpen. Het kwam voort uit echte problemen die we tegenkwamen tijdens echt werk. De prompt werd vijf keer herschreven. De woordenlijst groeide met elke taal. De scripts ontstonden uit fouten die door handmatige review heen glipt waren. Levende documentatie, gevormd door daadwerkelijk gebruik, bleek veel nuttiger dan welke specificatie we ook vooraf hadden kunnen schrijven.

Reageren op verandering

Onze architectuurbeslissingen werden gedreven door fouten, niet door voorafgaande planning. We voorspelden niet dat Layout JSON de grootste bron van bugs zou zijn. We ontdekten het tijdens Spaans en bouwden validatie ervoor vóór Portugees. We planden de agent-specialisatie niet. We kwamen erbij na te zien dat één groot context slechtere resultaten produceerde dan meerdere gefocuste. We eindigden met een betere opzet dan wat we ook op een whiteboard hadden kunnen ontwerpen.

Belangrijkste lessen

AI vervangt agile denken niet. Het versterkt het.

1. AI versterkt je proces, ten goede of ten kwade

Als je proces chaotisch is, produceert AI sneller chaos. Als je proces gedisciplineerd is (duidelijke prompts, gedefinieerde standaarden, verificatieloops), produceert AI kwaliteit op schaal. Dezelfde tool die onze JSON brak in iteratie 1 produceerde foutloze output in iteratie 6. De AI veranderde niet. Ons proces wel.

2. Context is alles

De woordenlijst, de vertaalprompt, de checklist, de cross-systeem consistentieregels. Dit zijn allemaal vormen van context. Een AI zonder context is gewoon een snelle vertaler. Een AI met de juiste context is een teamlid dat je conventies, je randgevallen en je kwaliteitsnormen begrijpt. Die context opbouwen is waar het echte werk zit — en het wordt meer waard met elke nieuwe taal die je toevoegt.

3. De menselijke rol verschuift van uitvoerder naar architect

In iteratie 1 deden mensen het vertalen. In iteratie 6 ontwierpen mensen het systeem, definieerden de standaarden, beoordeelden de output en verbeterden het proces. Het werk verdween niet. Het verschoof naar een hoger denkniveau. Minder kopiëren en plakken, meer nadenken over wat een goede vertaling is, wat een consistente gebruikerservaring oplevert, en hoe je fouten opvangt voordat gebruikers ze tegenkomen.

4. Begin klein, lever op, leer, herhaal

We hadden maanden kunnen besteden aan het ontwerpen van de "perfecte" vertaalpipeline voordat we één artikel vertaalden. In plaats daarvan begonnen we met kopiëren en plakken en itereerden. Elke taal leerde ons iets. Elke fout verbeterde het systeem. Tegen de tijd dat we bij de latere talen waren, hadden we een pipeline die geen enkele hoeveelheid voorafgaande planning had kunnen opleveren — omdat het gevormd was door echte problemen, niet door hypothetische.