Waarom AI-codeerassistenten Een Stuk Beter Kunnen

De meeste developers zijn inmiddels gewend aan AI-hulpmiddelen die aanvoelen als enthousiaste, maar vergeetachtige stagebakkers. Ze maken code, helpen met bugs, en soms komt er zelfs een nuttige suggestie voorbij. Maar zodra er iets misgaat, of je wilt terugkeren naar een eerder idee, begin je vaak opnieuw. Je gespreksgeschiedenis verdwijnt in een database waar je nooit direct bij kunt. De redenering van je agent verdwijnt zodra je de sessie sluit.

Dit model is fundamenteel gebroken, en het komt doordat Git als bijzaak wordt behandeld.

Git als Staat-machine, Niet als Backup-systeem

Wat veel developers missen over Git: het is niet zomaar een tool om bestandswijzigingen bij te houden. Het is een staat-machine met een ingebouwde gesprekslog. Elke commit legt niet alleen vast wat er veranderde, maar ook de context waarin die veranderingen ontstonden. Branches vertegenwoordigen afwijkende realiteiten. Worktrees laten je op meerdere plekken tegelijk existeren.

Stel je nu een AI-assistent voor die deze architectuur van nature begrijpt.

In plaats van een interne database bij te houden met agent-status, wordt elke actie van je AI-hulpje gecommit naar de repository, met volledige chat- en uitvoeringsgeschiedenis eraan gekoppeld. Wil je terug naar een eerder idee? Je checkt simpelweg een commit uit. Wil je een alternatief ontwerp verkennen? Je brancht naar een verse worktree zonder je huidige werk te verliezen.

Dit is niet zomaar een slimme implementatiedetails. Het is een fundamenteel andere denkwijze over hoe AI-ondersteunde ontwikkeling zou moeten werken.

Wat Dit In De Praktijk Mogelijk Maakt

Branches Als Volwaardige Operatie

Bij traditionele agents betekent een alternatieve aanpak verkennen óf je huidige richting verlaten, óf steeds verwarrender state proberen bij te houden. Met Git-native reasoning opent branchen een verse interactieve context in een geïsoleerde worktree. Je kunt die wilde refactoringskriebel uitleven zonder je stabiele checkout aan te raken. Werkt het? Merge terug. Werkt het niet? Verwijder de branch en je staat precies waar je stond.

Sessies Herstellen Die Echt Werken

Hoe vaak heb je een productieve debugsessie verloren omdat je het verkeerde tabblad sloot of je computer crashte? Als elke bestandswijzigende stap snapshot-gecommit wordt met chatgeschiedenis, is terugspoelen naar elk checkpoint triviaal. Je hoeft niet te hopen dat het systeem je state bewaard heeft—je kijkt letterlijk naar commits in je repository.

Configuraties Wisselen Tijdens Een Sessie

De beste developers schakelen door de dag heen tussen verschillende denkmodellen. Soms plan je architectuur, soms werk je implementatie bij, soms zit je in review-modus. Een Git-native agent kan tussen verschillende configuraties schakelen—planner, coder, reviewer—zonder je actieve context te verliezen. De overgangen zijn clean omdat de state in Git leeft.

Parallelle Verkenning Op Schaal

Meerdere agents tegelijk draaien is geen sciencefiction meer als je architectuur op worktrees is gebouwd. Meerdere benaderingen kunnen tegelijkertijd worden onderzocht, elk in zijn eigen geïsoleerde omgeving, met resultaten die je kunt vergelijken, mergen of afblazen.

Waarom Dit Ertoe Doet Voor Developer Experience

Er zit een psychologische kant aan dit verhaal die vaak wordt genegeerd. Als je AI-assistent in een opaque systeem werkt, ontwikkel je geleerde hulpeloosheid rond zijn state. Je stopt met vragen als "wat waren we gisteren aan het doen?" omdat het antwoord inhoudt dat je door interfaces moet navigeren die voor iets anders zijn ontworpen.

Als je agent in Git leeft, verdwijnt de drempel naar nul. Je weet al hoe je branches gebruikt. Je weet al hoe je diff. Je weet al hoe je checkout. De leercurve vlakt af omdat je vertrouwde workflows uitbreidt in plaats van helemaal nieuwe aan te nemen.

Voor teams is dit nog krachtiger. Een volledige ontwikkelgeschiedenis wordt doorzoekbaar, controleerbaar en herstelbaar. Een nieuwe developer onboarden betekent niet uitleggen hoe een of ander propriëtair agent-geschiedenissysteem werkt—het betekent "hier is onze repo, en trouwens, hier is wat de AI bij elke commit dacht."

De Tools Die Dit Mogelijk Maken

Moderne Git-native agents ondersteunen meerdere model backends—lokale modellen via tools zoals mlx-lm, cloud providers zoals Gemini, Claude en anderen—samen met een robuuste toolkit voor bestandsoperaties, shell-commando's en zoekfunctionaliteit. De abstractie werkt omdat het op Git's bewezen primitieven rust, in plaats van te proberen ze opnieuw te creëren.

De keyboard shortcuts voelen vertrouwd omdat ze map naar operaties die developers al uitvoeren: tussen tabs springen wordt contexten schakelen, diffen toont precies wat veranderde, en geschiedenis is gewoon... geschiedenis.

Vooruitblik

We betreden een tijdperk waarin AI-ondersteunde ontwikkeltools moeten volwassen worden. De proof-of-concept demo's zijn leuk, maar de tools die blijven zijn degene die respecteren hoe developers al werken. Git-native agents vragen je niet om je workflow aan te passen voor AI. Ze breiden je bestaande infrastructuur uit met AI-superpowers.

De vraag is niet of AI onmisbaar wordt in ontwikkelworkflows—dat is het al. De vraag is of die integraties aanvoelen als vreemde objecten die op vertrouwde tools zijn geschroefd, of als natuurlijke uitbreidingen van systemen die developers al vertrouwen.

Voor wie ooit burned is door opaque agent-states en verloren sessies, voelt Git-native reasoning minder als innovatie en meer als back-to-basics.