I'm Not Reading All of That: Understanding Software Engineers' Level of Cognitive Engagement with Agentic Coding Assistants

Dit onderzoek toont aan dat software-ontwikkelaars hun cognitieve betrokkenheid verliezen bij het gebruik van agentische codeerassistenten, wat leidt tot een gebrek aan reflectie en controle, en pleit voor nieuwe ontwerpstrategieën die kritisch denken en betekenisgeving actief stimuleren.

De kern

Titel: "Ik lees niet alles": Waarom programmeurs te snel afhaken bij slimme AI-assistenten

Stel je voor dat je een zeer getalenteerde, maar soms wat overijlde assistent hebt die voor je werkt. Deze assistent kan razendsnel een huis bouwen voor je, maar hij doet het zo snel dat hij de blauwdrukken, de materialen en de constructie niet meer uitlegt. Hij geeft je gewoon de sleutel en zegt: "Hier is je huis, het is klaar."

Je kijkt er even naar, ziet dat het er mooi uitziet, en denkt: "Perfect." Maar heb je eigenlijk wel gekeken of de fundering goed is? Of dat de stopcontacten veilig zijn? Waarschijnlijk niet, want je bent zo blij dat het werk gedaan is.

Dit is precies wat er gebeurt in de wereld van softwareontwikkeling, zoals beschreven in dit onderzoek van Samsung en York University. Hier is wat ze hebben ontdekt, vertaald naar begrijpelijke taal:

1. De "Slimme" Assistent (De Agentic Coding Assistant)

Vroeger waren AI-tools als een rekenmachine: je gaf een opdracht, en ze gaven een antwoord. Nieuwe tools (zoals Cline, waar dit onderzoek over gaat) zijn meer als een autonome bouwvakker. Ze kunnen zelf plannen maken, gereedschap gebruiken en code schrijven zonder dat jij elke stap hoeft te doen. Ze werken bijna als een partner die "agentic" (zelfstandig) handelt.

2. Het Probleem: De "Sluimerende" Brein

De onderzoekers wilden weten: Hoe hard werken programmeurs eigenlijk nog mee als zo'n slimme assistent het werk doet?

Ze stelden een simpele taak: "Schrijf een script dat Excel-bestanden sorteert." Ze keken naar vier programmeurs (van een beginner tot een veteraan). Wat zagen ze?

• Aan het begin (Het Plan): De programmeurs waren super alert. Ze keken goed naar wat de assistent plande. Het was alsof ze de architectuur van het huis bespraken. Ze wilden zeker weten dat de assistent de opdracht goed begreep.
• Tijdens het werk (De Uitvoering): Zodra de assistent begon te werken en een stortvloed aan tekst en code begon te produceren, gebeurde er iets raars. De programmeurs keken weg. Ze scrollden niet meer mee. Een van hen zei zelfs: "Ik lees niet alles."
  • De analogie: Het is alsof je een film kijkt die met 10x snelheid wordt afgespeeld. Je ziet wel dat er iets gebeurt, maar je begrijpt de details niet meer. De assistent gaf te veel informatie te snel, waardoor het brein van de programmeur "opgaf" en zich terugtrok.
• Aan het einde (Het Resultaat): Toen het werk klaar was, keken ze alleen naar het eindresultaat. Als het Excel-bestand er goed uitzag, dachten ze: "Gefeliciteerd, klaar!" Ze keken niet naar hoe het gemaakt was. Ze vertrouwden blindelings op de assistent.

3. De Gevolgen: Waarom is dit gevaarlijk?

Het probleem is dat software vaak wordt gebruikt in belangrijke situaties (zoals bankzaken of medische apparatuur). Als een programmeur alleen kijkt naar het eindresultaat en niet naar het proces, kunnen er gevaarlijke fouten ontstaan.

• Het "Happy Path"-effect: De programmeurs keken alleen naar het scenario waarin alles perfect werkt (de "happy path"). Ze dachten niet na over wat er gebeurt als er een foutje in de data zit, of als de assistent per ongeluk een kwaadaardige code heeft geschreven.
• Verlies van kritisch denken: Net zoals je je spierkracht verliest als je een machine hebt die alles voor je tilt, verlies je je "kennis-spieren" als je AI alles voor je laat denken. Je wordt een passieve kijker in plaats van een actieve bouwer.

