I used to think AI agents needed detailed step-by-step instructions to use external tools. A common approach is to create more and more agent skills to make agents "more efficient". But that approach was full of ambiguity, burned lots of tokens, and required more expensive models to handle things that are easy for simple software but still hard for LLMs because of their probabilistic nature. So I flipped the approach: I wrote a simple script for the deterministic steps (the parts that I expect always to be the same) and only called a small AI model for each non-deterministic task. The result? Much faster execution, a few cents in cost rather than whole dollars per task, and any cheap model is enough now. If you're facing a similar issue, I can help. Book a call or send me a DM. calendly.com/davidvartanian/…

Arena ran the same coding tasks through seven models and three different coding agents, and the part that caught my attention wasn't which model won. The same model, on the same task, could cost up to five times more depending on which agent was running it, because some agents make more tool calls, retry more often, and keep working much longer before they decide they're done. Most teams budget for AI by looking at the model's price, but a lot of the real cost ends up in those extra loops and later in the review queue, where two or three senior engineers spend their afternoons checking what the agent produced. I'm curious whether anyone is actually tracking that second number yet, or whether it's still buried inside salaries where nobody looks.

Platform teams keep reporting the same pattern this week. A multi-agent swarm queries a shared database in short bursts, connection limits trip, and the morning goes to restoring capacity while feature work waits. Token spend barely moves. The hours spent recovering the store do not show on the agent cost line. If agents can take down a system every team shares, what spend are you actually tracking?

Writing a change got cheap this week. An agent can open a pull request in an afternoon that used to take a sprint. The hours that still hit payroll start after the check turns green: a review only one person can give, a rollback path with no owner, and a caller waiting while two teams argue what shipped. If generation is the cheap part, which cost line tracks the week after merge?

Three coding agents opened PRs before lunch. Generation took minutes. The afternoon went to one senior engineer lining up merges so the diffs did not collide. That wait never shows on the agent spend line. If you only track token cost, what share of the real engineering cost are you missing?

Most AI agents can finish a task. Getting a stack of them to ship without dropping context or ownership is where post-PMF teams bleed hours. You see token spend. You do not see the re-briefs, the rejected runs, and the caller who waited while two agents disagreed. Did more agents this quarter cut the wait between steps, or add to it?

Coding agents made opening a pull request cheap. Then one eng team's test suite nearly quadrupled in a year while the wait for a green check barely moved. Runner minutes show up as a clear cost line. The quieter cost is every change parked until CI clears. Are you cutting runner spend, or the hours of work that cannot start until validation finishes?

Last week, I wrote about the three economic distortions that turn your software decisions into hidden costs. This week, I'm looking at what happens when you try to fix one of those distortions: splitting a monolith. The first instinct is to hunt for natural boundaries in the code. But there are no natural boundaries waiting inside your monolith. Every cut you make based on code alone is arbitrary. The wrong cut costs more than leaving the whole thing intact. It creates new coordination overhead, new sync taxes, and a system that's harder to change than the monolith you started with. If you keep splitting without understanding your product's real seams, you end up with more complexity, not less. This is article 14 of The Engineering Tax series. Read the full article here: beamersoftware.com/blog/the-…

The estimate said two days because it counted the schema change. Six reports still read the old columns, and fixing those took another week that never sat on the original ticket. How often does your two-day change leave a week of work nobody estimated?

You closed the migration when the new system took the traffic. Two years on, you're still paying people who know the old one, and that spend never got its own slide next to the project that was supposed to be done. How many quarters have you been funding both systems?

Your burndown can look perfect while a change that used to take an afternoon now needs a thirty-minute call that did not exist a year ago. Closing tickets keeps the board green, and the call time never counts as a miss. If those calls showed up the same way unfinished work does, how many green sprints would still look green?

The estimate said three days because it counted coding. Two of those days were waiting on a review only one person on the roster can give, and that wait never changed the number on the ticket. How many of your three-day tickets are mostly idle time?

Your sprint board can stay all green while a one-day change turns into four because two other teams still have to move first. Waiting never paints a cell red, so how many green weeks have you stacked where the product still got harder to touch?

This is super useful. Anyone else creating a fleet of bots to get things done?

The estimate said two days because it only counted the service you own. Three other teams still had to ship the same week so callers would not break, and that work never landed on the original ticket. How often does your two-day change actually take a week across the company?

Cloud spend gets a slide in every review. Waiting on other teams usually does not. Same week, same payroll, and only one of those numbers makes it into the room when someone asks what engineering actually costs. If you had to put a number on the hours your team lost last month to waits that never hit a ticket, what would you write down?

Most estimates stop at merge. The expensive part is usually the week after, when you're still watching traffic, cleaning up the cases that only real users hit, and getting support caught up so the same ticket doesn't keep bouncing back. If that week isn't on the ticket, the ticket never told you the real cost.

A shared staging box looks efficient until five teams are waiting on it in the same week. The feature work was on the plan. The queue for the environment was not, and that idle time still shows up as payroll.

Yep, it's a hoax.