7 min read
Coding agents run your tests one repo at a time. indo made it 3.3x faster
I measured Claude Code on 54 real repos. With indo and a small Agent Skill, a full test run went from 53.0 s to 16.1 s. Same correct answers, same cost. Here is the method, the numbers and the limits.
Ask a coding agent to run the tests in all your repos. It writes a for loop. Then it waits for each repo to finish before it starts the next one.
Your laptop probably has 8 or more CPU cores. The loop runs one test suite at a time.
I measured this. On 54 real open-source repos, Claude Code took 53.0 seconds to run all the tests and name the repos that fail. With indo and a small Agent Skill, it took 16.1 seconds. That is 3.3x faster. It got the same correct answer, and it cost the same.
This post explains how I tested it, what got faster, what did not, and how to set it up.
The problem: one folder at a time
Many developers work across many repos. A repo (repository) is one project folder tracked by git. Microservices, client projects and open-source work all mean many repos side by side.
When an AI coding agent needs to run a command in all of them, it usually writes this:
for d in */; do (cd "$d" && npm test); done
This works. But it is serial: one repo, then the next, then the next. If each test suite takes 1 second, 54 repos take about 54 seconds. Most of that time, your CPU is idle.
Running repos in parallel (several at the same time) is the fix. Bash can do it with & and wait, or with xargs -P. But agents almost never do it on their own. In 172 plain bash runs across this study, Claude Code ran folders in parallel only twice. Both times it was git fetch. It never ran tests in parallel.
What indo is
indo is a small command-line tool. It is one bash script with no dependencies. It runs one command in many folders:
indo -f -P 8 */ 'npm test'
*/means every folder here.-P 8runs 8 folders at the same time.-fshows only the folders where the command failed, plus a count.
The last part matters for agents. An agent reads every line of output, and it pays for every line in tokens (the units that AI models count and bill). Short output keeps the cost down.
indo used to be called in-cli. I wrote about the first version here. The command is indo because in is a reserved word in bash.
The Agent Skill
An agent does not know indo exists. You have to tell it. I tried two ways:
- A note in the system prompt. This is text the agent sees in every conversation. It worked, but it cost 6% to 30% more per run, because the agent reads the note every time.
- An Agent Skill. A skill is one small file,
SKILL.md. The agent sees only its short description. It reads the full file only when a task needs it. Claude Code, Cursor and Codex all support skills.
The skill won. I wrote 6 versions of it. I tested the final one on new tasks that I did not use while writing it. The final version tells the agent when to use indo and which command to run.
How I tested it
I wanted a fair test with real code, not a toy.
- Agent: Claude Code 2.1.325 with Sonnet 5.5, in headless mode (no human in the loop).
- Workspace: 54 real open-source repos, pinned to fixed commits. 18 JavaScript, 16 Go, 18 Python, and 3 without tests. Each repo had a small
ci.shscript that runs its test suite. Running all of them one by one takes about 45 seconds. - Known problems: 11 repos had failing tests (8 real failures, 3 that I added). 6 were behind their remote (they needed a
git pull). 6 had uncommitted changes. - Two setups: plain bash, and indo with the skill. Everything else was the same.
- 8 tasks, such as "run all tests and list the repos that fail" or "which repos are behind?".
- 3 paired runs per task. Each pair ran both setups on the same task, back to back, in random order. Only one run at a time, so the two setups never fought for the CPU.
- Grading by script. Each answer was checked against the known correct list. No human judgment.
This was round 3. Rounds 1 and 2 used 20 repos and tested the prompt note and the skill versions. In total: 402 graded runs. The full method, scripts and raw numbers are in the repo under bench/agent-eval.
The results
Correctness: both setups got 24 out of 24 tasks right.
Speed: the full test run went from 53.0 s to 16.1 s (median of 3 runs). That is 3.3x faster.
Across the 6 slow tasks, the ones that run test suites, indo was 1.8x faster. The 95% confidence interval is 1.4x to 2.3x. In plain words: with this little data, the real speedup is very likely somewhere between 1.4x and 2.3x.
Cost: about the same. With indo, a run cost 1.02x as much as plain bash (95% interval 0.95x to 1.07x). A run cost about 0.02 USD either way.
What did not get faster
indo is not magic. It only saves time when each command takes time.
- Quick commands gain nothing.
git statusin 54 repos finishes in a few seconds either way. With indo it was a little slower (0.8x). The agent spends more time thinking than waiting. - Few repos, little gain. "Pull 6 repos, then test them" touched only 6 repos. 1.1x.
- Go tests were already fast. Go caches test results, so the Go task took about 7 seconds even with a plain loop. 1.2x.
- A smaller model did not use it well. On Haiku 5.5, the skill gave no speedup (0.98x). The agent used indo in only 8 of 18 runs.
One more honest note. One plain bash run stalled for 355 seconds on a command that took 7 seconds in the other runs. I left it out of the headline numbers. With it included, the slow-task speedup is 2.25x instead of 1.8x. I report the smaller number.
How to set it up
Install indo and the skill for Claude Code in one line:
curl -sL https://raw.githubusercontent.com/inevolin/indo-cli/main/install.sh | bash -s -- --with-skill
This puts the skill in ~/.claude/skills/indo/. Cursor reads that folder too. For Codex, install the skill to ~/.agents/skills instead:
curl -sL https://raw.githubusercontent.com/inevolin/indo-cli/main/install.sh | SKILL_DIR=~/.agents/skills bash -s -- --with-skill
Using another agent? Add these 3 lines to its AGENTS.md file:
indo is installed. To run a command in 2 or more folders, use it instead of a for loop.
Slow commands (tests, builds, git fetch or pull): indo -f -P 8 */ 'CMD'
Status or search: indo -c */ 'git status -s' (add || true after grep)
The limits
This is a small study. Please read the numbers with that in mind.
- One agent. I tested Claude Code only. Cursor, Codex and Gemini CLI are not tested yet.
- Small samples. 3 paired runs per task. The confidence intervals are wide for that reason.
- One machine. An 8-core Linux box. More cores should help more. Fewer cores, less.
- Prepared repos. Each repo had a
ci.shscript, so the agent did not have to figure out how to run each test suite.
The takeaway
AI agents are good at writing code. They are not good at waiting. If your agent works across many repos, it probably runs your tests one at a time.
A 1-file skill and a small bash tool fixed that in my test: 3.3x faster on a full test run, with the same answers and the same cost.
indo is free and open source: github.com/inevolin/indo-cli.
