Our engineers now pair with an agent all day and with each other much less. That's mostly fine. But the mistakes each kind of partner catches turned out to be very different and we only noticed what we'd lost when it reached production.
Over the past year, human pair programming at Silkate quietly dropped off. Nobody decided it. It just stopped being the default once every engineer had a partner that was always available, never tired and could type faster than both people combined.
For a while we counted this as a pure win. Then we had a run of issues that all looked alike in hindsight: changes that were clean, well tested and internally consistent and that were wrong for reasons nobody in the session could have spotted - because the only other participant in the session was the agent.
So we went back and looked at what kinds of mistakes each partner actually catches. The answer isn't that one is better. They catch different classes of problem and the overlap is smaller than we assumed.
An agent is an excellent partner for anything that's visible in the code in front of it.
A human partner catches things that aren't in the code at all.
The difference that surprised us most wasn't about knowledge. It's about disagreement.
A good human pair pushes back. They have their own idea of how this should go and they'll argue for it. That friction is where a lot of the value comes from - you have to explain your reasoning and sometimes in explaining it you notice it's wrong.
Agents mostly don't push back. They follow your framing. If you say "let's add a cache here", you get a well-built cache. You don't get "are you sure the slowness is here? The trace suggests it's the query upstream." Agents can raise that kind of point, but they're much more likely to work inside the assumptions you hand them than to challenge them.
The result is that pairing with an agent feels very productive and can be quite lonely in the specific way that matters: nobody else in the session holds a different view of the problem.
catches well
┌──────────────────────────┐
agent │ local bugs, edge cases, │
│ API misuse, consistency, │
│ missing tests │
└────────────┬─────────────┘
│ overlap: smaller
│ than you'd think
┌────────────┴─────────────┐
human │ wrong problem, blast │
│ radius, history, org │
│ context, proportion │
└──────────────────────────┘
We didn't bring back pairing as a blanket rule. That would throw away a real productivity gain. Instead we got specific about when a second human is worth the cost.
We still pair with humans for:
We changed how we pair with agents:
And for important work, we sometimes pair three ways: two engineers and an agent. The humans argue about the approach and the agent does the typing. It sounds wasteful. For a gnarly migration or a risky refactor it's one of the most effective setups we've found, because you get human friction on the decisions and agent speed on the execution.
An agent is a better pair than a human for most of what's in the code: local bugs, edge cases, consistency and tests. A human is still much better for what's outside it: whether this is the right problem, what else it touches, what was tried before and when enough is enough. And unlike a good human partner, an agent rarely argues with you.
So the question isn't which partner to use. It's knowing which kind of mistake this piece of work is most likely to contain and making sure someone in the session can catch it.