70.000 regels code, geen documentatie en nu?

70.000 regels code. 10 jaar oud. Geen documentatie. Geen tests. De developers die het bouwden? Vertrokken.

Dit was de situatie bij een logistiek bedrijf. Hun backend systeem draaide dagelijks mee in bedrijfskritische processen. Maar niemand begreep meer hoe het werkte.

“We weten niet eens welke API endpoints er zijn.”

Herkenbaar? Je bent niet de enige.

Het probleem dat niemand durft aan te pakken

Vrijwel elke organisatie heeft er een. Dat ene systeem waar een ongeschreven regel voor geldt: niet aanraken.
Niet omdat het slecht werkt. Het draait prima. Al jaren. Maar niemand weet precies wat het doet. De oorspronkelijke developers zijn weg. De documentatie is nooit geschreven, of hopeloos verouderd. En de code? Die is in de loop der jaren zo vaak aangepast dat zelfs ervaren developers er niet meer wijs uit worden.

Het gevolg: elke aanpassing is een risico. Elke bugfix kan iets anders breken. En moderniseren? Dat wordt jaar na jaar uitgesteld, want waar begin je?

Traditionele aanpak: 9 maanden uitpluizen

De klassieke manier om een legacy systeem in kaart te brengen is handmatig. Een team van consultants leest de code, tekent diagrammen, schrijft documentatie. Bij een codebase van 70.000 regels ben je daar al snel 6 tot 9 maanden mee bezig.

En zelfs dan heb je geen garantie dat alles gedocumenteerd is. Mensen missen dingen. Zeker in code die door meerdere teams over meerdere jaren is geschreven.

Wat AI anders doet

AI leest anders dan mensen. Waar een developer code sequentieel doorneemt – bestand voor bestand, functie voor functie – kan AI de volledige codebase in een keer analyseren. Patronen herkennen. Afhankelijkheden in kaart brengen. Structuren ontdekken die voor het menselijk oog verborgen blijven.

Belangrijk: AI vervangt hier geen developers. AI doet het werk dat niemand wil doen en waar niemand tijd voor heeft. Het leeswerk. Het documentatiewerk. Het uitzoekwerk.

De developer valideert, verfijnt en besluit wat er met de inzichten gebeurt.

Het resultaat: 2 dagen in plaats van 9 maanden

Bij het logistiek bedrijf zetten we AI in op de volledige codebase van 70.000 regels. Het resultaat na 2 dagen:

• 90 API endpoints ontdekt en gedocumenteerd
• 751 unit tests gegenereerd
• Een complete OpenAPI specificatie
• Een CI/CD pipeline met automatische tests

Van “we weten niet wat we hebben” naar een volledig gedocumenteerd systeem met testdekking. In 2 dagen.

Niet 9 maanden. 2 dagen.

Waarom dit nu kan

Moderne AI-modellen hebben een contextvenster van meer dan 200.000 tokens. Dat betekent dat ze tienduizenden regels code tegelijk kunnen lezen en begrijpen. Iets wat twee jaar geleden nog onmogelijk was.

Dit maakt het voor het eerst praktisch haalbaar om een complete legacy codebase in een keer te analyseren, ongeacht de programmeertaal. Java, C#, COBOL, PL/SQL – het principe is hetzelfde.

De eerste stap is begrijpen wat je hebt

Legacy moderniseren hoeft niet te beginnen met vervangen. Het begint met begrijpen.

Welke endpoints bestaan er? Welke data stroomt waarheen? Welke business logica zit verborgen in de code? Welke afhankelijkheden bestaan er tussen modules?

Zodra je dat weet, kun je gefundeerde beslissingen nemen. Wat moderniseer je eerst? Wat kan blijven draaien? Waar zit het meeste risico?

Zonder dat inzicht ben je blind aan het bouwen. Met dat inzicht heb je een roadmap.

Herkenbaar?

Vrijwel elke organisatie heeft legacy systemen waar kennis over verloren is gegaan. De vraag is niet of je ze hebt, maar wanneer je er iets mee doet.

Wil je weten hoe AI jouw legacy systeem in kaart kan brengen? Neem contact op voor een vrijblijvend gesprek.