Brent Fitzgerald came back from a few weeks away from his computer and opened it to eleven cmux tabs. Several contained agents paused halfway through professional tasks, personal projects and things somewhere in between.1

This is not a benchmark. That may be exactly why the detail is worth keeping.

Agents reduce the execution cost of an idea. When that cost falls, we can start more things. The bottleneck quietly moves from “how do I build this?” to “which of these things deserves to be finished?”

Every idea can become an obligation

Fitzgerald describes those tabs as small pieces of debt: projects he thought he should automate, personal tools of questionable usefulness, conversations he is unlikely to read again. He does not claim AI has this effect on everyone. He is describing his own experience.1

What agents change is the cost of starting.

A small personal software idea used to hit resistance quickly: initialise the project, understand an API, build the first screen, debug it. That friction killed plenty of mediocre ideas before they became projects.

An agent can remove part of that friction. That is excellent for the good idea. For the other fifteen, it can create fifteen more branches that now need attention.

Fitzgerald describes a subtler loss too. Personal projects used to be a way to learn and tinker. By accelerating toward the result, he says he sometimes skipped the part that made the project enjoyable: learning.1

The shortcut worked technically and failed at the human objective.

Productivity can manufacture its own work

He describes a loop that has become familiar in 2026: using tools that make work faster to build systems that help us use even more of those tools.1

One agent supervises another. A dashboard tracks parallel tasks. Memory summarises sessions. A notification says an agent is waiting for a decision. Eventually the human has built a tiny company where their main job is management.

That does not make parallelism bad. It can be extremely useful for migrations, broad research or genuinely independent tasks. The problem begins when available capacity becomes a sufficient reason to create work.

“Can I delegate this?” quietly replaces “is this worth doing?”

Narrow delegation instead

The interesting part of Fitzgerald's essay is that he does not end by deleting his tools.

After returning, he launches an agent for a work project. The task is narrow: inspect codebases, wikis, schemas and conversations, flag gaps and suggest possible solutions. He supplies context and keeps the decision-making work.1

That looks less like an autonomous employee and more like an expensive function called at the right moment.

It is a useful distinction for our own workflows. An agent can be excellent at absorbing unpleasant amounts of context, comparing files or preparing options. None of that creates a reason to start another initiative.

“Human in the loop” often casts the person as the final checkpoint in an otherwise automated system. Fitzgerald flips it: the human is the loop, and the agent is tagged in occasionally.1

It is less impressive than a terminal with eleven tasks running in parallel. It is also much closer to a day that might actually end.