Delegating Multiple Tasks to AI Puts Humans in Multitasking Hell: Solutions from Cognitive Science

• Target Audience: Software engineers, DevOps, project managers
• Prerequisites: Basic knowledge of AI tools (GitHub Copilot, Claude, Cursor, etc.)
• Reading Time: 20 minutes

Overview

The proliferation of AI tools has enabled developers to delegate multiple tasks to AI simultaneously. Asking Claude Code to fix bugs, generate tests, and update documentation all at once, or having GitHub Copilot generate code while ChatGPT handles separate research—at first glance, productivity seems to skyrocket.

However, cognitive science research sounds the alarm. Whether executing multiple tasks simultaneously on the same AI tool or using different AI tools in parallel, humans still need to monitor, review, and integrate the outputs, ultimately falling into a multitasking state themselves. And cognitive load from multitasking has been shown to reduce productivity by up to 40%[^1].

A 2025 METR study reported the shocking finding that experienced developers using AI tools become 19% slower than without them[^5]. One contributing factor is thought to be that delegating tasks to AI creates new cognitive load.

This article organizes the cognitive science drawbacks of multitasking and explains practical strategies for leveraging AI while avoiding human multitasking, aimed at IT engineers.

Cognitive Science Drawbacks of Multitasking

40% Productivity Loss from Task Switching

A 2024 study quantified task switching’s impact on productivity. According to Hasan (2024) in Annals of Medicine and Surgery[^1], approximately 40% of adults engage in digital multitasking daily, and task switching alone can result in up to 40% productivity loss.

For a developer working 8 hours per day, this means approximately 3.2 hours lost to task-switching overhead.

Severe Impact on Cognitive Function

The same study[^1] observed the following cognitive declines in frequent multitaskers:

• Decreased working memory: Significantly reduced ability to retain information between tasks
• Reduced cognitive control: Diminished ability to filter irrelevant information
• Shortened attention span: Decreased ability to focus on a single task

Furthermore, neuroimaging studies reveal that multitasking reduces activation in brain regions involved in cognitive control while increasing stress-related activation[^1].

Mental Health Impact

Multitasking negatively affects not only cognitive function but also mental health[^1]:

• Frequent multitaskers show significantly higher anxiety symptoms (P<0.01)
• Significantly higher depression symptoms (P<0.05)
• Elevated self-reported stress levels

Human Brain Limitations: Serial Processing Bottleneck

The Illusion of Parallel Processing

The human brain performs simultaneous parallel processing with billions of neurons, but attempting to execute high-level cognitive tasks concurrently results in severe performance degradation[^2][^3].

Sigman & Dehaene (2008) in The Journal of Neuroscience[^3] used EEG and fMRI to investigate brain mechanisms during dual-task execution. Results showed:

• First ~250ms: Perceptual stage can process in parallel
• Central decision stage: Serial bottleneck exists in parieto-frontal network
• Decision-making: Only one task can be processed at a time

This means that while peripheral perception and motor stages can operate in parallel, high-level decision-making and cognitive control are inherently constrained to serial processing.

Psychological Refractory Period: The 0.3-Second Cost

The Psychological Refractory Period (PRP) refers to the phenomenon where humans cannot execute two tasks simultaneously[^2]. Sigman & Dehaene (2008)[^3] observed approximately 300ms delay during dual-task execution.

Fischer & Plessow (2015) in Frontiers in Psychology[^2] demonstrated:

• Serial processing is generally most efficient
• Parallel processing can be effective under specific conditions
• Efficient multitasking involves the ability to flexibly switch processing strategies according to context

In other words, what humans call “multitasking” is actually rapid task switching (context switching), not true parallel execution.

New Multitasking Problems Created by AI Tools

AI Delegation Creates New Cognitive Load

AI tools can automate many tasks, but this doesn’t necessarily reduce human cognitive load. This is because delegating tasks to AI generates the following additional work:

1. Task definition and instruction: Clearly communicating what the AI should do
2. Progress monitoring: Confirming the AI is working correctly
3. Output review: Verifying AI-generated results are correct
4. Integration work: Combining multiple AI outputs
5. Error correction: Discovering and fixing AI mistakes

