AI has flipped who’s waiting. It used to be that the machine sat idle while the human typed. Now the human sits idle while the machine processes. The natural response is to multitask — kick off one job, context-switch to another, check back later. But context-switching is not a solution. It’s a symptom of systems designed for machines, not for humans.
The context-switching tax
Context-switching enforces machine-shaped mental patterns onto the human. You’re juggling tasks not because your brain works that way, but because the technology demands it. Sometimes the result of one problem depends on the solution of another. All of that mental overhead — managing the meta-process of building — saps energy from the human’s actual potential.
People don’t naturally think in task queues. They think non-linearly, in bursts, about specific problems that may or may not be related to the one before or the one after. Ideas arrive partially formed. The system should accept that stream of thought as it comes — pause, process, and deal with it — rather than forcing the human to package their thinking into neat machine-friendly chunks.
Design for humans, not machines
The general principle: when designing systems that involve both humans and AI, optimise for human time. The machine waits on the human, not the other way around.
Concretely, the machine maintains a queue of work to perform and a queue of questions it needs answered. The human shows up when they’re ready, reviews what’s there, makes decisions, dispatches more work, and moves on. The human is the outer loop.
This inverts the current project management model. Right now, humans drive and tools track. In the new model, AI is autonomous — fleshing out requirements, writing code, reviewing it — and humans get queried for decisions and direction. The things only humans can provide.
What only humans can provide
The human’s job is to bridge between the construction of a system and the population of humans who’ll benefit from it. Agents don’t know what people want. Someone has to represent the users, understand the problem, and know enough about the solution to guide the build. That’s the human’s unique position — part user advocate, part builder.
Where we are now
I’ve built a basic version of this for myself — a task-oriented agent orchestration system using Gitea as the single source of truth. A product agent fleshes out issues. A code agent works on pull requests. A review agent checks the work. It’s a start, but it’s a shadow of what I’m describing here. I’ve retrofitted AI development onto the existing software development tooling we have available. Issues, merge requests, code review — all patterns designed for humans working at human speed.
It’s clear we need to go beyond that. The tools we have were built for a world where the human did the work and the machine tracked it. That world is inverting. We need tools designed from the ground up for a world where machines do the work and humans provide direction on their own terms, in their own time, in their own way.
The processes themselves will get faster. But the principle won’t change. Design for the human first.