Code generatie met LLMs: hoe wij Python-automatiseringen
10× sneller bouwen
Grote taalmodellen veranderen hoe software gebouwd wordt. Niet door ontwikkelaars te vervangen — maar door de verhouding tussen denken en typen radicaal te verschuiven. Wij leggen uit hoe wij dit in de praktijk toepassen, inclusief de valkuilen die je moet kennen.
Het oude model vs. het nieuwe
Traditioneel softwareontwikkeling: je bedenkt een oplossing, zoekt de juiste libraries, schrijft de code, debug je de fouten, test je de edge cases. Voor een middelgrote automatisering ben je al snel een dag verder.
Met LLM-ondersteunde ontwikkeling verschuift het werk. De implementatiedetails — de boilerplate, de API-aanroepen, de foutafhandeling — genereert het model. Jij focust op architectuur, logica en kwaliteitscontrole.
Hoe wij het concreet toepassen
Onze aanpak bij het bouwen van automatiseringen bestaat uit vier stappen waarbij het LLM structureel is ingebouwd:
Stap 1 — Specificatie als prompt. Voordat er een regel code wordt geschreven, schrijven wij een gedetailleerde beschrijving van wat de automatisering moet doen. Input, output, randgevallen, foutafhandeling. Dit document stuurt het model en dient later als documentatie.
Stap 2 — Gerichte generatie per module. Wij genereren code per functie of module, niet als één grote blob. Kleinere context = betere output = minder fouten.
# Prompt aan het model:
# "Schrijf een Python FastAPI endpoint dat een webhook ontvangt
# van een CRM systeem, de data valideert via Pydantic,
# een lead-score berekent op basis van company_size en industry,
# en het resultaat wegschrijft naar Supabase.
# Gebruik async/await. Voeg foutafhandeling toe voor
# netwerkfouten en validatiefouten."
# Output: werkende code in ~30 seconden
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import anthropic
app = FastAPI()
class LeadWebhook(BaseModel):
company_name: str
company_size: int
industry: str
contact_email: str
@app.post("/webhook/lead")
async def process_lead(lead: LeadWebhook):
score = calculate_lead_score(lead.company_size, lead.industry)
await save_to_supabase(lead, score)
return {"status": "processed", "score": score}
Stap 3 — Review en testen. Gegenereerde code wordt altijd gereviewd en getest. Het model maakt geen fouten in de logica die het begrijpt, maar kent jouw specifieke context niet. Die laag voeg jij toe.
Stap 4 — Iteratie via dialoog. Werkt iets niet? Beschrijf het probleem aan het model. "De Pydantic validator gooit een error bij None-waarden in het adresveld" levert in de meeste gevallen direct een correcte fix.
"Het model schrijft de code. Jij bewaakt de architectuur en de kwaliteit."
De valkuilen die je moet kennen
LLM-ondersteunde ontwikkeling is krachtig, maar niet foutloos. Drie valkuilen die wij zelf zijn tegengekomen:
- Verouderde libraries — modellen zijn getraind op data tot een bepaalde datum. API's veranderen. Controleer altijd of de gegenereerde imports en methodes nog actueel zijn.
- Zelfverzekerde fouten — het model presenteert incorrecte code soms even overtuigend als correcte code. Testen is niet optioneel, het is de kwaliteitslaag die jij levert.
- Context-verlies bij grote codebases — bij complexe systemen verliest het model overzicht. Ons advies: werk modulair, houd prompts gefocust en geef altijd relevante bestaande code als context mee.
Wat dit betekent voor jouw bedrijf
Je hoeft geen ontwikkelaar te zijn om hiervan te profiteren. Je hebt wel iemand nodig die weet welke vragen hij aan het model moet stellen, de output kan beoordelen en het geheel kan integreren in jouw systemen.
Dat is precies wat wij doen. De technologie maakt ons sneller. De expertise maakt het betrouwbaar.
Een automatisering laten bouwen?
Wij bouwen Python-automatiseringen die direct aansluiten op jouw systemen. Van webhook-verwerking tot volledige data-pipelines.
Vraag een gesprek aan