When delegating multiple tasks to AI agents simultaneously, these activities occur in parallel, putting humans in a state of moving between multiple tasks.

Isn’t Boss Delegation to Subordinates Multitasking?

An important question arises here. Bosses delegate tasks to multiple subordinates and review results later—this happens routinely, but is the boss in a multitasking state?

The answer is “No.” The reason is the fundamental difference in autonomy between human subordinates and AI agents.

Human Subordinates: High Autonomy

When delegating to skilled subordinates:

1. Complete independent work: After receiving instructions, subordinates plan, execute, and verify on their own
2. Asynchronous progress checks: Bosses check progress in batch at regular meetings (once daily, weekly, etc.)
3. Deliverables submitted: Subordinates submit “completed work,” bosses only do final review
4. Few interruptions: Bosses don’t need to check constantly during subordinate work

In this case, bosses perform batch-style reviews, avoiding multitasking. Review subordinate A’s deliverable at 10am, subordinate B’s at 11am—this is sequential work with low cognitive load.

Current AI: Low Autonomy

In contrast, AI agents as of 2025 (Claude Code, GitHub Copilot, etc.):

1. Frequent confirmation needed: Must check if AI is heading in the right direction
2. Early error detection: Must correct before heading in wrong direction to avoid large rework
3. Detailed instructions needed: Vague instructions don’t yield expected results
4. Continuous monitoring: Cannot be left completely alone, must monitor progress

When you ask Claude Code to handle 3 tasks simultaneously, you need to monitor progress on each, correct errors early, and adjust direction. This causes frequent interruptions, resulting in a multitasking state.

Cognitive Cost of Interruptions

The cognitive cost of interruptions is known to be very high. Mark et al. (2008)[^6] showed that while interruptions allow faster task completion, stress, frustration, time pressure, and effort increase significantly.

Additionally, task switching alone results in up to 40% productivity loss[^1]. This means that “check Claude Code task 1 → check task 2 → check task 3” isn’t just “switching”—it represents serious productivity loss.

Future Outlook: Increasing AI Autonomy

This analysis yields important implications:

If AI becomes sufficiently autonomous, asynchronous review like with human subordinates becomes possible

In the future, if AI agents have the following capabilities, the situation will change:

• Execute tasks completely independently (no mid-task confirmation needed)
• Self-verify and correct errors
• Ask questions at appropriate times when uncertain (minimizing interruptions)
• Deliver high-quality deliverables

At that point, delegating multiple tasks to AI in the morning and reviewing them together in the evening—a boss-subordinate relationship—might become reality.

However, as of 2025, AI autonomy is not yet sufficient. Therefore, executing multiple AI tasks simultaneously causes humans to fall into a frequently-interrupted multitasking state.

METR Study Shows 19% Delay for Experienced Developers

The METR study by Becker et al. (2025)[^5] clearly demonstrates this problem:

• Sample: 16 experienced developers from major open-source repositories (average 22,000+ stars)
• Tasks: 246 actual repository issues (bug fixes, feature additions, refactoring)
• Tools: Cursor Pro with Claude 3.5/3.7 Sonnet
• Results: Developers using AI tools took 19% longer than without

Even more interesting is the gap in perception:

• Developers predicted AI would improve productivity by 24%
• Actual result was 19% delay
• Yet developers felt AI had improved their productivity by about 20%

This perception gap suggests that while AI tools may provide subjective comfort through cognitive load reduction, they may reduce objective productivity.

Why Do Experienced Developers Slow Down with AI?

The study authors don’t specify, but the following factors are conceivable:

1. Review cost: Experienced developers must carefully review AI output and verify it meets quality standards
2. Context switching: Interaction with AI frequently causes departure from the original task
3. Over-expectations: Overestimating what AI can do leads to delegating inappropriate tasks
4. Multitasking: Using multiple AI tools simultaneously creates human bottlenecks

55.8% Productivity Improvement for Beginners

In contrast, Peng et al. (2023)’s GitHub Copilot study[^4] reported positive results:

• Controlled trial with 95 professional programmers
• GitHub Copilot group completed tasks 55.8% faster than control (95% CI: 21-89%)
• Developers with less programming experience benefited more

What does this difference mean?

