You're Not in the Loop Anymore. You're Running the Loops.

AI agents can do real engineering work now. That changes the question.

The question was never how fast one person can code. It's how a whole team gets everything done. Agents remove the typing bottleneck. What's left is coordination and judgment.

I started using herdr.dev on Monday. By Tuesday afternoon my team was talking about hundred-PR weeks. After thirty years of scaling SaaS, I have not seen leverage like it.

The loop

An agent doesn't do one thing and stop. It runs a cycle. Plan, act, check, correct, repeat. Write the failing test, make it pass, run the suite, fix what broke. That cycle is why an agent finishes work instead of handing back a first draft.

For a while, you sat inside that loop. The agent acted, then waited for you. You were the bottleneck.

The orchestrator pattern is what happens when you climb out and stand above it.

What I'm watching

Right now, a dozen agents are working at once. One is clearing failing end-to-end tests. One is driving a PR to green. One is picking apart a review plan before I see it.

I'm not inside any of those loops. I'm watching a board.

herdr is what makes that possible. It looks like a dashboard. It's more than that. It's a layer that sits between the agents and lets them pass work back and forth.

It's not one vendor's multi-agent mode

This is the part that matters most.

Some coding agents now ship their own multi-agent features. The tool spins up copies of itself and coordinates them. Useful, but locked in. You're orchestrating one company's agent talking to more of the same company's agent.

herdr orchestrates across agents. Claude Code, Codex, Pi, whatever comes next, all on the same board, under the same rules. You stop picking one assistant to bet on. You route each task to the agent that fits and let herdr keep them moving together.

The leverage isn't a smarter agent. It's a mixed crew, conducted by one person, with no lock-in.

The other half: compound engineering

Agents are only as good as the standards they run on. Ours are written down.

Everything runs on Every's compound engineering. The whole lifecycle is documented: plan, test, review, ship. And every solved problem gets captured, so the next run reads it instead of rediscovering it.

That's the compounding part. Each pass leaves the codebase and the process a little sharper.

The night it ran without me

We had dependency upgrades stuck for weeks. Not easy bumps. The kind that need judgment: a breaking change buried in a changelog, a peer version that has to move in lockstep, a lockfile that fights back.

I pointed the orchestrator at them and went to bed.

The harness held. A crew of agents worked the branches, ran the tests, fixed themselves, moved through the labels, and merged when green. Nobody was awake. I woke up to shipped work.

An agent writing code stopped being remarkable a while ago. A crew running the full lifecycle to merged, unattended, is the real line.

This is not vibe coding

It would be easy to call this magic, or a shortcut around real engineering. It's neither.

Look at the repo. Compounding knowledge. Unit tests. Cypress end-to-end scenarios that drive the real app the way a user would. Pre-push hooks, cost gates, harnesses that refuse broken work.

The tests still pass. The review still happens. The PR is still green before it merges. The only thing that changed is how many disciplined loops run at once, and how little of my day each one costs.

This is professional engineering, every guard rail intact, at a scale you could not staff.

Run it yourself

I packaged the orchestration skill as a plugin. It ships the skill and the scripts, sanitized, following Every's conventions, installable in any coding agent that supports them.

github.com/kevinold/multi-worker-pm-skill

/plugin marketplace add kevinold/multi-worker-pm-skill
/plugin install multi-worker-pm

It leans on Every's compound engineering plugin for the worker loop, where /ce-worktree and /lfg come from.

What this changes

If you still measure these tools by autocomplete speed, you're watching the wrong number.

Here's the number that matters. Can the practices you already stand behind, the testing and the review and the knowledge capture and the gates on every merge, run across every stream of work at once, without a person carrying each one by hand? That's a leadership question, not a typing-speed one.

You're not in the loop anymore. You're running the loops.

The answer to how a team gets it all done is both halves, together. herdr.dev for the orchestration. Every's compound engineering for the discipline that makes it worth running.