Delete Comments, Ban Unit Tests, Remove CI: A Paradigm Engineer's Six Principles for Swarms
Software engineering is becoming magic. Paradigm's Georgios Konstantopoulos shares six principles for riding AI swarms, from making bold demands to deleting comments, plus the open-source tool he is using, Nanocode.
Paradigm co-founder Georgios Konstantopoulos recently said on Twitter: 'Software engineering is becoming like magic.' This is not a metaphor; it is his judgment. He published a long post, 'Effective Swarm Riding for Engineers,' and released the full version on the Paradigm blog the same day.
Swarm refers to multiple AI agents working together, like a hive of worker bees. Previously this felt like doing it for its own sake, but a new generation of models (such as Opus 5.5) makes it practical. How do you ride a swarm? He gives six principles.
Be willing to make crazy demands
Train yourself to 'think more aggressively.' For example, rewriting Bun in Rust? At the time it looked crazy, but now it looks obvious. You can also rewrite the parts of your dependency stack that slow you down, or build your own database or write your own cryptography. He says Tempo has been rewritten in more than 5 different languages, just to explore the boundaries of efficiency and security. Why not?
Let agents work in the cloud 24/7
To run swarms at scale, your laptop cannot hold them. You need cloud infrastructure. You can use off-the-shelf products, or Nanocode, Pi Durable, Fx, or build your own devbox. He promises to publish a full setup guide later.
Say the right incantations
He does not believe in long prompts, but he believes in 'short and dense' prompts and encouraging models to do impossible things. Some words are like magic spells. Examples:
- Do not say 'optimize X'; say 'make this 10x faster.'
- Do not say 'fix all bugs'; say 'differential test this and close all gaps.'
- 'Rewrite this in ... using TigerStyle.'
- 'Find all implicit state machines in the code, encode all correct states into the type system, and eliminate bug classes at compile time.' (Original by Steve Ruiz)
- 'Find shared-state patterns and replace them with lock-free versions using the tokio actor pattern.'
- 'I am away for 8 hours; trust yourself.' (From Anthropic's research)
The principle behind these words is: compress higher-level abstractions and domain knowledge into a few words.
Keep it simple
Many people overcomplicate the setup. Do not build planning, orchestration, memory, compression, skills, cross-review. Use frontier models, give simple prompts in a well-set-up codebase, and then get out of the way. Every new model makes the previous round of customizations obsolete. Less is more.
Make the codebase ready for swarms
This set of advice is a bit counterintuitive:
- Delete comments. Comments waste tokens and mislead agents. You reading code is also an agent reading code.
- Delete all
.skillsanddocs/folders. They are distractions. - Delete unit tests written by agents, and ban them in AGENTS.md. Agents can now write code that does not need unit tests in one pass.
- Replace them with deterministic simulation testing (DST). This lets agents automatically find bugs and not repeat them.
- Rewrite dependencies, or use TigerStyle. Prevent supply-chain attacks.
- Merge everything into a monorepo and unify the codebase as soon as possible.
- (Controversial) Push directly to master and remove CI. Agent threads are the new PRs and CI. There will still be CI-like mechanisms, but they will not be GitHub Actions.
Try new ways of interacting
Today's AI apps all look the same: a thread sidebar on the left, chat in the middle, and a browser on the right. You can do better. He likes using Inbox to feed himself tasks, making one decision at a time, like Superhuman. When doing performance optimization, he wants a loss-curve-style UI. Creative workers can use an infinite canvas to explore in parallel.
On reward hacking
A user asked him: how do you prevent a swarm from reward hacking when unattended? He says he is still figuring it out. When facing known goals, he currently trusts that agents will get him to the right result. It is essentially metric definition. Everyone in ML is doing this.
Conclusion
He believes that software development a year from now will look more and more like machine learning: most engineers' work will be tuning how a swarm performs on metrics. The thing he spends the most time on is not the agents themselves, but optimizing the environment in which agents run. Spawning a swarm from a good environment is just an accelerator. What interests him most right now is automated program verification and testing.
He has implemented these principles in an open-source SDK: Nanocode. It supports code mode, persistence, does not require a per-session sandbox, and can be paid for with a ChatGPT or Claude subscription, an API key, or a Tempo wallet. It is suitable for running locally or in your own cloud environment. Install:
curl -fsSL https://nanocode.xyz/install | sh
The GitHub repository is at https://github.com/nanocodexyz/nanocode . He also said: please try Nanocode.
Finally, if you also want to ride a swarm, first ask yourself: is my codebase ready to be ridden by a swarm?
By the way, he recently listened to The Doors' Riders on the Storm. It might have some kind of echo with swarms.
发布时间: 2026-11-21 11:50