Beginners tend to accept AI output as-is (or with minor modifications), resulting in lower review costs and less context switching. Meanwhile, experienced developers have higher quality standards and carefully verify AI output, generating additional cognitive load.

Important Note: This study involved a relatively simple task of implementing an HTTP server in JavaScript. Results may differ for complex tasks.

Strategies for Leveraging AI While Avoiding Human Multitasking

Strategy 1: Sequential Delegation (One AI Task at a Time)

The most effective strategy is not executing multiple tasks simultaneously even on the same AI tool.

Bad Example: Simultaneous Parallel Delegation (Human Becomes Multitasker)

[3 tasks requested to Claude Code simultaneously]
10:00 - Task 1: Request API endpoint bug fix
10:02 - Task 2: Request test case generation (Task 1 in progress)
10:04 - Task 3: Request documentation update (Tasks 1,2 in progress)

10:10 - Check Task 1 output (context switch ①)
10:15 - Check Task 2 progress (context switch ②)
10:18 - Check Task 3 progress (context switch ③)
10:22 - Give Task 1 correction instructions (context switch ④)
10:28 - Review Task 2 output (context switch ⑤)
10:35 - Review Task 3 output (context switch ⑥)
10:45 - Integrate 3 outputs

Total context switches: 6+ times
Cognitive load: Very high
Human cannot track state of 3 tasks, becomes confused

Good Example: Sequential Delegation (Single Task)

[Process one at a time with Claude Code]
10:00 - Task 1: Request API endpoint bug fix
10:15 - Review and modify Task 1 output (focused)
10:30 - Task 1 complete, move to next task

10:35 - Task 2: Request test case generation
10:45 - Review and modify Task 2 output (focused)
10:55 - Task 2 complete, move to next task

11:00 - Task 3: Request documentation update
11:10 - Review and modify Task 3 output (focused)
11:20 - Task 3 complete

Total context switches: 2 (only between tasks)
Cognitive load: Low
Deep work time: Maximized
Can focus on each task

Supplement: Same Applies When Using Multiple Different Tools

[Bad Example]
10:00 - Start code generation with GitHub Copilot
10:05 - While generating, request document creation with ChatGPT
10:10 - Check Copilot output (context switch)
10:15 - Check ChatGPT progress (context switch)
→ Cognitive load increases from switching multiple tools

[Good Example]
10:00 - Code generation with GitHub Copilot (focus until complete)
10:30 - Document creation with ChatGPT (focus until complete)
→ Minimize cognitive load by completing one at a time

Strategy 2: Distinguish Complete Delegation vs Collaboration

Rather than treating all tasks the same, classify by degree of delegation.

Completely Delegatable Tasks (No monitoring needed, review later):

• Code formatting
• Routine test case generation
• Dependency updates
• Simple refactoring (variable renaming, etc.)

Run these in background and review in batch after completion.

Collaborative Tasks (Real-time monitoring required):

• New feature implementation
• Complex algorithm design
• Security-critical code
• Architecture changes

For these, focus on AI interaction and don’t perform other tasks simultaneously.

Strategy 3: Batch Processing Approach

When there are multiple AI tasks, block time for batch processing.

Implementation Example: Pomodoro Technique Application

[Block 1: 09:00-10:30] Code implementation (collaborate with Claude Code)
- New feature implementation with Claude Code (focus on single task)
- Don't request other tasks until complete
- Turn off notifications

[Block 2: 10:45-11:15] Next task (Test generation with Claude Code)
- Generate tests for feature implemented in previous block
- Focus on this task, don't request other tasks until complete

[Block 3: 11:30-12:00] AI output review & fixes
- Review documentation update delegated to Claude Code yesterday
- Efficiency through batch processing
- Don't start new AI tasks during this block

[Block 4: 13:00-14:30] Deep work (No AI)
- Important design and architecture review
- Time to think without relying on AI
- Important time to maintain cognitive ability

[Key Points]
- Focus on only one task within each block
- Even when using Claude Code, don't request multiple tasks simultaneously
- Only allow context switching between blocks

Strategy 4: Context Setting Optimization

To minimize context switching from AI interactions, prepare project-specific settings in advance.

Configuration Files in Project Root

CLAUDE.md (for Claude Code)

# Project Context

