Agents make low-value work feel productive

I spent $500 on API credits in a day recently.

On paper, that's easy to justify. If a senior engineer can get a week's worth of output done in a day, the numbers look fine.

The problem is the numbers lie a bit.

The easy math

Agents let you produce a stupid amount of code now. Rewrites that would've dragged on for days can happen in an afternoon. Old services can get cleaned up. Duplication disappears. Test coverage improves. Naming gets less embarrassing. The repo feels lighter.

You look at the diff and think: great, huge win.

Sometimes it is.

Sometimes you've just spent a lot of money making old code nicer to work in, while doing almost nothing for the business this week.

Where the math breaks

A week of engineering effort is not automatically a week of value.

That's the part people keep glossing over.

If I use agents to tear through a bunch of overdue rewrites, there's real value there. Lower tech debt matters. Better structure matters. Stability matters. Future feature work gets easier. I'm not saying that work is not important.

I'm saying it gets way too easy to justify because agents make the execution cost feel cheap.

Before agents, a lot of that work stayed in the backlog for a reason. It wasn't always because nobody cared. Sometimes it was because, when forced to choose, the company had better places to spend senior engineering time.

Now the friction is gone, so the prioritisation discipline disappears with it.

That's a slippery slope.

The trap

Agents are brilliant at helping you finally do all the boring shit you've been putting off for years.

That feels productive because it is productive. You are shipping changes. The code is cleaner. The todo list is shrinking. Seeing those diffs with 50k lines of code removed or whatever is amazing.

But the real question is whether the work moves the needle.

Does it unlock revenue? Does it remove meaningful risk? Does it speed up an important roadmap? Does it let the team do something they genuinely could not do before?

If the answer is no, you may just be paying to satisfy engineering discomfort quickly.

That is a very different thing from moving the org forward.

Where I think tokens should go

I think agent spend is easiest to justify on work that used to be constrained by complexity, not work that was ignored because it was boring.

Use them for:

• hard migrations with real upside
• gnarly investigations
• ambitious feature scope
• prototypes that answer expensive questions quickly

Be much more suspicious when the pitch is:

• finally rewriting that thing
• cleaning up this old service
• fixing all the little code smells
• making the repo nicer

Those jobs can still be worth doing. They just shouldn't get a free pass because the prompt box makes them easier.

The rule

Before spending serious tokens on a task, ask one blunt question:

If this gets done today, what actually changes for the business?

If the answer is vague, the spend probably is too.

Token prices will keep moving around. Models will get cheaper in some places and more expensive in others. That matters.

The bigger risk is burning budget on work that creates a lot of output, a lot of satisfaction, and not much leverage.

Agents are incredible for expanding scope.

Using them to accelerate low-priority housekeeping is a waste of a very good weapon.