The Cautious Team's Guide to Autonomous Delivery

There’s a weird duality in how teams are adopting coding agents right now. Some have leaned all the way in and moved to truly hands-off patterns, where the agent does the work and a human (occasionally) checks the result. Others have embraced the same tools but keep their engineers’ hands hovering over the wheel, eyes on the road, ready to take it back the second something looks wrong.

The second group tends to look at the first with a mix of envy and disbelief. They can see the end state, they just have a hard time seeing the path from where they are today. It’s often for good reasons, and completely understandable. Invisible complexity buried in codebases no single person fully understands. Compliance requirements or reputation risk that turns a bad change into a nightmare.

It’s a big leap going from a world where engineers drive everything, to one where code ships autonomously. But nobody sane onboards a person that way either. A new hire doesn’t get a production database migration in their first week. You start them on something small that can be undone, and then you give them more slack as you learn what they’re good at.

Autonomy should follow a similar trajectory—it’s more of a dial than a switch.

With several of TheGP’s portfolio companies, we’ve been layering autonomy one piece at a time.

The first layer doesn’t ship anything at all. When a bug report or feature request comes in, we have an agent enrich it. It has access to prod data and Sentry traces, and it does the root cause analysis a person would otherwise do by hand. The tedious part has been handed off and the blast radius is zero. A human operator picks up the issue, already jump-started. I’m notoriously bad at filing tickets, and I’ve even found myself filing tickets just to trigger the enrichment.

The next layer we add is a triaging step. Once the agent is good at that analysis, it can judge whether its own recommended fix is tightly scoped enough to open a PR right away. You can turn this dial as gently as you like. One-line changes. Changes that don’t touch the API surface. Wherever your own edge feels comfortable.

After that, it’s tuning. As the agent proves itself on one type of work, you widen its scope. When it gets something wrong, you don’t rip the whole thing out. You add a guardrail and keep going. The dial can also turn backward.

On the back end of a change, there’s a second dial. Once code starts being written automatically and reviewed automatically, you start to realize not everything needs a person to approve it. Again, you start small. Auto-approve one-line copy changes. Then the low-risk fixes that arrive with tests proving they work. The two ends move on their own: you can be bold about what the agent is allowed to attempt and cautious about what merges unseen, or the other way round.

For the teams worried about compliance and reputation, this is the part that should settle them rather than scare them. The dials are essentially a boundary you can audit. You can specify exactly what the agent is allowed to touch, point to the check that clears each kind of change, and widen that surface deliberately instead of all at once. And in practice many of the checks and gates are deterministic and predictable.

That predictability is imperative. What buys the next notch on a dial is a cheaper, surer check. A cleverer agent isn’t really more trustworthy. A contract test, a trace, a fixture that turns “I think this worked” into “I can see this worked” is.

This is also where the invisible complexity from the start turns into a to-do list. Old systems are hard because you often can’t tell what they’ll do at runtime by reading the code. And you can’t safely hand off work you can’t cheaply check. So a lot of earning autonomy in a legacy system is unglamorous: making what it does at runtime visible, one test and trace at a time, until a check is cheap enough to trust. In reality it’s actually quite boring work. But the outcome is pretty cool.

What tends to surprise cautious teams is that none of it looked like the leap they were bracing for. There’s no day you flip to autonomous delivery. There’s a Tuesday when you notice a whole class of change has been shipping without you for weeks, and nothing caught fire.

The teams that are hands-off today aren’t braver than the ones with their hands hovering over the wheel. They started turning a dial, watched what their checks could carry, and turned it again. The end state the second group envies is often the same company a few notches further along, on the kind of work they took the time to make cheap to check.

So you don’t need permission to get there. You need a first layer that ships nothing, and the patience to turn the dial only as fast as your checks will hold.