Insights
Developer Productivity Oct 2026

Pair Programming With an Agent vs With a Human: What Each Catches

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.

The Problem

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.

What an Agent Catches

An agent is an excellent partner for anything that's visible in the code in front of it.

  • Local correctness. Off-by-one errors, missing null checks, the unhandled branch in a switch, the error that's caught and silently swallowed.
  • Edge cases within a function. Empty lists, unicode in names, time zones, very large inputs. Ask an agent what could break this function and the list is usually longer and better than a human's.
  • API and library misuse. The deprecated method, the option that doesn't do what its name suggests, the async call that isn't awaited.
  • Consistency. This file handles errors differently from the five next to it. This test doesn't follow the pattern the others use.
  • Missing tests. It notices the case you didn't cover and writes the test in the time it would take you to write the note.
  • Stamina. It's as careful at 6pm as it was at 9am, which no human partner is.

What a Human Catches

A human partner catches things that aren't in the code at all.

  • The wrong problem. "Wait - why are we building this? Didn't finance say they only need it monthly?" An agent works on the problem as you framed it. A human questions the frame.
  • Effects beyond the diff. "That table is read by the reporting job overnight. If you change the column type, that breaks." The information isn't in the files the agent was given and often isn't written down anywhere.
  • History. "We tried exactly this in 2023 and rolled it back because of the batch import." Institutional memory lives in people.
  • Organisational context. Which team owns that service, who has to approve a schema change, which client is sensitive about which behaviour.
  • Taste and proportion. "This is a lot of abstraction for something we'll call twice." Agents tend to produce complete, general solutions. Humans are better at saying "that's enough".
  • When to stop. A human partner gets bored of a rabbit hole and says so. An agent will happily keep exploring it with you.

The Agreement Problem

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      │
                 └──────────────────────────┘

What We Changed

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:

  • Design decisions that are hard to reverse: schema changes, public API shapes, anything touching auth or money.
  • Incidents. Two people debugging production catch each other's wrong assumptions far faster than one person and an agent.
  • Onboarding to an unfamiliar system, in either direction. It's the fastest way to transfer the history that isn't written down.
  • The first change in a new domain, where the risk is misunderstanding the problem, not writing the code.

We changed how we pair with agents:

  • Ask it to argue against you. Before accepting an approach, we ask the agent to make the strongest case for a different one. This partly fixes the agreement problem. It's not as good as a human who actually disagrees, but it's a lot better than nothing.
  • Review in a fresh session. The agent that helped write the code is anchored on the same framing you are. A new session given only the diff and the spec finds different things.
  • Give it the wider context on purpose. Many "beyond the diff" mistakes come from the agent never seeing the consumers of the code it's changing. Pointing it at the callers and downstream jobs is cheap context engineering that catches a lot.

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.

Takeaway

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.