The promise of AI coding assistants like Claude Code is seductive: delegate the tedious refactoring work while you focus on architecture. But developers are hitting a snag nobody warned them aboutโ€”the cognitive whiplash of waiting for an agent to think.

The Context-Shift Tax

A developer writing on DEV.to described the experience in brutally honest terms. They asked Claude Code to refactor a module and immediately faced dead timeโ€”not long, but enough to open a browser tab, half-read some random thread, and completely lose track of what they were trying to accomplish. When the run finished, they had to re-read their own prompt just to remember the original task. This isn't an edge case. It's the fundamental UX problem with current AI agent architectures. These systems require significant compute time for reasoning, file operations, and context building. Meanwhile, developers sit in a liminal space where they're neither actively coding nor truly resting.

Why This Breaks Productivity

The human brain doesn't switch contexts cleanly. When you task an AI to handle something and then browse Twitter/X while waiting, you're not banking free timeโ€”you're fragmenting your attention. The context you were holding about the codebase evaporates faster than you'd expect, especially for complex refactors that touch multiple files or introduce architectural changes. The irony is brutal: developers adopted AI agents partly to reduce cognitive load, but the waiting period introduces a different kind of mental overhead. You can't fully disengage because you need to review the agent's output when it finishes. You're perpetually half-attending to two things at once.

What Developers Are Doing About It

Some teams are restructuring how they use these toolsโ€”breaking larger refactors into smaller, faster tasks that don't require extended waiting periods. Others have adopted a "queue management" approach: batching multiple requests during meetings or commutes when they're already context-switched anyway. The more interesting solutions involve rethinking the human-agent interaction entirely. Rather than firing off a task and waiting, some developers are experimenting with continuous background agents that handle incremental changes without requiring explicit wait states.

Key Takeaways

  • The "thinking time" between launching an AI agent task and receiving results creates genuine context-switching overhead that undermines productivity gains
  • Developers cannot fully disengage during agent wait periods because they must review output when it finishes, leaving them perpetually half-attending to two tasks
  • Teams are adapting by breaking larger refactors into smaller batches or batching requests during naturally interrupted times like meetings

The Bottom Line

Current AI coding tools have a time-to-think problem that creates a genuinely new kind of developer friction. Until agents can deliver results faster or maintain persistent context across interruptions, the "typing while the agent thinks" experience will remain a rough edge in the AI-assisted development workflow.