Effective Swarm Riding for Engineers

Swarms are transforming software development, enabling swarm riders to brute force through incredible software problems in hyperspeed, whether that is a research breakthrough or a performant and secure rewrite of a codebase. Swarms only became practical with models like Opus 5.5. Before, spawning subagents felt like doing it for the sake of it. But how do you make use of swarms?

Be unreasonably ambitious. Training yourself to think more ambitiously is what lets you access swarms as a superpower. The Bun in Rust rewrite seemed crazy at the time, but now it seems obvious. You should rewrite any part of your dependency stack that is slowing you down or concerns your security. You can just build your own database that’s tailored to your workload now. You can roll your own cryptography. You can just produce 1000x more efficient software. We’ve rebuilt Tempo in >5 different languages in search of new efficiency and safety frontiers in days. Why not?

Use Cloud Agents. Super obvious but no matter what you do, you’ll need to run infrastructure on the cloud. It can be one of the well-known products, it can be with Nanocode, Pi Durable, Fx, or you can do a bootleg setup with a devbox. I personally recommend self-hosting and building your own bespoke solution because if you’re doing something very ambitious it’s likely that you’re either going to get fleeced by the service providers trying to make margin, or you are going to end up with underprovisioned machines. If you build your own, you select what infrastructure your agents have access to, and you can make it really fast and for cheap.

Say the right words. There seem to be some magic words that make models do the job better:

  • Hillclimbing:

    • Do not say “Optimize X”. Say “Measure and redesign for optimal IO, Mem and CPU utilization based on all our historical data”.

    • Do not say “Fix all bugs”, say “Differentially test this with <reference> and close all gaps”.

    • “Using TigerStyle reimplement <target> in <language of choice>”. Examples: Tatami (tiling window manager) and Goempo (Tempo node in Go).

  • Superpowered-Find And Replace prompts:

    • “find all implicit state machines in my code, encode all correct states in the typesystem, and eliminate bug categories at compile time” [original]

    • “find shared state patterns in my code and replace them with lock-free alternatives using the tokio actor pattern”

    • “find all sequential async calls and replace with tokio::join “ [original]

    • “add otel observability and measure all my bottlenecks e2e by component”

  • “I am stepping away for 8hrs, believe in yourself”. [original]

These are some examples of things that work well for me. I think there’s general principles here around:

Do the simple thing. People tend to overcomplicate their setup.

  • Use frontier models, ideally with Cyber access.

  • Do not build plans, orchestration, memory, compaction, skills, or cross-review model outputs.

  • Do the simple prompt in a well-setup codebase, and then get out of the way.

Each new model cycle obliterates customization over the last cycle, so less is more.

I think self-hosting your swarms is important to maximize your ability to cut through bottlenecks, especially infrastructure around the agent. Consider steering your swarms via an email inbox-style UX, instead of babysitting various agents.

Make your codebase swarm-ready. Codebases will need to be rethought around removing friction for swarms:

  1. Comments waste tokens and they confuse agents. All the code you read is intermediated by agents anyway. Remove them.

  2. Delete all `.skills` and `docs/` folders. Again, distractions.

  3. Remove all unit tests written by agent now and ban them in your AGENTS.md. Agents are one-shotting code that doesn’t need unit tests.

  4. Introduce Deterministic Simulation Tests instead. This allows agents to automatically hunt for bugs and never repeat them.

  5. Rewrite your dependencies / use TigerStyle. This will save you from supply chain attacks.

  6. Monorepo everything, consolidate your codebases ASAP to avoid wasting everyone’s time.

  7. (Controversial) Push to master (hello merge queue) and remove CI. The agent thread is the new pull request & CI. This is currently debated in the engineering community. My take: A sufficiently swarm-pilled codebase is continuously tested, benchmarked, and ultimately released by the swarm itself. Of course you’ll still have something that looks like CI, but I am telling you this won’t be Github Actions or any neo-CI you see out there, it’ll be something that runs on the same infrastructure your agents run.

I basically think there’s a lot of glass to break. It will be an interesting time. I don’t know what the right thing is yet, but I am definitely thinking about:

  1. How much of my infrastructure / deps should I own?

  2. How can I manage the risk of doing so?

Experiment with new ways to interact. Every app these days looks the same: thread sidebar on the left, chat with composer in the middle, github or a browser on the right. You can do a lot better than that. I really like currently using an Inbox that feeds me with tasks and I need to take a decision at a time, instead of me jumping around threads. For performance work, I am working towards a loss curve-style UI. If you are a GTM person you may need to build something to help you with optimizing your pipeline. Just build something custom for you, but do not settle for the default. If you’re a creative, why not have an infinite canvas with parallel idea exploration?

Conclusion. I think software development is going to look more like machine learning a year from now, with most developers' jobs tuning swarms descend on the metrics they care about. We will need to unlearn a lot of habits & practices of the last years of software engineering.

I do very few special things with the agent itself, and spend most of my time optimizing the environment the agent operates in. Spawning a swarm from well setup environments is then just an accelerator, on a process that I was confident would converge to the right result.

Effective swarm riding to me ultimately reduces to code security, and so the area I am the most interested in right now is automated program verification and testing.

The frontier of the art of engineering is changing rapidly. If you are thinking about this, please reach out: georgios@paradigm.xyz.

Disclaimer: This post is for general information purposes only. It does not constitute investment advice or a recommendation or solicitation to buy or sell any investment and should not be used in the evaluation of the merits of making any investment decision. It should not be relied upon for accounting, legal or tax advice or investment recommendations. This post reflects the current opinions of the authors and is not made on behalf of Paradigm or its affiliates and does not necessarily reflect the opinions of Paradigm, its affiliates or individuals associated with Paradigm. The opinions reflected herein are subject to change without being updated.

en