Scaling Agentic Coding As If People Still Mattered

· Code for Humans and Machines ·

8 min read Original article ↗

The other week I read Gergely Orosz’s excellent post on the state of the tech industry in 2026. In that post, several prominent developers share how they work with 5-10 parallel agents, each one running in a separate terminal tab. This is a trend that I think is about to enter the mainstream.

That trend also ties into a topic I’ve written about before: the cognitive cost of faster coding. Back then, I claimed that agentic coding is mentally expensive and more effortful than old-school manual coding. This time, I want to expand and revisit the human consequences of running five agents in parallel. I mean: what could possibly go wrong?

First, let me clarify an important point: the number of parallel agentic tasks in itself is not the problem. The problem is the number of focus tasks.

I’m running multiple agents myself, but I restrict myself to one focus task. That’s the task requiring my involvement, my decisions, and my sign-off. My other agents typically work on maintenance tasks (e.g., upgrading a dependency or researching new language features that our product needs to know about) or minor bug fixes. I never need to babysit those and can check their outcomes during a break.

The big shift with agents is that it’s now technically feasible — and consequently tempting — to launch multiple workstreams. In fact, the entire agentic workflow actively encourages it. I mean, when launching an agentic task, I never know what the wait time will be. Are we talking 30 seconds, or do I have to watch the internal LLM ramblings for 25 minutes? That wait time is like an open invitation for self-interruptions, which are the most damaging types of context switches. AI coding just gives us so many passive pause points: waiting, reviewing, correcting, waiting again, ad infinitum.

To avoid getting bored, it’s tempting to embark on a second and third task in parallel just to stay busy. This is often a mistake: agents scale; human attention doesn’t.

When trying to balance multiple focus tasks in parallel, you’re likely to experience combinations of the following:

  • Attention residue: When switching tasks, part of our attention remains occupied by the previous task. This hurts our performance on the next task, making us less effective as we go along.

  • Decision fatigue: The quality of our decisions deteriorates after sessions of continuous choices. It’s not only draining but also means things will slip through your software factory that a fresher version of yourself would have caught.

  • Stress: An interesting study indicates that people attempt to compensate for context-switching costs by trying to work faster. That compensatory strategy is likely to cause growing stress, frustration, and a sense of time pressure.

  • Diminished creativity: Creative thoughts tend to arrive when we let our minds wander. Constant busyness and task switching are directly at odds with that.

Each one of these might be unpleasant enough in isolation. Combine them for a longer period of time, and you’re at risk of both a loss of motivation and burnout.

Even if we magically sustain the pace, the constant context-switching will have damaging consequences for the future of the products we work on. To understand why, we need to dig into the human process of creative problem solving.

I did my first psychology thesis on the topic of Unconscious Thought Theory (UTT). I was simply interested in how we humans make complex decisions in situations where we’re flooded by data and trade-offs.

The core idea in UTT is that our minds constantly keep processing information in the background. (Think of a bunch of background processes). UTT then proposes that when we’re faced with open-ended, complex problems, thinking hard about them might not lead to a solution. The cognitive complexity is simply too large; the problem has too many variables. By stepping away, we allow our brains to integrate and process the information. New connections emerge that we wouldn’t have come up with through effort.

UTT influenced how I solve problems. Whenever I find myself stuck, I simply refocus on learning as much as possible about the problem as opposed to actively trying to push through and solve it. Once I’ve learned what there is to learn, I then go off for a walk and listen to some cool music. More often than not, an idea pops into my head.

UTT never got that big as a theory and has its academic challenges. But related research supports the need for incubation: engaging in activities that allow your mind to wander does wonders for creative problem solving.

We don’t yet understand the mechanisms behind — maybe it is indeed unconscious thought, or it’s just the switch in perspective — but it’s clear that this is at odds with monitoring five agentic tasks in parallel. There’s a risk that by optimizing for perceived productivity, we eliminate the downtime our wetware needs.

The need for focus becomes even more obvious when we look under the hood of a typical development task. One product feature rarely means one development task. There’s a poorly understood concept in software engineering that captures the challenge: requirements explosion.

The term requirements explosion was first coined by Robert Glass, who argued that “for every 10-percent increase in problem complexity, there is a 100-percent increase in the software solution’s complexity.” In other words, each requirement in your input spec will lead to tens of implicit design requirements that need to be resolved. We cannot leave that as guesswork for an agent to figure out.

So with five parallel agents, you are not juggling five tasks. It’s more like 50.

The concept of requirements explosion: one product feature rarely means one development task.

The role of the software engineer is already shifting, with two key responsibilities emerging. First, we developers will be important in helping to decide what to build. Second, we will create environments that guide and constrain how that software is built.

Neither of these responsibilities is trivial, nor do they come with clear-cut answers. So why are we embracing workflows that remove the very foundations of creative thinking and effective decision making? I suspect a combination of three forces:

  1. Copying without context: Most trends in software come from a specific context. Microservices, for example, evolved partly to solve the problem of organizational scaling. When these ideas hit the mainstream, the original context and constraints are often missed. Agentic workflows are probably the same. If I were working in a high-stakes company months away from an IPO, then that short-term goal could be worth the long-term sacrifice.

  2. We mistake busy for productive. The best code was always the code we didn’t have to write. This happened each time we thought a bit more about the problem we were trying to solve and found a simpler solution. Agents don’t change that. No code is “free” in the financial sense.

  3. The agentic experience encourages us: As I pointed out, the current agentic UX encourages exactly this behavior due to its unpredictable wait times. We’re getting gamed to fill a perceived gap.

We’re simply facing a brand-new luxury problem: the average organisation now has more coding capacity than ever. And it wants to spend it, which is why this friction occurs: there’s an imbalance between the ever-expanding production capacity and our fairly stable human cognitive capacity.

I’m not immune to these forces myself. Over this past year, I’ve shipped more product increments than ever before. With AI, I can finally build features I had wanted for years but couldn’t afford to build manually. I did that while attempting to follow my own advice in this article. I have to admit that it wasn’t always easy: as developers, we are conditioned to keep up the pace, even when we’re making more progress than ever.

But the core aspects of the problem are of course not new. We’ve probably all been hit by the negative consequences of multi-tasking at some point. I remember myself living through it in the pre-AI days.

Like many founders, I had to do a ridiculous amount of work during the formative years of my startup. For the first five years, the company was bootstrapped. That meant I had to do marketing, handle sales, and manage my small team, all while building the evolving product. I pulled all-nighters writing code just so we could match a specific enterprise requirement standing between us and a large deal.

One thing I noticed, though: the busier I became, the fewer new ideas I got. Yes, I got a lot of things done, but I was cannibalizing my own future: once ideas and creativity start to drain, you’re on a downward slope.

And now I’m seeing a whole generation of developers about to face the same situation. In a couple of months, the expectations on many devs will be to process multiple tasks daily and in parallel.

Sustainable AI-first processes and workflows need to account for that. Otherwise, we risk optimizing for perceived productivity at the expense of the creativity and decision-making skills that determine what we can build tomorrow.

Discussion about this post

Ready for more?