AI-assisted delivery
Teams with AI agents start more work than ever and ship about the same. The entry got cheap; verification, integration, and shipping didn't. The way out is an old discipline: limit work in progress and count finished work, not started.
Starting new work has never been cheaper. One more agent thread. One more idea. One more experiment running in the background. The cost of beginning something has collapsed — an AI agent will take any task you hand it, instantly, at any hour.
Here is what didn't collapse: the cost of finishing. Verification, integration, review, deployment — getting work to the state where it runs on production and earns its keep — costs almost exactly what it cost before.
So teams start more than ever and ship about the same. Boards fill up with half-done work. Agents run all day, the token bill grows, and somehow the release notes look no longer than last quarter's.
This isn't a tooling problem, and better prompts won't fix it. It's an old flow problem, amplified by new tools — and the fix is old too: limit work in progress and optimize for finishing, not starting. The winner isn't whoever launches the most — it's whoever finishes the most. The rest of this article is the case for that claim: first in money, then in mechanics.
For decades, the cost of one task was invisible — buried inside fixed salaries. A developer's month costs the same whether a feature took three attempts or thirty, so nobody counted attempts. With AI agents, every action has a price tag — and the accounting becomes very visible, very fast.
Here's what it looks like in practice. An agent made 40 attempts, spent $15 in tokens, and still failed to deliver a working feature. Now multiply that by every task your team runs in a month. The loop behind that bill is familiar to anyone who runs agents on real work: an attempt. Almost works. One more attempt. A bit better. Then something breaks, the context slips, you start fixing — and it gets worse. Somewhere around there you see it clearly: one “task” is rarely one action. It's dozens of iterations — attempts, corrections, dead ends — and you pay for every one of them, including the ones you throw away.
To know what your delivery actually costs, you only need to count three things:
Divide total spend by finished tasks and you get the number that matters: cost per successful task — what one finished piece of work really costs you.
The payoff is that optimization stops being guesswork. Does the new prompt actually help? Do tests around the agent pay for themselves? Did that workflow change do anything? Subjectively, everything always “feels better.” The number doesn't care how it feels: after any change, cost per successful task either went down or it didn't.
One warning before you go optimize it. Watch teams work on this metric and you'll see them go straight for token prices and model tiers — and miss the real leak. The goal isn't to minimize token usage; it's to maximize successful outcomes per dollar spent. And the biggest driver of cost per finished task isn't the price of an iteration. It's all the work you started and never finished.
If you've read how I diagnose delivery systems, the frame here is the same. Every metric that described a human team still applies. Only one thing actually changed:
| Metric | What changes with AI agents |
|---|---|
| Throughput — tasks shipped per period | Nothing. Production counts, not generation. |
| Time to Market — from idea to working result | Nothing. The clock still runs to production. |
| Quality — work usable without rework | Nothing. Rework is still what eats you. |
| NPS — whether the result creates value | Nothing. Value is still the point. |
| Cost per successful task — total spend ÷ finished tasks | Everything. It used to be invisible, buried in salaries. Now every task has a bill. |
You can ship fast but expensive, cheap but drowning in rework, or a lot of it but nothing users need — and the economics quietly stops converging.
The measurement system survived. What changed is where the work piles up.
Two mechanisms eat the gains. Both are old; both got amplified.
The first is waiting. Most tasks in most systems are not being worked on — they're waiting. Now look at an AI-assisted workflow: you wait for the agent (generation, tests, deploy), then the agent waits for you (an answer, a decision, the next instruction). While a task waits, you switch to another one — starting it is nearly free, after all. Every task you add makes the queue longer for all of them. Little's Law — lead time equals work in progress divided by throughput — doesn't care whether the workers are humans or agents. Start more without finishing more, and every task simply lives longer.
The second is context. Every system has a limit on how much active work it can hold. For a human, the limit is attention and memory. Research on interrupted work found that people do compensate for switching — they work faster — but pay with measurably higher workload, stress, and frustration (Mark, Gudith & Klocke, 2008). The cost is real; it's just hidden in the humans instead of the invoice.
For an agent, the limit is the context window — and there the degradation is measurable in output, not stress. A study of web agents on long-context tasks (Chung et al.) found that performance collapses as irrelevant history accumulates in the context — exactly what a multi-task thread produces. With noise built up toward 150,000 tokens, success rates fell from 40–50% to single digits for some of the models tested — GPT-4.1 dropped from roughly 45% to 2.7%.
Humans lose focus, agents lose context — but it's the same failure. Too much work in progress degrades the worker, whether the worker is made of neurons or tokens.
The discipline that fixes this has existed for decades. AI didn't make it obsolete; AI made it mandatory, because the temptation to start more has never been this cheap.
The uncomfortable shift is in what counts as a signal of progress. Started work used to be scarce, so starting meant something. Now that starting is nearly free, the winner isn't whoever launches the most — it's whoever finishes the most. Fewer things in flight, more things done.
If you buy the thesis — finish over start — one more consequence follows, and for AI-heavy startups it's the most important one.
For a solo founder or a tiny team with disciplined AI use, writing code has almost stopped being the constraint. Iterations are cheap compared to the cost of unfinished work; the generation itself is fast. What's scarce now is the ability to decide what to build, why, and for whom — and the ability to drive work to done. For a 5–50 engineer product team, coding isn't free yet, but the direction is the same: the bottleneck is drifting out of code production and into decisions and finishing.
This is Theory of Constraints 101: when the constraint moves, optimizing the old one is wasted effort. Squeezing another 10% out of code generation changes nothing if work dies waiting for verification, review, and a decision.
AI doesn't abolish systems thinking. It makes system errors more expensive — because now the bill for them arrives immediately, itemized, in dollars. If your delivery system loses work between “started” and “shipped,” agents will happily scale that loss for you. (If that's where you are with an AI-built product, I wrote about the rescue path separately.)
Because an agent's working memory — its context window — is a hard limit, and research shows success rates collapsing as irrelevant context accumulates in a thread. Five tasks in one conversation means blurred details and forgotten decisions. Run one thread per task and route side-work elsewhere; you'll ship more with the same agent.
Usually not. With basic hygiene, tokens are a minor line item. The expensive thing is unfinished work: tasks that consumed iterations and died before production, and queues where finished-enough work waits for review. Optimize completion rate first; token prices later, if ever.
The opposite. WIP limits existed because starting was tempting and finishing was hard. AI made starting nearly free — which makes the temptation stronger and the limit more valuable, not less. And it now applies to your agents as much as to your team.