How to Reduce Cognitive Fatigue in AI-to-Human Handover

In AI-augmented development, agents typically hand over to a software engineer several times during a task, whether the AI and the human pair in a conversational style or the human delegates to the AI in a more directive way.

Common reasons for these AI-to-Human handovers include asking:
– for clarifications or permissions,
– for decisions to resolve architectural/design/implementation edge cases,
– to fill specification gaps,
– to review the result as the task is completed.

As AI agents take on longer and more complex semi-autonomous tasks, these cold interruptions sharply increase cognitive fatigue, leading to more human errors in decision-making or code quality.

Current AI models are surprisingly suboptimal at collaborating with a human

This sharp increase in cognitive fatigue is not only because of the sheer volume of requests for answers, decisions, and reviews the AI directs at software engineers.

As the tasks become larger and more complex, so does the content of the conversations, which goes far beyond the linear, ping-pong, single-issue chit-chat we were used to with ChatGPT-3.5 in 2022.
Instead, the AI handover typically comes with these problems:

• Multi-issue: multiple complex issues bunched together in one message; these are often disparate issues that are usually unrelated, belong to different domains and levels, and are not necessarily logically or chronologically connected, with each issue being potentially worth a distinct longer conversation in its own right
  
• Cognitive gap: behind every issue, there is a long problem-solving process done by the AI model that provides context necessary to understand and address the issue, but all this is not presented together with the issue
  
• Opacity: the AI model’s problem-solving process behind the topic handed over can often be opaque and hard to understand for a human because the problem-solving process of the model is inherently different from the way humans reason, think, solve problems, and communicate the solution (how they got there, the mistake they made, the hurdles they had to overcome, etc.)
  
• Lack of natural friction: the AI model presents a simple, straightforward point and an extremely complicated issue in similar ways, failing to communicate which are the difficult and important parts, glossing over critical details of the complicated issue, while over-explaining the simple point
  
• Muddled presentation: the presentation of the issue not only lacks the required context, but its info is presented in a way that makes the concepts hard to follow, understand, absorb and connect; for example, it does not start from a high-level overview or summary before gradually drilling down into the relevant details; it does not tell the what and the why; it doesn’t list the possible answers, the pros and the cons or tradeoffs involved.
  
• Text-only: many software engineers, when discussing a complex topic, explain themself well by drawing a quick sketch, whereas the model provides only a static final textual message, or, if instructed, at best a static graph; but the model cannot sketch in real time while gradually explaining the issue, keeping the human actively in the loop to guide and influence the final result as it happens.

How multitasking and the “slot-machine” effects amplify the fatigue

Beyond these AI limitations, two common human-driven interaction patterns add to the cognitive fatigue:

The Multi-Tasking Trap: When an agent is autonomously executing a long task, it is natural for an engineer to switch to other work. However, if the agent suddenly interrupts to hand over an ask/topic, it forces a context switch that adds cognitive fatigue.

The Slot-machine effect: When an agent falls down a rabbit hole of incorrect answers, or when asking the agent for improvement suggestions, it is tempting for some engineers to take another spin at the “slot machine” (try prompting again), However, repeating this cycle multiple times without getting better results rapidly compounds cognitive fatigue.

My Conclusions

Combining effective agent instructions (a skill) on how to interact effectively, with self-discipline to resist task-switching and ‘slot machine’ spinning, reduces cognitive fatigue, cuts costly errors, and gives engineers the clarity to think, understand, reason and solve problems.

1) To combat the cognitive fatigue caused by current AI handovers, you can create a custom skill that forces the agent to communicate in a way that works for you. For example, instruct the agent to:

– Present one ask or topic at a time
– Provide clear context, including what task you are carrying out and why the ask or topic is being raised
– Start with a high-level summary before diving into the full description
– Outline the specific input you need, the available options, and the pros, cons, or trade-offs of each
– Format the message to visually separate the background information from the actual input request.

One, based on personal preference, may ask to start by presenting a diagram or a sketch of the ask/topic.

On the other hand, these problems are built into how current AI models operate, so they cannot be fixed yet:
– the Text-only presentation style completely lacks collaborative visual problem-solving
– the opacity and the lack of natural friction compound each other’s effect, and together amplify the cognitive gap

2) The other improvement comes from managing your own multitasking:

– Finish your current thought: when a long-running agent interrupts with an ask/topic, complete what you are doing first
– Stay in the same domain: If you multitask, group tasks within the same product domain to avoid context switching
– Take a break: After completing a task, take a brief break to note what worked, what didn’t, and how you can improve

Appendix 1: A TypeSafe AI Jev-powered hook to deal with multi-ask handovers

A Skill that instructs the agent to spot these multi-issue, multi-ask handovers and present them one at a time, with proper context and explanation, is quickly forgotten after a few turns. Conversely, using a hook to force the agent to check every message is excessively expensive and slow. Furthermore, an AI agent’s ability to identify which messages actually require this kind of pacing is unreliable.

The System One Jev model from TypeSafe AI, on the other hand, accurately identifies which messages need step-by-step pacing, and invoking Jev on every message is fast and cheap.

Find the hook implementation with Jev here: https://github.com/lucaminudel/jev-unpack-hook/

Ship Production-grade Software Faster with AI. No AI slop.

Drive Value Faster with AI. No AI bloat.

See how we can help across the full AI adoption lifecycle.

AI Services