Waarom je intuïtie bij AI-ontwikkeling nog steeds goud waard is
Schattend schatten in het AI-tijdperk
Vroeger kon je als developer vrij precies zeggen: die feature zit in twee weken. Tegenwoordig? Met AI die niet alleen code aanvult maar hele oplossingen bedenkt en bouwt, is dat een gokwerk geworden.
De klassieke aanpak (die best oké was)
In de puur menselijke dev-wereld hing een schatting af van simpele factoren:
- Kennis van de codebase + Ontwerpslimheid + Tik-snelheid + Test- en debug-tijd = Realistische deadline
Je kende de codebase door en door. Wist precies waar de auth-module robuust was en de DB-schema een chaos. Zo rekende je uit: zoveel uur refactor, zoveel edge cases, en je dagelijkse productiviteit.
Het was nooit 100% accuraat – vaak 20-40% overschrijding – maar het zat in de buurt. Je had een werkend mentaal model.
AI-agenten gooien alles om
Geef hetzelfde probleem aan een AI-tool en de spelregels veranderen totaal:
Snap die de architectuur in één keer? Hangt af van je docs, contextlimieten en hoe goed het model jouw stack beheerst.
Komt de perfecte oplossing meteen? Raak je het in één run, dan uren werk. Anders dagenlang prompten en itereren.
Hoeveel herschrijf je zelf? AI-code vraagt vaak aanpassingen voor security, integratie en finetuning.
Kortom: te veel onvoorspelbare factoren buiten jouw bereik als developer.
De 'gevoelens-schatting' die niemand hardop zegt
Veel devs doen stiekem aan 'gevoelens-coding':
- Gokken op basis van AI-snelheid, niet op feature-complexiteit
- Hopen op een first-try hit, zonder iteratie in te kalkuleren
- Integratiewerk onderschatten tussen AI-output en je systemen
- Hallucinaties of kwetsbaarheden overschatten in fix-tijd
Geen luiheid, maar oude tools passen niet meer bij deze wereld.
Wat wél werkt (praktische tips)
Lukt schatten met AI niet? Dit helpt teams vooruit:
1. Test AI-prestaties eerst
Voordat je belooft: probeer kleine features. Klok de inference-tijd, tel iteraties en tel revisies. Echte data, geen giswerk.
2. Splits mens- en machine-tijd
Geen eenheid meer. Maak het concreet:
- AI-fase: Prompts, generatie, eerste output
- Mens-fase: Review, security-check, refactor
- Integratie-fase: Koppelen, testen, debuggen
Zo schat je alleen wat je écht beheerst – voorspelbaarder.
3. Maak context-pakketten
AI faalt zonder bagage. Besteed 2-3 uur aan docs, conventies en voorbeelden. Output wordt beter, minder loops, kortere totale tijd.
4. Bouw buffers in voor onzekerheid
Geen '5 dagen' meer. Zeg '3-8 dagen, afhankelijk van de AI'. Eerlijker en handiger voor planning.
5. Meet en tweak je workflow
Elk team vindt z'n eigen AI-goud. Diep prompten? Iteratief finetunen? Log resultaten per stack en team, pas schattingen aan.
De echte shift
Die onrust over schattingen? Dat is geen falen van jou. Het is de softwarewereld die verandert. Van 'hoe lang coderen mensen dit?' naar 'hoe lang snapt AI het, stelt het voor, en checken/integreren wij?'.
Lastig te voorspellen door variabelen als:
- Model-kwaliteit en snelheid
- Probleem-fit met trainingsdata
- Je codebase-docs en structuur
- Hoe goed je team AI stuurt
Het positieve nieuws
Upside: als AI het meteen raakt – en dat komt vaker voor dan je denkt – ship je in dagen wat weken kostte. Hogere spreiding, maar betere gemiddelde snelheid.
Erken die variatie, meet hem strak, pas je modellen aan.
Hoe verder?
Succesvolle devs omarmen dit:
- Accepteren dat schatten rommeliger is
- Meten obsessief hun AI-flow
- Bouwen slimme context en prompts
- Geven ruime, eerlijke ranges
- Shippen snel en leren per ronde
Dat 'gevoelens-coding'? Misschien de nieuwe realiteit van slim ontwikkelen – schatten mét AI, niet ertegen.