Agents in de cloud laten draaien

Een AI-editor was tot voor kort iets op je laptop: jij typt, hij denkt mee, alles gebeurt in dezelfde map. De nieuwe generatie is iets anders geworden — een schakelbord waarop meerdere agents tegelijk draaien, op losse werkkopieën, op een server elders, of in de cloud.

Terug naar Kennis
01/10

Wat er wordt opgelost

Niet snelheid per taak, maar het wachten ertussen.

Als een agent op je eigen machine werkt, zit je erop te wachten. Je kunt ondertussen niet in dezelfde bestanden, want die zijn van hem. Dat is het probleem dat losse werkkopieën oplossen: hij werkt in zijn eigen kopie van het project, jij in de jouwe.

Zet je die kopieën vervolgens op een server of in de cloud, dan komt er nog iets bij. Je laptop hoeft niet meer aan te staan, en zware taken — een testpakket dat twintig minuten draait, een migratie over duizend bestanden — leggen je eigen machine niet meer plat.

Wat het níet oplost, is de tijd die het kost om de uitkomst te beoordelen. Dat blijft bij jou, en het is bij dit soort opzetten de enige echte grens.

02/10

Wat een losse werkkopie precies is

Geen tweede computer, wel een tweede map.

Een werkkopie is een tweede uitgecheckte versie van hetzelfde project, in een eigen map, met een eigen tak. Alles wat daar gebeurt, staat los van waar jij in zit. Je hoeft niets te kopiëren en niets te synchroniseren; het versiebeheer regelt dat.

Dat klinkt als een detail en het is de hele reden dat parallel werken opeens praktisch is. Zonder werkkopieën moet een agent wachten tot jij klaar bent met een bestand, of andersom. Met werkkopieën komen jullie elkaar simpelweg niet tegen.

De prijs is schijfruimte en een beetje boekhouding: je moet weten welke agent in welke kopie zit, en aan het eind moet iemand de takken samenvoegen. Bij twee kopieën is dat overzichtelijk. Bij vijf ben je een halve dag bezig met iets wat je met één kopie niet had gehad.

03/10

Waar het echt verschil maakt

Lange taken

Een migratie of een grote refactor die een uur draait, hoeft niet op je eigen machine.

Werk naast werk

Terwijl één agent bouwt, laat je een tweede uitzoeken hoe een koppeling werkt. Die tweede raakt geen bestanden aan.

Zware tests

Een testpakket dat je laptop laat blazen, draait elders zonder dat je iets merkt.

04/10

Wat het je kost aan overzicht

  • Drie agents die tegelijk werken, leveren drie resultaten op die je alle drie moet begrijpen voordat je ze samenvoegt.
  • Ze zien elkaars werk niet. Twee agents die allebei een hulpfunctie nodig hebben, schrijven er allebei een — geen conflict, wel dubbel werk dat er allebei goed uitziet.
  • Een agent op een server draait in een andere omgeving dan jouw laptop. Wat daar werkt, werkt niet vanzelf bij jou.
  • En je merkt niet meer wanneer er iets vastloopt. Op je eigen machine zie je het; elders moet je gaan kijken.
05/10

Hoe je het inricht zonder rommel

Eén agent per gebied, en afspraken die vooraf vastliggen.

De regel die het meest oplevert is saai: één agent per map of per gebied. Zodra twee agents in hetzelfde bestand kunnen komen, wint degene die het laatst schrijft, en dat merk je pas als er iets weg is.

Leg daarnaast vooraf vast wat ze allebei nodig hebben. Twee agents die allebei een gebruiker moeten opslaan, verzinnen allebei een eigen naam voor hetzelfde veld. Eén bestand met de gedeelde namen, dat ze allebei als uitgangspunt krijgen, voorkomt dat.

En kijk elk resultaat apart na, in volgorde van klein naar groot. Beginnen bij de agent die het minst heeft aangeraakt, maakt de rest leesbaarder. Alles tegelijk samenvoegen en dan kijken of het nog werkt, kost meer tijd dan je met parallel werken hebt gewonnen.

06/10

Wat er misgaat als de omgeving verschilt

Werkt bij mij is bij agents in de cloud een echt probleem.

