Lange taken
Een migratie of een grote refactor die een uur draait, hoeft niet op je eigen machine.
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.
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.
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.
Een migratie of een grote refactor die een uur draait, hoeft niet op je eigen machine.
Terwijl één agent bouwt, laat je een tweede uitzoeken hoe een koppeling werkt. Die tweede raakt geen bestanden aan.
Een testpakket dat je laptop laat blazen, draait elders zonder dat je iets merkt.
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.
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.
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.
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.
Zoveel als je kunt nakijken zonder het overzicht te verliezen. Voor de meeste mensen zijn dat er twee, waarvan er één uitzoekwerk doet.
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.
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.
Ja. Losse werkkopieën en een terminal-agent doen hetzelfde; het schakelbord van een editor maakt het alleen overzichtelijker.
Wie het laatst schrijft, wint, en dat zie je niet. Daarom is de scheiding per map de belangrijkste afspraak van dit hele verhaal.
Nee. Een team overlegt, corrigeert elkaar en onthoudt afspraken. Parallelle agents doen dat niet uit zichzelf; jij bent het overleg.
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.
Een korte intake volgt na je inschrijving. Daarna stemmen we scope en datum af.
We nemen contact op om de intake in te plannen.
We gebruiken cookies om je ervaring te verbeteren en het gebruik van de site te meten.