I Let AI Agents Run My Dev Team for Two Days. Here's What It Cost.

For two days I ran DogBase's biggest launch of the year the way the AI demos promise: one Claude Code session acting as a tech lead, handing tasks to a team of AI agents, each in its own copy of the code, building, reviewing and testing in parallel while I tried the app and sent feedback.

A week ago I wrote about what one security update cost me with Superpowers. This is the sequel: a bigger launch, more agents at once, and the day the bill and my laptop both said stop.

It worked. The launch got built: a redesigned insights area, a new sidebar, readiness requirements that let each K9 unit define what "ready to deploy" means for its dogs, workload tracking per dog, and a pinned row on the dashboard. Four rounds of my feedback, each one turned around in hours.

It also froze my laptop, and one feedback round cost about 1.9 million tokens. This is what happened, where the cost went, and the five rules I changed.

The setup

DogBase is one repository with a web app (SvelteKit), Go services, Firebase functions and a mobile app. I use Claude Code with a workflow plugin that runs the whole process: brainstorm, write a spec, write a plan, then build the plan with agents.

The build step is the interesting part. The main session doesn't write most of the code itself. It hands each task to a fresh agent working in its own git worktree, then sends a reviewer agent over the result, then a fix round if the reviewer finds something, then a final agent that runs every test the project has. Between rounds I opened the app, clicked around and wrote down what was wrong.

On paper this is a small, tireless team. In practice it behaves like one, including the parts nobody budgets for.

What went wrong

My Mac froze. On the first evening nine agents were running at once: seven building, two reviewing. Each one ran the type checker, the unit tests and sometimes the Firebase emulators. My Intel Mac ran out of memory. The type checker got killed, a three-minute test run took twenty-two, and I had to hard-reboot. About thirty leftover copies of the code were also sitting in the project folder, and my editor was watching all of them.

✕

The token bill. The fourth feedback round was about twenty UI fixes: spacing in the top bar, a messy settings panel, chart tabs in the wrong place. It cost roughly:

• five builder agents: about 95k, 125k, 200k, 285k and 280k tokens
• one review of all the changes: about 250k
• one fix round: about 300k
• one final local test run: about 330k, over 87 minutes

That adds up to about 1.9 million tokens for one round of feedback. The round before it had a final test run that cost about 715k on its own. It hit my five-hour usage limit halfway through and had to be resumed.

✕

The time. The final check ran everything locally: about 6,400 unit tests, the type checker, Go tests against emulators, and around 200 browser tests. Each run took one to four hours, and my laptop was sluggish the whole time.

The mess. By the end, 74 copies of the code had piled up. 69 of them could be deleted straight away.

Where the tokens actually went

I expected the cost to be in writing code. Most of it wasn't.

✕

Every agent read the handbook on day one. Each helper starts with no memory. My instructions told every one of them to read the project rules, the spec, the plan, the design guide and my notes before touching anything. That's 50,000 to 100,000 tokens before the first line of code, repeated for every agent.

The final check was verification theatre. An agent running every suite locally, reading long logs and browsing the app with screenshots cost 300k to 700k tokens a round. My CI on GitHub already runs those same tests on every pull request.

Reviews of reviews. A task got reviewed, fixed, then reviewed again. The same change was read two or three times by agents starting from zero.

The biggest model for everything, including renames, docs and reading test output.

Small fixes sent to agents. A one-file CSS fix done by an agent cost 100k tokens or more. When the main session just made the edit itself, it cost a few thousand.

The five rules I changed

1. Agents read only what they touch. Tasks are now split by layer: backend, web, functions. The brief carries the few lines of the spec that matter and names the exact files to change. The agent reads those files and that part of the app's rules, nothing else.

2. The right model for the job. I tested this rather than assuming it. The bigger model (Opus) is noticeably better at building features and fixing real logic bugs, so it keeps those. The smaller one (Sonnet) does reviews, reads CI failures, makes mechanical changes and writes docs. And small fixes don't go to an agent at all: the main session makes them directly.

3. My eyes come before code review. The new order is: build, I try it, fix my feedback, one light code review, push. I was the best UI test in the whole process, and I was coming last. A UI try-out can't catch a wrong permission check, so one code review stays. Re-reviews of fixes only happen if something was critical.

4. CI is the full test. No local final-check agent. My GitHub Actions workflow already runs only the parts of the repo that changed, cancels outdated runs when I push again, and covers unit tests, database rules, browser tests and the Go tests against emulators. Push once per round, fix the failures in one batch. Before merging, Claude asks me whether I want a local run anyway.

✕

5. Hard limits. At most four agents at a time, at most two of them building. Every copy of the code gets deleted as soon as its work is merged.

Offloading the load (and why it doesn't save tokens)

My first instinct was to move everything off my laptop. Here is how the options compared:

• Local checks (before): heavy laptop load for hours and a high token cost. Free, but the laptop is unusable.
• GitHub Actions (chosen): no laptop load, low tokens. Costs Actions minutes per run.
• Self-hosted runner on a VPS: no laptop load, low tokens. A small monthly server bill plus upkeep.
• Claude Code in the cloud: no laptop load, but the same tokens. No setup.

I chose GitHub Actions, because it was already set up. If the minutes ever run short, the same workflow can run on a cheap VPS as a self-hosted runner, which is fine for a private repository.

The lesson I didn't expect: offloading moves machine load, not tokens. Tokens are the work itself. Running the same agents in the cloud costs the same. The only thing that lowers the bill is changing how the work is organised.

What I'd tell another founder

• Parallel agents are productive, but each one is a new hire reading the whole handbook on its first morning. Give it the two pages it needs.
• The expensive part is rarely writing code. It's checking, re-checking and re-reading.
• Your own eyes are the best UI test you have. Put them before code review, not after.
• Measure it. Every agent reports its token count. Add them up per round, and you'll see where it goes.

I'll run the next round under these rules and post the before-and-after numbers.