Keep pairing with humans
Rule 21 was never only about the code. Agents took over the navigator's job, and the second salary now buys focus, honesty, shared knowledge and someone who makes you stop for lunch.
The hardest sell
When I was helping teams adopt agile and XP practices in the 2000s, most were easy to explain. Standups keep everyone in step and often kick off the day. Showcases put working software in front of the people paying for it. Retros give the team a regular place to fix how the process is working. TDD means you drive out behaviour as a client of your code. You could make the case for any of these in a sentence and most people nodded.
Pair programming was different. However you described it, a manager heard two people doing one person's job. The benefits were real, but they were spread across quality, knowledge, focus and morale, none of which show up on a timesheet. The cost was right there on the payroll. Rule 21 is blunt about it: it never took off outside a few shops because it cost two salaries for one keyboard.
The teams most receptive to pair programming were the ones with a disastrous history of delivery, who wanted every tool we had to give them the deluxe agile experience. Teams who were only interested in cherry picking a few practices rarely accepted pairing as an option.
Everyone pairs now, whether they know it or not
Coding agents settled that argument without anyone winning it. Everyone using Claude Code, Codex or something like it is pairing all day. Usually it isn't limited to a pair. One person drives several agents at once, each in its own workspace and each on a different problem.
Rule 21 calls this pairing, and some of it is. But when you take the old practice apart, you find it was doing several jobs at once, and an agent can only take over some of them.
What pairing was for
| What pairing was for | Can an agent do it? |
|---|---|
| Typing, looking things up, remembering APIs | Yes, better than us |
| A second opinion on design | Mostly |
| Catching mistakes as they're made | Mostly |
| Keeping each other honest | Not really |
| Spreading knowledge through the team | No |
| Growing less experienced people | No |
| Keeping each other focused | No |
| Looking out for each other | No |
| Taking breaks | No |
| Company | No |
The top of that table is the part everyone remembers: the navigator spots the off-by-one, suggests a better name, knows the API you've forgotten. Agents are good at all of that, often better than a human navigator.
The rest of the table is where the value was hiding.
- Keeping each other honest. A good pair wouldn't let you skip the test, merge without reading the diff, or call it done when it wasn't. An agent will do whatever you ask, and will tell you it's a great idea while it does. It can review its own work, but it can't hold you to a standard you've decided to drop at 6pm on a Friday.
- Spreading knowledge. Pairing, and rotating pairs, was how a codebase ended up in more than one head. Collective ownership depended on it. An agent forgets everything at the end of the session. The Contract and the knowledge graph help, but a team still needs people who understand the system well enough to know when the agent is wrong.
- Growing people. Juniors learned by sitting next to seniors and watching how they think. Seniors learned a lot from explaining things. An agent can answer a junior's questions, but it won't notice the questions they aren't asking.
- Focus. It's hard to drift off to email or Slack when someone is waiting for you. Nobody waits like that for an agent, and every agent that finishes is another tab asking for your attention.
- Breaks and company. More on these below, because they're the part I care most about.
The legion that never gets tired
Agents never need to eat, go to the toilet, talk to their partner, pick up their kids or feed the cat. They are always ready for the next prompt.
On your own with several of them, it's very easy to get into a rhythm where you never stop. There's always one agent that has just finished and wants a decision, and always one more thing you could kick off before lunch, then before dinner, then before bed. Each prompt is small, so it never feels like you're overworking. The day doesn't have natural stopping points anymore, and nobody notices when you skip lunch.
I think this is unsustainable in a way the industry hasn't really reckoned with yet. A lot of us have spent the last year working alone with a team that never gets tired, and calling it productivity.
We do practice pairing at Fresho and so have been experimenting with a slightly new version of pairing. When someone is sick, I really notice it as I work for a few more hours - "just this one more thing". The only reason my partner isn't annoyed by it is because that's exactly what she's doing too.
Human pairing is more important than ever
So I'd like to propose that pairing with another person matters more now than it did in 2000, though it looks different.
At Fresho we're fully remote, so we pair over Tuple. Each of us runs several agents in parallel, each one in its own workspace on its own problem, and we move between our own machine and our pair's screen as the work demands. It's less like one driver and one navigator and more like two air traffic controllers sharing a tower.
What we get from it:
- Company. You spend the day with someone you can talk to, which matters more than it sounds when the rest of your team is made of agents.
- Breaks. One of you wants a tea, a coffee or a stretch, so you both stop. Some of the best ideas come from the tangential chat while the kettle boils.
- Focus. Someone is watching you work. It's much harder to wander off into your inbox, and much easier to notice when an agent has been spinning on the wrong thing for twenty minutes.
- Honesty. With several workspaces going and constant switching between them, it's easy to lose track of what you actually checked. A second person asks "did you read that diff?" and "does this actually work?", and expects an answer.
- Shared understanding. Two people now know what changed and why, which keeps working when the session ends and the agents forget.
- A finishing time. When your pair logs off, you log off. That alone has probably done more for us than any process change this year.
A proposed revision of rule 21
- 1999: All production code is pair programmed.
- 2026: All production code is pair programmed, with an agent.
- Proposed: Pair with a human, and bring your agents.
Rule 21 says pairing used to cost two salaries for one keyboard. That isn't the trade anymore. Two people now run a small fleet of agents together, and the second salary buys what the agents can't provide: focus, honesty, shared knowledge, and someone who makes you stop for lunch.