## Architecture
- Microservices: Auth, API, Worker
- Message queue: RabbitMQ
- Cache: Redis
- Database: PostgreSQL (with read replicas)

## Coding Standards
- Language: TypeScript (strict mode)
- Testing: Jest (80%+ coverage required)
- API: GraphQL with Apollo Server
- Error handling: Custom error classes with error codes

## Delegation Rules

### Tasks Safe to Automate
- GraphQL resolver boilerplate
- Database migration files
- Pure function unit tests
- Type definition updates

### Human Review Required
- Authentication/authorization logic
- Database transaction processing
- Rate limiting implementation
- Third-party API integration

.cursorrules (for Cursor)

# Task Classification

## Delegate to AI (Background execution)
- Unit test generation
- Documentation updates
- Code formatting and linting
- Repetitive refactoring (cross-file renaming, etc.)
- Dependency updates
- Simple bug fixes with clear reproduction steps

## Human Focus (Attention required)
- Architecture decisions
- Complex algorithm design
- Code review of AI-generated code
- Security-critical implementations
- Performance optimization

## Workflow

1. Break tasks into independent subtasks
2. Identify tasks suitable for AI delegation
3. **Execute one AI delegation task at a time**
4. Human focuses on high-value tasks
5. Review and integrate AI output

## Code Generation Guidelines

- Always include type hints (Python) or TypeScript types
- Include unit tests for new functions
- Follow project-specific naming conventions
- Consider security implications (OWASP Top 10)
- Document complex logic

This eliminates the need to explain the same context every time, making AI interactions short and efficient.

Strategy 5: Complete Automation of Routine Tasks

For tasks that don’t need monitoring, fully automate with scripts. This eliminates even the need for AI tool interaction.

GitHub Actions Automation Example

# .github/workflows/ai-tasks.yml
name: AI Automated Tasks

on:
  schedule:
    - cron: '0 2 * * *'  # Run daily at 2am
  workflow_dispatch:  # Manual execution also possible

jobs:
  update-docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Generate docs from API spec
        run: |
          npx openapi-generator-cli generate \
            -i openapi.yaml \
            -g markdown \
            -o docs/api/

      - name: Generate docs from TypeScript types
        run: npx typedoc --out docs/types src/

      - name: Auto-create PR
        run: |
          git checkout -b docs/auto-update-$(date +%Y%m%d)
          git add docs/
          git commit -m "docs: Auto-generated documentation update"
          gh pr create --title "Automated Documentation Update" \
                       --body "Auto-generated by AI/tools"

This causes the documentation update task itself to disappear from view, no longer causing context switching.

Cognitive Load Reduction Doesn’t Mean Productivity Improvement

Subjective Comfort vs Objective Productivity

Many studies show AI tools reduce cognitive load:

• 73% of GitHub Copilot users report improved flow state and reduced interruptions
• 87% value mental relief from routine work

However, as the METR study[^5] shows, this subjective comfort doesn’t necessarily translate to objective productivity improvement.

Why Does the Gap Occur?

1. Different types of cognitive load: The load from manual coding differs qualitatively from reviewing AI output
2. Psychological comfort: The feeling of being “helped” by AI increases satisfaction
3. Measurement difficulty: Task completion time is measurable, but code quality and long-term maintainability are harder to measure

Importance of Regular Objective Measurement

Rather than relying on subjective satisfaction, regularly measure the following:

Metrics to Measure:

• Task completion time (with AI vs without)
• Code review comment counts
• Bug occurrence rates
• Daily context switch counts

Measurement Tool Examples:

# Track time with RescueTime or Toggl
# Tag each task: "AI used", "AI not used"

# Log context switches
echo "$(date +%H:%M) - Task switch: $TASK_NAME" >> ~/context-switches.log

# Weekly review
grep "Task switch" ~/context-switches.log | wc -l

Implementation Guide: Phased Approach

Phase 1: Current State Assessment (1 week)

Tasks:

1. List currently used AI tools
2. Record daily context switch counts
3. Record which tasks use AI

Recording Example:

