The Next Project Is the Trap

A project gets hard, a new idea shows up, and twenty minutes later there is a new repo with a working dashboard. The original project is still unfinished. The fresh start feels like progress, but it hasn’t moved the existing work forward.

It is a close relative of the trap in Skill Is a Dependency, handing a problem to the agent before thinking about it. This version hands off the whole project, by walking away from it.

Here is the claim. Agents removed the friction that used to stop most ideas at the door. Without it, work enters faster than it leaves. Output goes up. Throughput, meaning things that are finished, does not have to.

Friction was admission control

Before agents, starting a project meant scaffolding, wiring auth, and picking a schema. That cost filtered ideas. Most of them died in a notes file, which was fine, because most of them were not worth a week.

Now the first hour of almost any idea is close to free. The middle and the end are not. The data model, the auth edge case, and the users who never show up cost what they always cost. Ship Fast. Recover Faster. made the same point about production: faster code generation does not remove uncertainty, it moves the pressure somewhere else.

Cheap work also changes what you choose to do. When some tasks become nearly free, they crowd out the ones that matter. Measuring how fast you got through the new mix of work overstates what you gained, because part of that mix only exists because it was cheap. A dashboard that took an hour is not evidence that the dashboard was worth building.

In Retries as a Load Multiplier, admission limits protect a dependency even when callers misbehave. Here the protected dependency is you, and the admission limit is gone.

Little’s Law for your attention

Little’s Law says the average number of items in a system equals the arrival rate times the average time each item spends there. It holds for stable systems under very few assumptions.

$$L=\lambda W\Rightarrow W=\frac{L}{\lambda }$$

Rearranged, it tells you how long work waits. With 12 open projects and one finished a month, the average project stays open for 12 months. Starting a 13th finishes nothing sooner. It makes the average wait longer.

The law describes averages in a stable system, and a person’s side projects are not a clean queue. Many items never leave; they are abandoned. That is the point. An item that never completes is not throughput, and a system where arrivals outpace completions is not stable: work in progress grows without bound. Queueing Theory in One Picture shows what happens to waiting time as a server approaches 100%.

There is one more difference. The simple queueing model assumes the server moves from one job to the next for free. You don’t.

Switching is not free

The cost of switching shows up at every timescale.

• Seconds. Alternating between tasks costs time, and the cost grows as the rules of each task get more complex.
• Minutes. Part of your attention stays on the task you just left. This attention residue is heavier when that task was left unfinished.
• Programming sessions. After an interruption, programmers rarely go straight back to editing. They first move around the code to rebuild the context they lost.
• The bill comes later. Interrupted work can finish just as fast while leaving you more stressed, rushed and tired. It can look efficient while it wears you down.

Agents add a new source of switches. Every agent run is a pause, and a pause is where a switch happens. When you open another project during that pause, you are scheduling your own interruptions.

Feeling productive is a bad sensor

The hardest thing to see in AI-assisted development is not whether it speeds you up. It is that you can’t reliably tell from the inside.

A day full of prompts, diffs and green checks feels productive. Whether it was depends on what finished. Developers have always tended to judge a day by how busy it felt, and agents make every day feel busy.

This is the problem from Why p99log again. The sensor in your head reports activity, the way an average-latency dashboard reports that everything is fine. It does not report completions.

Why the new project always looks better

The new project has no history yet. The current one does. Comparing them means comparing an estimate with a measurement.

People forecast from the version of the work in their head and give little weight to how similar work went before. That is the planning fallacy, and it is why deadlines slip. A fresh idea is nothing but plan. The project you are stuck on has already met reality.

Reward adds to the pull. Surprise feels good, and last month’s surprise becomes this month’s baseline. The first time an agent built a working app from a paragraph felt remarkable. Now it is expected, and the feeling needs something newer.

Agent output is also intermittent. Sometimes the first prompt works and sometimes ten prompts don’t. Rewards that arrive unpredictably keep people going longer than rewards that arrive every time. And the most surprising output of all is usually the first working version of a brand-new idea.

Open loops cost attention, and judgment

Unfinished work pulls at you. You keep drifting back to it in your head, even while you work on something else.

The good news is that you don’t have to finish something to close the loop. You have to decide what happens next.

• A specific plan quiets the loop. Writing down the next concrete step for an unfinished goal reduces the intrusive thoughts it causes.
• A resume note cuts the residue. A short note written before switching, saying where you are and what comes next, frees you to give the new task your full attention.
• Cues beat memory. Coming back to code is faster when you can see what you were last doing than when you have to remember it.

Open loops also cost judgment. Watching automation well takes attention, and when that attention is split across other work, people start trusting the output instead of checking it. Experience does not prevent this. Several agents running across several projects is that setup. Review gets thinner exactly when there is the most to review. Synthetic Resilience describes what slips through.

The hard middle of a project is also where skill forms. Debugging the thing that won’t work is how you learn how it works. Leaving whenever a project gets hard skips the part that builds the judgment Skill Is a Dependency argues for.

Controls that help

The answer is not to use agents less. It is to put back the controls the friction used to provide, deliberately this time.

1. Set a WIP limit. One active project and one experiment. Everything else goes in a queue. Little’s Law says this is the only way to shorten the time each project spends open without finishing faster.
2. Keep an admission queue, not a graveyard. Each idea gets a date, a line on why now, and the first concrete step. Review the queue weekly. Writing the specific step is what frees attention, so a vague note is not enough.
3. Write a resume note before you switch. Where you are, what comes next, and what you were unsure about. It takes two minutes and is the cheapest fix for attention residue in this list.
4. Decide what agent wait time is for. Read the code the agent is touching, review the diff so far, or do nothing. Don’t start a project.
5. Ask whether you are choosing or escaping. If the current project has just reached its hard part, that is a reason to stay, not to leave.
6. Give new projects a stop condition. Treat them like a canary in Ship Fast. Recover Faster.: decide in advance what “worth continuing” means after a week, and stop if it isn’t met.
7. Measure completions, not output. Each month, count projects finished and projects killed, and track the age of the oldest open one, the way you would watch the age of the oldest message in a queue. Rising WIP with flat completions is a growing backlog, however busy the week felt.
8. Kill projects explicitly. Archive the repo and write one line on why. Retries as a Load Multiplier gives invalid messages a dead-letter policy; projects need one too. A killed project is a closed loop. A silently abandoned one stays open.

What this post does not claim

• That AI makes you slower. Agents can save real time. The point is about where that time goes.
• That this is addiction. Some of the patterns overlap with compulsive behavior, but that is a clinical question this post does not try to answer.
• That the psychology is about agents. Most of what we know about attention, switching and planning predates coding agents. It describes mechanisms, not measurements of people using agents.
• That parallel agents are wrong. Parallel work is fine when the work is independent and someone reviews it. The problem is parallel projects that nobody is finishing.

The tail of a project

The average day with agents looks great: lots of output and plenty of green checks. The tail is the week a project gets hard, and that week decides whether anything ships.

Starting is cheap now. Finishing is the bottleneck. Protect the bottleneck.