4. De Oplossing: Hoe maken we de AI weer een goede "Sparringpartner"?

De auteurs zeggen dat we de AI niet moeten zien als een robot die het werk voor ons doet, maar als een paardrijder die samen met ons werkt. Om dit te bereiken, moeten we de AI op een paar manieren veranderen:

• Gebruik meer dan alleen tekst: In plaats van een muur van tekst te gooien, moet de AI visuele hulpmiddelen gebruiken. Denk aan flowcharts, grafieken of mindmaps.
  • Analogie: In plaats van een recept dat je moet lezen, krijg je een filmpje van de kok die laat zien hoe hij de ingrediënten mengt. Dat is veel makkelijker om te volgen.
• Stel de AI een "rem" op (Cognitive Forcing): Soms moet de AI de programmeur dwingen om na te denken.
  • Analogie: Stel je voor dat je een auto hebt die altijd automatisch remt als je te hard gaat. Nu moeten we de AI zo programmeren dat hij stopt en vraagt: "Weet je zeker dat dit goed is? Heb je dit gecontroleerd?" Hierdoor moet de programmeur weer actief nadenken in plaats van alleen maar te klikken.
• Gebruik stem en geluid: Onderzoek toont aan dat als een AI met een menselijke stem praat, mensen er beter naar luisteren en minder snel afhaken.

Conclusie

Dit onderzoek is een waarschuwing: als we AI-tools te veel laten doen, worden we lui in ons denken. We krijgen mooie resultaten, maar we begrijpen niet hoe ze tot stand kwamen.

De boodschap is simpel: AI moet ons helpen nadenken, niet ons denken overnemen. Door de tools visueler te maken en ze soms even te laten "stopten" om na te denken, kunnen we ervoor zorgen dat programmeurs scherp blijven en veilige software bouwen.

Kortom: Laat de assistent de bakker zijn, maar blijf jij de chef-kok die proeft of het gerecht goed is.

Technische samenvatting

Probleemstelling

De opkomst van Agentic Coding Assistants (ACAs) (zoals Cline, Claude Code en Codex) heeft de softwareontwikkeling getransformeerd van handmatige codering naar autonome samenwerking. Hoewel deze systemen de productiviteit verhogen, bestaat er een significant risico op overmatige afhankelijkheid, wat leidt tot een afname van kritisch denken en een toename van complaisantie.

De kern van het probleem ligt in de rol van ACAs als "Tools for Thought" (gereedschap voor denken). In plaats van louter taken uit te voeren, zouden ze menselijk redeneren en zingeving (sensemaking) moeten ondersteunen. Echter, door de autonome aard van deze systemen en de neiging van gebruikers om zich te focussen op het eindresultaat in plaats van het proces, dreigt de cognitieve betrokkenheid van software-engineers (SEs) af te nemen. Dit is gevaarlijk in software-engineering, waar developers complexe afwegingen moeten maken, correctie moeten garanderen en foutmodi moeten anticiperen, vooral gezien de neiging van Large Language Models (LLMs) tot hallucinaties en algoritmische bias.

Methodologie

De auteurs voerden een formatieve studie uit om de cognitieve betrokkenheid van SEs bij het werken met een ACA te onderzoeken.

• Deelnemers: Vier software-engineers met variërende ervaring (van <1 jaar tot >10 jaar).
• Tool: De studie gebruikte Cline, een open-source agentic assistant gekend om zijn planningscapaciteiten en interactie met externe tools.
• Taak: Deelnemers moesten een script schrijven dat Excel-bestanden in een map scant, specifieke kolommen kopieert en een nieuw werkmap genereert. De taak was gebaseerd op een prompt uit de DevGPT-dataset.
• Fasen van de studie:
  1. Planning: Deelname aan het begrijpen van de prompt en het reviewen van het plan van de agent.
  2. Executie: De agent genereert code en voert tools uit.
  3. Evaluatie: De gebruiker evalueert de gegenereerde code en het resultaat.