[2025-11-12]
09:00 - Request bug fix with Claude Code (Task 1 start)
09:05 - While Task 1 in progress, request test generation (Task 2 start, context switch ①)
09:10 - Check Task 1 output (context switch ②)
09:20 - Check Task 2 progress (context switch ③)
09:25 - Give Task 1 correction instructions (context switch ④)
09:35 - Request documentation update (Task 3 start, context switch ⑤)
09:40 - Check Task 2 output (context switch ⑥)
09:50 - Check Task 3 progress (context switch ⑦)
10:00 - Final review of Task 1 (context switch ⑧)
...

Total context switches: 12
AI simultaneous tasks: Max 3 (within same Claude Code)
Problem: Couldn't track state of 3 tasks, needed repeated checking

Alternative Pattern (Multiple Tools):

[2025-11-13]
09:00 - Start refactoring with Claude Code
09:15 - Algorithm research with ChatGPT (context switch ①)
09:30 - Return to Claude Code (context switch ②)
10:00 - Other feature implementation with GitHub Copilot (context switch ③)
10:05 - Check Claude Code progress (context switch ④)
...

Total context switches: 10
Tools used: 3 (Claude Code, ChatGPT, Copilot)

Phase 2: Task Classification (2-3 days)

Classify current tasks into three categories:

1. Completely delegatable: Formatting, routine tests, etc.
2. Collaboration needed: New feature implementation, complex logic
3. No AI: Architecture decisions, important design

Phase 3: Sequential Delegation Trial (2 weeks)

Rules:

• Use only one AI tool at a time
• Don’t open other tools during collaborative tasks
• Batch process completely delegatable tasks

Measure:

• Task completion time
• Context switch counts
• Subjective fatigue level (1-10)

Phase 4: Optimization and Continuation (Ongoing)

Analyze 2-week trial results and adjust:

• Which tasks are suitable for AI
• What time of day to batch AI tasks
• Project configuration file improvements

Caveats and Limitations

Individual Differences and Learning Curve

AI tool effectiveness varies significantly by:

• Experience level: Beginners tend to benefit more[^4], experts may sometimes slow down[^5]
• Task complexity: AI highly effective for simple tasks, but supervision costs increase for complex tasks
• Tool proficiency: Time needed to learn effective usage

Not All Tasks Are Suitable for Delegation

Tasks Suitable for AI Delegation:

• Routine, repetitive work
• Tasks with clear specifications
• Applying existing patterns
• Test and documentation generation

Tasks Humans Should Execute Directly:

• Architecture decisions
• Security-critical implementations
• Novel algorithm design
• Complex tradeoff judgments

Uncertainty of Long-term Effects

Current research primarily measures short-term effects. Further research is needed on long-term impacts:

• Potential skill degradation from over-reliance on AI
• Impact on continuous learning and growth
• Impact on team collaboration

Summary

Human Multitasking vs AI Tool Usage

	Traditional Multitasking	AI Parallel Delegation (Bad)	Sequential Delegation (Good)
AI Usage	None	Multiple tasks simultaneously on same tool or multiple tools in parallel	Complete one task before starting next
Human State	Switching between tasks	Switching for AI monitoring	Focused on single task
Context Switching	Many	Very many	Minimal
Cognitive Load	High	Very high	Low
Productivity	Up to 40% loss[^1]	Possible 19% delay[^5]	Potential improvement
Subjective Satisfaction	Low	High (possibly illusory)	High
Concrete Example	Multiple manual tasks	3 tasks to Claude Code simultaneously or Copilot+ChatGPT+Claude in parallel	Complete Claude Code one at a time

Fundamental Difference Between AI and Human Subordinates

Bosses don’t become multitaskers when assigning work to multiple subordinates because subordinates have high autonomy and bosses can review asynchronously.

AI as of 2025 is not yet as autonomous as human subordinates:

• Frequent confirmation needed: Direction checks needed mid-task
• Cost of interruptions: Interruptions significantly increase stress, frustration, and time pressure[^6], and task switching alone loses up to 40% productivity[^1]
• Batch review difficult: Cannot be left completely alone, continuous monitoring needed

Therefore, executing multiple AI tasks simultaneously causes humans to fall into a multitasking state due to frequent interruptions.

As AI autonomy improves in the future, asynchronous review like with bosses and subordinates will become possible, and this problem will be resolved. However, currently, careful design of AI collaboration is necessary.

5 Principles for Effective Usage

