Artificial intelligence (AI) heeft de manier waarop we programmeren fundamenteel veranderd. AI-agents kunnen code genereren, optimaliseren en zelfs helpen bij debugging. Toch zijn er enkele beperkingen die programmeurs in gedachten moeten houden bij het werken met AI.
Het lijkt makkelijk, maar complexiteit brengt problemen
Op het eerste gezicht lijkt het alsof AI moeiteloos code kan schrijven. Eenvoudige functies en scripts worden vaak zonder problemen gegenereerd. Maar zodra een project uit meerdere bestanden en mappen bestaat, ontstaan er problemen. AI heeft moeite met het behouden van consistentie en structuur in een grotere codebase. Dit kan leiden tot problemen zoals ontbrekende of foutieve koppelingen tussen bestanden en inconsistentie in de implementatie van functies.
Problemen met volgorde en duplicatie
AI-agents hebben moeite met de juiste volgorde van code. Ze kunnen bijvoorbeeld initialisaties aan het einde van een bestand plaatsen, wat runtime-fouten veroorzaakt. Daarnaast kan AI zonder aarzeling meerdere versies van dezelfde klasse of functie definiëren binnen een project, wat tot conflicten en verwarring leidt.
Een codeplatform met memory en projectstructuur helpt
Een oplossing hiervoor is het gebruik van AI-codeplatforms die geheugen en projectstructuren kunnen beheren. Dit helpt bij het bewaren van consistentie in complexe projecten. Helaas worden deze functies niet altijd consequent toegepast. Hierdoor kan het voorkomen dat de AI de samenhang van een project verliest en ongewenste duplicaties of incorrecte afhankelijkheden introduceert tijdens het programmeren.
De meeste AI coding platformen werken met zogenaamde tools die het large language model aan kan roepen. Die tools zijn gebaseerd op een open standaard protocol (MCP). Het is dan ook mogelijk om aan een IDE zoals Visual Code aan een AI coding agent te koppelen. Eventueel kan je lokaal een LLM opzetten met llama of ollama en kies je een MCP server om mee te integreren. Modellen zijn te vinden op huggingface.
IDE-extensies zijn onmisbaar
Om AI-gegenereerde code beter te beheren, kunnen ontwikkelaars gebruik maken van IDE-extensies die toezien op code-correctheid. Hulpmiddelen zoals linters, type checkers en geavanceerde code-analyse tools helpen om fouten vroegtijdig op te sporen en te corrigeren. Ze vormen een essentiële aanvulling op AI-gegenereerde code om de kwaliteit en stabiliteit te waarborgen.
De oorzaak van herhalende fouten: context en rol in API’s
Een van de belangrijkste redenen waarom AI-agenten fouten blijven herhalen, ligt in de manier waarop AI API’s interpreteren. AI-modellen hebben context en een duidelijke rolomschrijving nodig om effectieve code te genereren. Dit betekent dat prompts volledig moeten zijn: ze moeten niet alleen de functionele eisen bevatten, maar ook het verwachte resultaat en de randvoorwaarden expliciet maken. Om dit te vergemakkelijk kun je de prompts in standaard formaat (MDC) opslaan en standaard meesturen naar de AI. Dat is vooral handig voor generieke programmeer regels die je hanteert en de functionele en technische requirements en de structuur van je project.
Tools zoals FAISS en LangChain helpen
Producten zoals FAISS en LangChain bieden oplossingen om AI beter met context om te laten gaan. FAISS helpt bijvoorbeeld bij het efficiënt zoeken en ophalen van relevante codefragmenten, terwijl LangChain helpt bij het structureren van AI-gegenereerde code en het behouden van context binnen een groter project. Maar ook hier kun je het eventueel zelf lokaal opzetten met RAC databases.
Conclusie: nuttig, maar nog niet zelfstandig
AI is een krachtige tool voor programmeurs en kan helpen bij het versnellen van ontwikkelingsprocessen. Toch is het nog niet ehct in staat om zelfstandig een complexere codebase te ontwerpen en te bouwen zonder menselijke controle. Programmeurs moeten AI beschouwen als een assistent die taken kan automatiseren en ideeën kan genereren, maar die nog altijd begeleiding en correctie nodig heeft om tot een goed resultaat te komen.
Neem contact op om te helpen de ontwikkelomgeving op te zetten om teams te helpen het maximale uit de ontwikkelomgeving te halen en meer bezig te zijn met requirements engineering en ontwerp dan met debuggen en code schrijven.
