In het eerste artikel van deze reeks legden we uit hoe je een computer klaarmaakt voor vibe coding. We installeerden Linux, configureerden Codex en Antigravity, koppelden GitHub en publiceerden onze eerste applicatie met Railway.
We slaagden erin met kunstmatige intelligentie een kleine applicatie te ontwikkelen zonder zelf code te schrijven.
Maar dat was een proef. We lieten Codex programmeren, controleerden of het werkte en gebruikten daarna Antigravity om het resultaat te beoordelen. Prima om mee te beginnen, maar voor echte projecten is meer structuur nodig.
Wat gebeurt er als we meerdere functies op de planning hebben staan? Hoe voorkomen we dat AI bestanden wijzigt waar het vanaf moet blijven? Wie controleert vóór het programmeren of een oplossing goed is uitgedacht? En hoe weten we zeker dat wat we publiceren precies is wat we hebben gecontroleerd?
Om die vragen te beantwoorden heb ik gaandeweg mijn eigen werkwijze opgebouwd. Ik heb niets revolutionairs bedacht: ik heb gangbare praktijken uit professionele softwareontwikkeling aangepast aan een omgeving waarin AI-agenten een groot deel van het werk doen.
Ik laat je stap voor stap zien hoe ik dat organiseer en gebruik. Misschien helpt het je om hetzelfde te doen.
Zo organiseer ik het werk met AI-agenten
Het idee is eenvoudig: de ene AI ontwikkelt en de andere controleert het werk, terwijl wij de belangrijke beslissingen zelf blijven nemen.
Zelf gebruik ik vijf basistools:
| Tool | Functie |
| Codex | Analyseert, plant, programmeert, test en documenteert. |
| Antigravity | Controleert onafhankelijk het plan en de code. |
| GitHub | Bewaart de code, versies en Pull Requests. |
| Linear | Organiseert taken, tests, audits en statussen. |
| Notion | Bewaart eisen, besluiten en projectgeschiedenis. |
Daar voeg ik er nog twee aan toe: Local WP voor ontwikkelingen met WordPress en Convex of Supabase als het gaat om een webapplicatie die een database nodig heeft.
Notion is optioneel, maar ik raad het aan voor middelgrote projecten. Later leg ik uit waarom.
We hoeven overigens niet precies deze applicaties te gebruiken. We kunnen Codex bijvoorbeeld vervangen door Claude Code of een andere agent inzetten als auditor. Het belangrijkste is dat de verantwoordelijkheden gescheiden blijven.
De volledige procedure is:
- Vereisten.
- Technisch plan.
- Eerste audit.
- Ontwikkeling en tests.
- Tweede audit.
- GitHub.
- Uitrol.
- Verificatie.
Stap 2 (Codex) en stap 3 (Antigravity) kunnen we meerdere keren herhalen: als Antigravity een probleem vindt, lost Codex het op en controleren we opnieuw. Het idee is om in cycli van werken en controleren vooruit te gaan, zonder naar de volgende fase te stappen zolang belangrijke problemen onopgelost zijn.
In mijn werkwijze zijn twee audits verplicht, al hangt de diepgang af van de complexiteit van de ontwikkeling. De eerste beoordeelt wat we van plan zijn, de tweede controleert wat we werkelijk hebben gedaan.
En iets belangrijks: een GO van de auditor is geen toestemming om te publiceren. Die beslissing blijft aan ons.
Stap 1. Onze werkomgeving met Codex voorbereiden
We gaan uit van de computer die we in de eerste handleiding hebben ingericht. Codex, Antigravity en GitHub werken al, dus die hoeven we niet opnieuw te installeren.
We openen een terminal in de projectmap en starten Codex:
cd ~/Proyectos/mi-proyecto
codex
Nu komt een van de dingen die ik het leukste vind aan werken met agenten: we hoeven niet de hele projectstructuur handmatig in te richten. We kunnen Codex vragen dat te doen.
Prompt 1. De werkomgeving configureren
Ik wil dit project voorbereiden op een AI-ondersteund ontwikkelproces onder menselijk toezicht.
Jij bent de analist en ontwikkelaar. Antigravity is de onafhankelijke auditor. We gebruiken GitHub voor de code, Linear voor de taken en eventueel Notion voor de documentatie.
Onderzoek het project en controleer welke koppelingen beschikbaar zijn. Stel blijvende instructies, minimale documentatie, toegangsregels en een procedure met twee verplichte audits voor: van het technische plan en van de code.
Implementaties, belangrijke Git-handelingen en uitrolacties vereisen menselijke toestemming. Taken worden pas afgesloten nadat de productieomgeving is gecontroleerd.
Presenteer eerst een configuratieplan. Maak geen bestanden aan en wijzig geen diensten voordat je toestemming hebt gekregen.
Codex moet analyseren wat er beschikbaar is en ons vertellen wat er ontbreekt.
Normaal gesproken moeten we enkele handelingen zelf uitvoeren:
- Inloggen bij Linear of Notion.
- Een integratie autoriseren.
- Rechten accepteren of een koppeling maken waarvoor authenticatie via de browser nodig is.
HEEL BELANGRIJK: we mogen geen wachtwoorden of tokens rechtstreeks in de chat plakken.
We gebruiken de authenticatiemethoden van de afzonderlijke diensten (Github en Claudflare hebben die) en geven uitsluitend de noodzakelijke rechten.
Zodra we de configuratie hebben goedgekeurd, kan Codex de bestanden voorbereiden en de tools organiseren.
Maar we controleren wel of dat echt is gebeurd, dus vragen we Codex het te verifiëren. Een agent kan geen koppeling met Linear maken als er in zijn omgeving geen compatibele integratie beschikbaar is.
Stap 2. Documentatie organiseren zonder de repository vol te stoppen met bestanden
Om met agenten te werken hebben we iets nodig wat gesprekken alleen niet bieden: een operationeel projectgeheugen.
Stel dat we al weken aan het ontwikkelen zijn en een nieuwe Codex-sessie beginnen. Dan willen we niet opnieuw de hele architectuur uitleggen, welke tools we gebruiken, welke bestanden hij mag aanpassen en hoe de uitrol werkt.
Daarom gebruiken we twee basisdocumenten in de repository:
- AGENTS.md: blijvende instructies voor Codex, grenzen aan wat het mag doen en ontwikkelregels.
- PROJECT.md: projectbeschrijving, basisarchitectuur, omgevingen en links naar de documentatie.
Codex kan deze op basis van onze eisen aanmaken.
En waarvoor hebben we Notion nodig?
Bij kleine projecten zijn Markdown-bestanden misschien voldoende om wijzigingen en beslissingen vast te leggen. Maar zodra functies, beslissingen, vereisten en veranderingen in de architectuur zich opstapelen, eindigen we met te veel documenten in de repository.
Daarom raad ik Notion aan voor middelgrote projecten.
Daar bewaren we vooral de PRD's (Product Requirements Document), technische beslissingen en projectgeschiedenis. Linear bevat de taken, statussen, audits en tests. GitHub bewaart de code.
Het interessante is dat vooral de agenten zelf Notion en Linear gaan gebruiken. Codex schrijft en actualiseert documentatie, raadpleegt de eisen voordat er geprogrammeerd wordt en legt resultaten vast. Antigravity heeft die informatie nodig om een audit uit te voeren.
We hoeven zelf niet pagina's vol documentatie te schrijven. Het is aan ons om te controleren of de eisen en belangrijke beslissingen overeenkomen met wat we willen.
Stap 3. Bepalen wat we willen ontwikkelen
Als voorbeeld nemen we een echte ontwikkeling die ik voor deze website heb uitgevoerd.
In mijn online magazine werden berichten op tagpagina's chronologisch weergegeven. Ik wilde die verbeteren zodat de interessantste inhoud extra aandacht kreeg zonder de gebruikelijke lijst kwijt te raken.
Dit is precies het soort behoefte dat we in gewone taal aan Codex kunnen uitleggen, terwijl zo'n verzoek nog behoorlijk wat vragen openlaat.
- Hoeveel artikelen lichten we uit?
- Hoe bepalen we welke relevant zijn?
- Wat gebeurt er met de overige?
- Moet het op alle pagina's werken?
- Welke onderdelen willen we niet wijzigen?
Voordat we iets analyseren, moeten we die vragen beantwoorden.
Prompt 2. Eisen en technisch plan voorbereiden
Ik wil deze functionaliteit ontwikkelen: [BESCHRIJVING].
Lees de projectinstructies en -documentatie. Zet de behoefte om in toetsbare eisen en acceptatiecriteria. Maak of actualiseer het PRD en organiseer de benodigde taken in Linear.
Onderzoek de bestaande code en stel de eenvoudigste oplossing voor die aan de eisen voldoet. Benoem de betrokken bestanden, risico's, alternatieven en tests.
Programmeer nog niet. Stel mij vragen over functionele beslissingen die je niet met de beschikbare informatie kunt nemen en bereid het plan voor op een onafhankelijke audit.
Dit is een van de grootste verschillen met simpelweg een AI vragen iets te programmeren.
Codex kan ons helpen een idee om te zetten in een specificatie. Wij bepalen of die specificatie aansluit bij wat we nodig hebben.
Bij de tags bijvoorbeeld mocht het acceptatiecriterium niet beperkt blijven tot het tonen van uitgelichte artikelen. We moesten ook de navigatie behouden, ongewenste duplicaten voorkomen en zorgen dat alles op de verschillende pagina's goed werkte.
Zodra we de aanpak hebben goedgekeurd, legt Codex deze vast en maakt het technische plan.
We hebben nog geen regel code geschreven.
Frontendontwerp
In dit geval wist ik precies welk ontwerp ik wilde, dus vroeg ik niet om visuele voorstellen. Maar in andere gevallen zou ik daar op dit punt wel om vragen, zodat Codex ze kan meenemen voordat het een technische oplossing voorstelt.
Als je al weet wat je wilt, leg je het natuurlijk gewoon uit. En als je een functie nodig hebt die de backend raakt in plaats van de frontend, heb je ook geen mockups nodig.
Stap 4. Eerste audit: het plan met Antigravity controleren
Nu komt onze tweede agent in beeld.
We openen een tweede terminal in dezelfde projectmap en voeren het volgende uit:
agy
Bij mijn huidige werkwijze werkt Antigravity handmatig. We laten Codex het niet automatisch aanroepen en doorgaan zonder dat we het resultaat zelf hebben bekeken.
We willen dat het optreedt als onafhankelijke auditor, niet als een tweede programmeur die bestanden gaat wijzigen.
Prompt 3. Het technische plan auditen
Treed uitsluitend op als onafhankelijke technische auditor.
Bekijk de projectinstructies, de eisen en het door Codex voorgestelde plan. Beoordeel of de oplossing haalbaar, voldoende eenvoudig, veilig en verenigbaar met de bestaande werking is.
Controleer de risico's, mogelijke regressies en of de geplande tests geschikt zijn.
Geef een onderbouwd oordeel: GO, voorwaardelijke GO of NO-GO. Als je onvoldoende bewijs hebt, meld dat dan uitdrukkelijk.
Noem de concrete problemen en benodigde correcties. Wijzig geen bestanden.
Waarom al vóór de ontwikkeling auditen?
Omdat een oplossing perfect geprogrammeerd kan zijn en toch een slechte oplossing kan blijken.
Misschien introduceert ze een onnodige afhankelijkheid, dupliceert ze bestaande informatie, voert ze te veel query's uit of maakt ze toekomstig onderhoud lastiger.
Bij de tags was het bijvoorbeeld niet genoeg om een systeem met uitgelichte artikelen te maken. We moesten ook bekijken hoe we de volgorde konden berekenen zonder trage bewerkingen uit te voeren telkens als iemand een pagina opende.
Als de auditor problemen vindt, geven we het rapport door aan Codex. Dat past het plan aan en we laten het zo nodig opnieuw auditen.
We beginnen pas met programmeren als het plan geaccepteerd is en een mens toestemming heeft gegeven voor de uitvoering.
Stap 5. Codex ontwikkelt en voert tests uit
Met een goedgekeurd plan begint de implementatie.
Codex werkt op een branch van de repository. Als je het eerste deel hebt gelezen, ken je Git en GitHub al. We hoeven dus niet opnieuw uit te leggen hoe ze werken.
Het nieuwe is dat we niet rechtstreeks op de stabiele projectversie programmeren. We bereiden wijzigingen apart voor, zodat we ze kunnen beoordelen voordat we ze samenvoegen.
Prompt 4. De functionaliteit implementeren
Ik geef toestemming om het goedgekeurde en geaudite plan voor [LINEAR-TAAK] uit te voeren.
Werk op een aparte branch en beperk wijzigingen tot de goedgekeurde scope.
Implementeer de oplossing, voer de relevante tests uit en controleer op mogelijke regressies. Leg de resultaten vast in Linear.
Bereid de volledige diff voor, benoem de gewijzigde bestanden en lever het benodigde bewijsmateriaal voor de tweede audit.
Voer geen merge of deployment uit. Stop zodra de ontwikkeling klaar is om beoordeeld te worden.
Codex mag binnen de goedgekeurde scope bestanden wijzigen, tests uitvoeren en fouten corrigeren.
Maar er is iets waar we op moeten letten: dat AI zegt dat een functie werkt, betekent nog niet dat dit is aangetoond.
We hebben bewijs nodig. Afhankelijk van het project kan dat bestaan uit geautomatiseerde tests, uitvoerresultaten, functionele controles of een combinatie daarvan.
We moeten ook onderscheid maken tussen wat Codex werkelijk heeft getest en wat het nog niet kan verifiëren.
Terug naar ons voorbeeld: het is niet genoeg om te controleren of er drie uitgelichte artikelen verschijnen. We moeten ook kijken wat er gebeurt als er minder artikelen beschikbaar zijn, als iemand van pagina wisselt of als inhoud niet de verwachte gegevens heeft, zoals een artikel dat niet in een bepaalde taal is vertaald.
De agent moet deze controles en eventuele beperkingen vastleggen.
Stap 6. Tweede audit: de daadwerkelijke code beoordelen
De functionaliteit is ontwikkeld, maar we publiceren haar nog niet.
We gaan terug naar Antigravity en vragen om de gewijzigde code te controleren, niet alleen het rapport dat Codex heeft opgesteld.
Prompt 5. De implementatie auditen
Treed op als onafhankelijke technische auditor voor [LINEAR-TAAK].
Bekijk de volledige diff, het goedgekeurde plan, de vereisten en de testresultaten.
Zoek naar functionele fouten, beveiligingsproblemen, regressies, onnodige complexiteit en wijzigingen buiten de goedgekeurde scope.
Geef een onderbouwd oordeel en vermeld bevindingen waar mogelijk per bestand en locatie.
Leg de SHA-256-vingerafdruk van de geaudite diff vast om de exact beoordeelde versie te identificeren.
Wijzig geen bestanden en geef geen toestemming voor commits, merges of deployments.
Twee details zijn belangrijk.
Ten eerste moet Antigravity dezelfde regels en eisen kunnen raadplegen als Codex. Anders bestaat het risico dat het een technisch correcte oplossing beoordeelt die toch niet voldoet aan wat we hadden gevraagd.
Ten tweede moeten we de documentatie van alle geaudite wijzigingen bewaren. Zo kunnen we de exacte versie identificeren die een GO kreeg en ontdekken of de code daarna is aangepast. Die vingerafdruk moet op reproduceerbare wijze over dezelfde inhoud worden berekend.
Zelf bewaar ik het volledige overzicht in Linear, gekoppeld aan de betreffende taak.
Als Antigravity fouten vindt, gaan we terug naar Codex, vragen om correcties en herhalen de audit.
Twee agenten kunnen zich vergissen, zelfs als ze het met elkaar eens zijn. Daarom zijn audits extra controles, geen absolute garanties. En daarom kunnen we eventueel een derde toevoegen.
Stap 7. De wijzigingen integreren in GitHub
Wanneer we een GO hebben, kunnen we de integratie voorbereiden. De gebruikelijke procedure is:
Branch > Commit > Push > Pull Request > Merge.
We hoeven die commando's niet handmatig uit te voeren. Codex kan dat doen, maar we moeten begrijpen waarvoor we toestemming geven.
Met de Pull Request kunnen we bekijken welke wijzigingen we op de hoofdbranch willen samenvoegen, met welke tests en met welke adviezen van de auditor.
Het is ook verstandig te controleren of de versie die we willen samenvoegen nog steeds de geaudite versie is. Als we na een GO de code veranderen, is die beoordeling mogelijk niet meer geldig.
Voor belangrijke handelingen geef ik liever uitdrukkelijk toestemming. We kunnen sommige combineren als de scope heel duidelijk is, maar we moeten geen onbeperkte vrijheid geven om te integreren en te publiceren.
Dat de auditor een ontwikkeling goedkeurt, is iets anders dan dat wij beslissen die op te nemen.
Hier kan de derde AI in beeld komen: we kunnen een tweede, gespecialiseerde auditor inzetten, zoals CodeRabbit.
Anders dan Antigravity, dat we gebruiken om het plan en de code lokaal te beoordelen, kan CodeRabbit de Pull Requests op GitHub automatisch analyseren voordat ze worden samengevoegd.
Dat is een interessante extra controle voor belangrijke projecten, al is het niet noodzakelijk en kost het geld, hoe bescheiden die kosten ook zijn gezien wat het biedt. Voorlopig houd ik het zelf liever bij de twee handmatige audits en overweeg ik een derde zodra het project groter wordt.
Stap 8. Uitrollen en de werking in productie controleren
Deze stap hangt sterk af van waar ons project wordt gehost.
In het eerste deel gebruikten we Railway. We zouden ook via GitHub Actions, de tools van onze hostingprovider of een ander uitrolsysteem kunnen publiceren.
De bijzonderheden van WordPress, LocalWP en Webempresa behandelen we in een ander artikel.
Hier gaat het om één algemene regel: een succesvol afgeronde deployment betekent niet dat de functionaliteit goed werkt.
Na het publiceren van de wijziging moeten we de echte applicatie controleren.
In ons voorbeeld betekent dat de openbare pagina's bezoeken, de uitgelichte artikelen controleren, door de lijst bladeren en nagaan of andere functies niet zijn veranderd.
We moeten ook bevestigen dat de nieuwe versie wordt getoond. Soms wordt de code goed gepubliceerd, maar serveert een cache nog oude inhoud. Dat overkwam mij met WP Rocket.
Bij belangrijke ontwikkelingen moeten we vooraf bedenken hoe we de stabiele versie herstellen als er iets misgaat.
Pas na deze controles kunnen we zeggen dat de functionaliteit klaar is.
Stap 9. De taak afsluiten en de volgende ontwikkeling voorbereiden
Zodra we het resultaat hebben gecontroleerd, vragen we Codex om Linear en de projectdocumentatie bij te werken.
Het moet vastleggen wat er is ontwikkeld, welke versie gepubliceerd is, welke tests we hebben uitgevoerd en of er nog problemen openstaan.
De taak krijgt pas de status voltooid na de controle in productie, niet wanneer Codex klaar is met programmeren of Antigravity een GO geeft.
Die documentatie heeft nog een voordeel: we kunnen de sessie afsluiten en een nieuwe beginnen zonder context te verliezen.
Ik raad zelfs aan dat te doen als we aan een andere functionaliteitbeginnen. Agenten kunnen regels, eisen en besluiten uit de projectdocumenten ophalen in plaats van afhankelijk te zijn van eindeloze gesprekken.
Na verloop van tijd kunnen we een deel van de coördinatie tussen Codex en Antigravity automatiseren. Voorlopig houd ik het liever handmatig, zodat ik kan controleren of de procedure werkt en vertrouwen kan opbouwen voordat ik toezichtstappen schrap.
Is het bij iedere ontwikkeling de moeite waard om zo te werken?
Nee.
Voor een proefje of twintig minuten experimenteren zijn documentatie, twee audits en een publicatieproces overdreven.
Maar als we een echte website, een applicatie voor een klant of een project ontwikkelen dat we maandenlang moeten onderhouden, is die extra inspanning volkomen logisch.
Het voordeel van deze procedure is niet dat ze fouten uitsluit of programmeerkennis vervangt, maar dat we gestructureerder kunnen werken, besluiten kunnen vastleggen en problemen kunnen opsporen voordat gebruikers ermee te maken krijgen. We beperken de typische fouten van de eerste Vibe Coding-experimenten.
En omdat agenten de meeste uitvoerende taken doen, kunnen wij ons concentreren op wat belangrijk is: beslissen wat we willen, goedkeuren hoe we dat gaan doen en controleren of het resultaat werkt.
Conclusie
In het eerste artikel hebben we de computer klaargemaakt. In dit artikel hebben we onze werkwijze voorbereid.
Nu weten we hoe we:
- Een behoefte omzetten in vereisten.
- Codex om een plan vragen.
- Dat met Antigravity auditen.
- Een functionaliteit ontwikkelen.
- De code beoordelen.
- Die met versiebeheer publiceren.
- Alles documenteren.
Het gaat er niet alleen om sneller te programmeren met kunstmatige intelligentie, maar om te kunnen onderhouden wat we ontwikkelen, te begrijpen wat er is veranderd en een procedure te hebben om problemen op te lossen als ze opduiken.
In het volgende deel passen we deze werkwijze toe op WordPress: lokale ontwikkeling, tests, bestanden onder versiebeheer en deployments op een echte hostingomgeving.
Veelgestelde vragen
Moet ik kunnen programmeren om deze werkwijze te gebruiken?
Zelf code schrijven is niet noodzakelijk, maar je moet wel de basisbegrippen van softwareontwikkeling begrijpen en leren tests en risico's te beoordelen. AI neemt onze verantwoordelijkheid voor het resultaat niet weg.
Moet ik Codex en Antigravity gebruiken?
Nee. Je kunt ze vervangen door andere ontwikkel- en controleagenten. Het belangrijkste is de rollen gescheiden te houden en te voorkomen dat de ontwikkelaar als enige zijn eigen werk beoordeelt.
Heb ik Notion en Linear nodig?
Linear is de taakbeheertool die we in deze handleiding gebruiken. Notion is optioneel voor eenvoudige projecten, al raad ik het aan wanneer eisen, besluiten en documentatie zich opstapelen. Je kunt die informatie ook in Markdown bewaren.
Wat doe ik als Antigravity een NO-GO afgeeft?
Geef het rapport aan Codex, laat de problemen verhelpen en herhaal de audit. Ga niet automatisch naar de volgende fase.
Waarom twee keer auditen?
Omdat de eerste audit problemen in het plan opspoort en de tweede de implementatie controleert. Wie alleen de code beoordeelt, mist misschien ontwerpfouten die eerder makkelijker te herstellen waren geweest.
Kan ik deze werkwijze gebruiken met WordPress of andere technologieën?
Ja. De procedure is onafhankelijk van programmeertaal of platform. Alleen de tests, omgevingen en publicatiemethoden verschillen.
Wanneer is een taak echt afgerond?
Wanneer de goedgekeurde versie gepubliceerd is, is gecontroleerd dat die in productie werkt en het bewijs en de beslissingen zijn vastgelegd.

Geef een reactie