1. Sequential delegation: Execute only one task at a time even on the same AI tool
2. Task classification: Distinguish complete delegation vs collaboration vs no AI
3. Batch processing: Block time for AI tasks and process together
4. Context optimization: Reduce repeated explanations with project settings
5. Objective measurement: Measure actual productivity, not just subjective satisfaction

Understanding the Paradox

AI tools can certainly automate many tasks, but executing multiple tasks simultaneously on the same AI tool or using multiple different AIs in parallel puts humans in a new multitasking state. Understanding this paradox is the first step to effectively leveraging AI.

Especially with powerful tools like Claude Code, precisely because they have the capability to “handle multiple tasks at once,” users must consciously practice sequential usage.

The METR study[^5] result that “experienced developers become slower with AI” can be seen as a warning of this paradox. Without being misled by the subjective comfort of cognitive load reduction, continuously measure objective productivity and find AI usage methods that work for you.

Future Outlook

As of 2025, AI tool adoption is rapidly progressing (76% of developers using or planning to use per Stack Overflow’s 2024 survey). However, the simple thinking that “delegating more to AI is better” may actually reduce productivity.

To truly improve productivity, understanding human cognitive limitations and carefully designing AI collaboration is necessary. The cognitive science drawbacks of multitasking are an essential human constraint that remains unchanged even in the AI era.

---

References

References corresponding to citation numbers [^1]-[^6] in the main text are listed in numerical order.

1. Digital multitasking and hyperactivity: unveiling the hidden costs to brain health - Hasan, M. K. (2024). Annals of Medicine and Surgery, 86(11), 6371-6373. [Reliability: High]

2. Efficient multitasking: parallel versus serial processing of multiple tasks - Fischer, R., & Plessow, F. (2015). Frontiers in Psychology, 6:1366. [Reliability: High]

3. Brain Mechanisms of Serial and Parallel Processing during Dual-Task Performance - Sigman, M., & Dehaene, S. (2008). The Journal of Neuroscience, 28(30), 7585-7598. [Reliability: High]

4. The Impact of AI on Developer Productivity: Evidence from GitHub Copilot - Peng, S., Kalliamvakou, E., Cihon, P., & Demirer, M. (2023). arXiv:2302.06590. [Reliability: Medium-High]

5. Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity - Becker, J., Rush, N., Barnes, E., & Rein, D. (2025). arXiv:2507.09089 / METR Blog. [Reliability: Medium-High]

6. The Cost of Interrupted Work: More Speed and Stress - Mark, G., Gudith, D., & Klocke, U. (2008). Proceedings of the SIGCHI Conference on Human Factors in Computing Systems, 107-110. [Reliability: High]

Other References (Not Numbered in Text)

Resources consulted during article creation but not directly cited in the text.

• Multitasking: does task-switching add to the effect of dual-tasking on everyday-like driving behavior? - Asuako, P. A. G., Stojan, R., Bock, O., Mack, M., & Voelcker-Rehage, C. (2025). Cognitive Research: Principles and Implications, 10:5. [Reliability: High]

• Building Effective Agents - Anthropic (2024). [Reliability: High]

• Media Multitasking and Cognitive, Psychological, Neural, and Learning Differences - Uncapher, M. R., & Wagner, A. D. (2018). Proceedings of the National Academy of Sciences, 115(40), 9889-9896. [Reliability: High]

• Cognitive Challenges in Human–Artificial Intelligence Collaboration - Bader, V., & Kaiser, S. (2022). Information Systems Research, 33(2), 678-696. [Reliability: High]

• AI in the Workplace Statistics 2025 - Azumo (2025). [Reliability: Medium]

---

On Citation Accuracy:

The studies cited in this article have been verified through the following methods:

• Confirmation in academic databases (PubMed, arXiv, Google Scholar, etc.)
• Verification of paper information on official journal websites
• Cross-verification through multiple independent sources (academic media, official research institution announcements, etc.)

Full PDF access may be restricted for some papers, but abstracts, DOIs, author information, and key findings have been confirmed through official academic databases and reliable secondary sources.

---

This article was written by AI (Claude Sonnet 4.5). All claims are based on reliable sources, but please adjust for your own environment and requirements when implementing.