Een agent die op een server draait, draait daar in een andere omgeving dan jouw laptop: andere versies, andere instellingen, soms een ander besturingssysteem. Code die daar de tests haalt, kan bij jou omvallen op iets wat niets met de wijziging te maken heeft.

Dat kost tijd op het vervelendste moment: je hebt een resultaat in handen, je wilt het samenvoegen, en dan blijkt het bij jou niet te draaien. De eerste reflex is dan de code te verdenken, terwijl het aan de omgeving ligt.

De maatregel is dezelfde die je zonder agents ook zou nemen: leg de versies vast waarmee je werkt, in een bestand dat met het project meereist. Dan draait iedereen op hetzelfde, of het nu jij bent of een agent op een machine die je nooit ziet.

07/10

Wanneer je dit beter niet aanzet

Wel zinvol
  • Je hebt taken die echt los van elkaar staan
  • Je werkt met versiebeheer en kunt per wijziging terug
  • Je project is groot genoeg dat wachten pijn doet
Niet zinvol
  • Je bent nog aan het uitzoeken wat er moet gebeuren
  • Je werkt aan één scherm waar alles samenkomt
  • Je hebt geen manier om te toetsen of iets werkt
08/10

Het patroon dat wel altijd werkt

Er is één vorm van parallel werken die in de praktijk vrijwel altijd wint: één agent bouwt, de andere bereidt voor. Terwijl de eerste aan de code werkt, laat je de tweede uitzoeken hoe een externe koppeling in elkaar zit, welke bibliotheek geschikt is, of hoe de foutmelding van gisteren te reproduceren is.

Dat werkt omdat de tweede agent niets aanraakt. Hij levert informatie op, geen code. Daarmee vervallen alle conflicten, terwijl je wel het voordeel houdt dat er twee dingen tegelijk gebeuren. Een verslag lezen is bovendien iets heel anders dan een wijziging nakijken.

Wie hier een ritme in vindt, komt verder dan wie drie agents tegelijk laat bouwen. Minder spectaculair, meer opbrengst — wat vaker geldt dan mensen leuk vinden.

09/10

Wat dit betekent voor een bouwdag

In één dag is de winst beperkt. Het werk is dan zo afgebakend dat wachten zelden het probleem is, en het overzicht houden telt zwaarder dan doorlooptijd. We gebruiken hooguit een tweede agent voor uitzoekwerk naast de bouw.

Waar het wél interessant wordt, is daarna: als je product groeit en er migraties, testrondes en opruimwerk bij komen. Dat is precies het soort werk dat je elders kunt laten draaien zonder dat het je dag in de weg zit.

10/10

Veelgestelde vragen

Hoeveel agents tegelijk is verstandig?

Zoveel als je kunt nakijken zonder het overzicht te verliezen. Voor de meeste mensen zijn dat er twee, waarvan er één uitzoekwerk doet.

Heb ik hier versiebeheer voor nodig?

Ja, en niet als formaliteit. Zonder de mogelijkheid om per wijziging terug te gaan, is parallel werken vooral een manier om jezelf klem te zetten.

Wat kost het om agents elders te laten draaien?

Dat hangt af van de opzet: op je eigen server betaal je die server, in de cloud van je editor betaal je gebruik. Reken erop dat lang doorlopende agents meer verbruiken dan je schat.

Kan ik hier ook zonder editor mee werken?

Ja. Losse werkkopieën en een terminal-agent doen hetzelfde; het schakelbord van een editor maakt het alleen overzichtelijker.

Wat gebeurt er als twee agents hetzelfde bestand aanraken?

Wie het laatst schrijft, wint, en dat zie je niet. Daarom is de scheiding per map de belangrijkste afspraak van dit hele verhaal.

Is dit hetzelfde als een team simuleren?

Nee. Een team overlegt, corrigeert elkaar en onthoudt afspraken. Parallelle agents doen dat niet uit zichzelf; jij bent het overleg.

Wil je zien wat een assistent met jouw systemen kan?

In een bouwdag ontsluiten we één systeem met leesrechten en bouwen we een assistent die er vragen over beantwoordt. Dan weet je of het idee hout snijdt.