$ cat choices/autonomy-with-guardrails.md
the call
I give people and agents the freedom to move without asking permission, bounded by rails (tests, CI, review, types) that make the speed safe. Autonomy is the speed; guardrails are the tracks.
Speed comes from people not waiting on permission. But unbounded speed is just a faster way to crash. So you build the rails (tests, CI, code review, types) and then you let people and agents run flat out inside them. The rails don’t slow the work down. They’re what make running flat out survivable. Ask forgiveness, not permission, because the guardrails already caught the mistakes that would’ve needed forgiving.
The two halves only work together. Hand someone autonomy before the rails exist and you get fast damage. That’s not trust, it’s negligence. Build the rails but keep approving every move yourself and you’ve just made an expensive bottleneck wearing a process costume. The discipline is investing in the tracks first, then actually letting go. If I’m still in the loop on every decision, the guardrails aren’t doing their job. Or I don’t trust them, which means they’re not done.
This is how I operate now, directing fleets of agents at The Bushido Collective. I’m not approving each step. I’m setting direction and trusting the rails to catch what goes sideways. This very site was built that way: agents moving without asking, bounded by tests, types, and review that make their speed safe. The train only moves as fast as the tracks it’s built on, so I build the tracks, then let the train run. Teach a man to fish: I don’t do the work for the agents any more than I’d do it for an engineer. I unblock and let them solve it.— see: writing / Volume Is Free Now
Trust scales; supervision doesn’t. The job isn’t to make every call. It’s to build the system where the right call is the easy one and the wrong call gets caught cheap. That’s true whether the thing on the other end is a senior engineer or a swarm of agents. You earn speed by investing in the foundation that makes speed safe, then getting out of the way. Move fast, build the tracks.
the gaps — what it costs even when it’s right
The rails are real work, up front. Tests, CI, review gates, types: none of that is free, and it all lands before you see the payoff. Skip it and “autonomy” is just a nicer word for chaos.
Letting go is harder than it sounds. The failure mode isn’t building bad rails. It’s building good ones and then still hovering. If you don’t actually trust the system, you’ve paid for guardrails and kept the bottleneck.
Guardrails can rot. A test suite everyone ignores, a review that’s a rubber stamp. Rails that look like rails but don’t catch anything are worse than none, because they buy false confidence. They need maintaining or the whole model quietly stops working.