• Datacollectie:
  • Observatie van gedrag (denk hard-out protocol, blikrichting).
  • Een enquête gebaseerd op Bloom's Taxonomie (herinneren, begrijpen, analyseren, evalueren) die direct na de taak werd afgenomen om memory-bias te minimaliseren.
  • Cross-referentie van antwoorden met de daadwerkelijke werkbestanden.

Belangrijkste Resultaten

De studie onthulde twee kritieke patronen in het gedrag van software-engineers:

1. Afnemende Cognitieve Betrokkenheid: Er is een duidelijke daling in cognitieve inspanning naarmate de taak vordert.

   • Planning: Deelnemers waren zeer actief en besteedden veel cognitieve middelen aan het begrijpen van de prompt en het plannen van de agent.
   • Executie: Tijdens het genereren van code door de agent daalde de betrokkenheid drastisch. Deelnemers keken weg van het scherm of lazen niet mee ("I'm not reading all of that"). De grote hoeveelheid tekst werd ervaren als extraneus cognitieve last (onnodige belasting), wat leidde tot "information overload".
   • Evaluatie: De focus lag bijna uitsluitend op het eindresultaat (de Excel-bestanden) en niet op het onderliggende proces (de code). Zolang het resultaat correct leek, werd de taak als voltooid beschouwd.

2. Focus op de "Happy Path":

   • Deelnemers herinnerden, begrepen, analyseerden en evalueerden voornamelijk de stappen die leidden tot een correcte output.
   • Ze waren niet in staat om details te herinneren (bijv. het aantal functies in het script) of om randgevallen (edge cases) en potentiële kwetsbaarheden te analyseren.
   • Dit gedrag suggereert een System 1-denken (snelle, intuïtieve beslissingen) in plaats van System 2 (analytisch, inspannend denken), waarbij gebruikers shortcuts nemen om cognitieve middelen te sparen.

Kernbijdragen en Ontwerpmogelijkheden

Op basis van de bevindingen stellen de auteurs concrete ontwerprichtlijnen voor ACAs voor om cognitieve betrokkenheid te behouden en kritisch denken te stimuleren:

1. Communicatie voorbij Tekst (Multimodaliteit):

   • Huidige ACAs vertrouwen te veel op tekststromen, wat leidt tot overschrijding van de verwerkingscapaciteit van de gebruiker.
   • Voorstel: Integreer visualisaties (flowcharts, grafieken, mindmaps) en spraak (voice AI). Dit kan complexe informatie samenvatten, de waargenomen cognitieve last verlagen en de retentie van informatie verbeteren.

2. Cognitieve Forcering Ontwerpen (Cognitive Forcing Designs):

   • Om System 1-denken te doorbreken en System 2 (analytisch denken) te activeren, moeten ontwerpen ingrijpen in het proces.
   • Voorstel: Ontwerpen die het AI-besluitvormingsproces vertragen of onderbreken om de gebruiker te dwingen tot analyse. Bijvoorbeeld: de AI toont pas suggesties nadat de gebruiker eerst zelf een analyse heeft uitgevoerd, of de AI vraagt expliciet om reflectie over randgevallen voordat de code wordt gegenereerd. Dit fungeert als een "paard" (pair programmer) die instructies en scaffolding biedt in plaats van alleen oplossingen.

Significantie

De studie benadrukt dat de integratie van ACAs in software-engineering niet alleen een technisch, maar vooral een cognitief ontwerpprobleem is. Als ACAs worden ontworpen die gebruikers passief maken, riskeren we het creëren van software die minder veilig en minder robuust is, omdat kritische evaluatie van de code en het proces wordt overgeslagen.

De voorgestelde benadering, waarbij ACAs fungeren als actieve partners die reflectie en zingeving stimuleren (in plaats van alleen uitvoeren), is essentieel voor het ontwikkelen van betrouwbare systemen in hoog-risico contexten. De auteurs pleiten voor een verschuiving van "autonome uitvoering" naar "ondersteunde cognitie", waarbij multimodale interactie en cognitieve forcing mechanismen centraal staan.