Before You Split a Task Into Subagents, Run This One-Agent Baseline

Most people add subagents to a Claude Code task and assume the team is faster. This approach does the opposite first. It runs the same task with one agent, then lets the numbers decide.

The idea comes from u/Nir777 on r/PromptEngineering, and it’s simple enough to try today. Before you split anything up, run this prompt:

“Do this task yourself, without subagents. Read the files you need, make the change, and run the tests.”

Then run your subagent version with the same time limit and compare /usage. That’s the whole test. It takes maybe twenty minutes of setup, and it can save you hours of babysitting a pipeline that never needed to exist.

The old way vs the new way

The old way: you look at a task, decide it’s big, and spin up a planner, a coder and a reviewer. It feels organized. Nobody checks whether it actually beat one agent doing the whole thing. Picture a bug fix in a mid-sized repo. The planner writes a plan, the coder re-reads the same files to follow it, and the reviewer reads them a third time. Three agents, three rounds of context loading, and handoff notes that lose detail along the way.

The new way: the single agent is your baseline. If the team can’t beat it, you’ve added cost and moving parts for nothing. A single agent keeps everything it learned in one context. It read the file, it knows why the function looks that way, and it doesn’t need a summary to pass along. That’s a real advantage, and it’s the one you have to beat.

There’s a fairness problem in how these comparisons usually go. A team almost always gets more compute than the one agent it’s compared to. So a team that looks better might just be a team that spent more. Matching the time limit and reading /usage keeps the comparison honest. Think of it like comparing two cars by giving one of them a bigger fuel tank. The result tells you about the tank, not the car.

How to run the check

  1. ✅ Pick one real task, something with files to read, a change to make and tests to run. Avoid toy examples. A refactor across three or four files with an existing test suite works well, because you can see both the quality of the result and the cost to get there.
  2. ✅ Run the one-agent prompt above. Note the time limit, the result, and the /usage numbers. Write them down somewhere, even in a scratch file. Also note whether the tests passed on the first try, since that’s a quick quality signal.
  3. ✅ Run your subagent version on the same task with the same time limit. Compare /usage. Start both from the same clean git state so neither run inherits leftover changes from the other.
  4. ✅ Run both twice. A break can show up in only one of two runs, so a single pass can fool you. If the two runs of the same setup disagree a lot, that variance is itself useful information about how much to trust the result.

What the community is saying

One commenter said most of their subagents ended up as skills inside one main loop. They keep planning and execution separate, with one model planning and another executing, and they still want review to come from a different model in a different harness. That’s a useful middle path: you keep the structure, but you don’t pay for a whole team of agents when a reusable skill does the job.

Another said that in their own tests, the single agent caught 37% of the bugs the subagent team missed, but only when it got 1.5x the time, and they decided the trade-off wasn’t worth it. That’s one person’s setup, not a universal rule. It does show why the baseline matters: the answer depends on your task and your limits. A 1.5x time budget might be a bargain on a small task and a dealbreaker on a long one.

The original post says subagents do pay off in some cases. The author covers those in their newsletter, so I’d read that before writing subagents off completely. The point isn’t that teams are bad. The point is that you should know what they’re buying you. Tasks that split into truly independent pieces, like researching five separate libraries at once, are the kind where parallel work tends to make the most sense.

Your move

Pick one task you were about to hand to a team. Run the one-agent version first, compare /usage, and repeat once. If the team wins, keep it and you’ll know why. If it doesn’t, you just saved yourself a pile of tokens! Drop your results in the comments, I’m curious which tasks actually earn their subagents.

Frequently Asked Questions

Q: Should the same model review the subagents’ work?

One commenter says no. Review should come from a different model in a different harness, because a harness reviewing its own output tends to find nothing real while still burning tokens. They plan with Opus and hand execution to Codex, so the reviewer is never the one that wrote the code. If a missed bug costs more than the tokens you saved, that review step is worth paying for.

Q: Is a single agent worth it if it needs more time?

One tester found the single agent caught 37% of the bugs the subagent team missed, but only when given 1.5x the time, and decided that trade-off wasn’t worth it. The other commenter’s view is that saved tokens mean nothing if the real problem slips through, so a missed bug can cost more than the extra time. Run both versions on a task you actually care about before you pick a side.

Q: What can I do instead of spinning up separate subagents?

One commenter turned most of their subagents into skills that run inside one main loop. Planning and execution stay as separate roles, so each job still has a clear focus without the overhead of extra agents. Keep a separate agent only where the work truly runs in parallel or needs a different model.

Run this prompt before you split a Claude Code task into subagents
by u/Nir777 in PromptEngineering

Scroll to Top