Swarm riding is the habit of directing many AI coding agents at once and letting them grind through large engineering problems. Its advocates say it works for research breakthroughs and for fast, secure rewrites of whole codebases.
One practitioner has published a field guide with blunt advice. The pitch is that swarms only became practical with models like Opus 5.5. Before that, spawning subagents felt like doing it for the sake of it.
Aim higher than feels reasonable
The first rule is ambition. The author points to the Bun rewrite in Rust, which looked absurd when it was proposed and now looks obvious. Their advice is to rewrite any part of the dependency stack that slows you down or worries you on security grounds.
That includes building a database tailored to your workload, or rolling your own cryptography. The author says they’ve rebuilt Tempo in more than five languages in days, searching for better efficiency and safety.
Run your own cloud agents
Any serious swarm needs cloud infrastructure. The options range from well-known products to tools like Nanocode, Pi Durable and Fx, or a homemade setup on a devbox. The author recommends self-hosting. Hosted services take a margin or hand you underpowered machines, they argue, and a custom setup lets you decide what the agents can reach and keeps costs down.
They also suggest steering swarms through an inbox-style interface instead of watching individual agent threads.
Use the right words
Certain phrasings, the author says, make models do better work. Vague requests lose out to specific measurement targets:
- Instead of “optimize X,” ask the agent to measure and redesign for optimal IO, memory and CPU use based on all historical data.
- Instead of “fix all bugs,” ask it to differentially test against a reference and close every gap.
- Ask it to reimplement a target in a chosen language using TigerStyle. Examples include Tatami, a tiling window manager, and Goempo, a Tempo node in Go.
Find-and-replace prompts get the same treatment: locate every implicit state machine and encode the valid states in the type system, so a category of bugs disappears at compile time. Another swaps shared state for lock-free patterns using the tokio actor model, or replaces sequential async calls with tokio::join. One more adds OpenTelemetry and measures each component’s bottlenecks end to end.
The author’s favorite is a line to leave running overnight: “I am stepping away for 8hrs, believe in yourself.”
Keep swarm riding simple
The author’s general principles run against the trend toward elaborate setups. Use frontier models, ideally with cyber access. Skip plans, orchestration, memory, compaction, skills and cross-review between models. Give a plain prompt in a well-prepared codebase, then get out of the way. That is the whole approach to swarm riding.
The reasoning is that each new model generation wipes out the customization built for the last one, so less is more.
Make the codebase swarm-ready
The most provocative section lists changes to remove friction for agents:
- Delete code comments, since they waste tokens and confuse agents.
- Remove `.skills` and `docs/` folders as distractions.
- Delete agent-written unit tests and ban new ones in AGENTS.md.
- Use deterministic simulation tests so agents can hunt bugs and avoid repeating them.
- Rewrite dependencies and follow TigerStyle to reduce supply chain risk.
- Merge everything into a monorepo.
- Push to master behind a merge queue and drop CI, a step the author admits is controversial.
On that last point, the author argues that a codebase built around swarms is tested, benchmarked and released by the swarm itself, on the same infrastructure the agents use. It would resemble CI, but not GitHub Actions or any current alternative.
They concede open questions: how much infrastructure and how many dependencies to own, and how to manage the risk of owning them.
Build a better interface
Most agent apps look alike, with a thread sidebar, a chat box and a browser or GitHub pane. The author prefers an inbox that serves one decision at a time, and for performance work they are building a UI that shows a loss curve. Sales teams could build a view for pipeline tuning. The advice is to build something custom for your own job.
What happens next
Several of these ideas, like removing CI or deleting tests, will draw strong objections from other engineers, and the author says the question is still debated. Teams that try it will need to weigh the speed gains against the loss of conventional safety nets. What’s clear is that the playbook is shifting from supervising agents closely to setting ambitious goals and letting them run.
Source: Paradigm