Remote pair programming sounds exhausting to a lot of people at first: two people, one shared screen, eight hours on a video call. If that is what it looks like, it really is exhausting. Set up well, though, programming together across a distance is one of the best remedies for knowledge silos, long review loops and the feeling of sitting alone in your home office with a problem nobody else sees.
I care about this topic both as a developer and as a team lead. As a developer, because I like puzzling over a tricky problem with someone else. As a team lead, because pairing tends to be either mandated from above or quietly forgotten, and neither works well. In this guide you get the roles, the tools, a format for your first session and the usual pitfalls. We will also look at when ensemble programming with the whole team pays off.
In short
Pairing remotely works when roles are clear, you switch regularly and breaks are planned in. The key insight: setting up the tools takes minutes, while the rhythm of timer, role switch and break decides whether it succeeds. The biggest pitfall is a navigator who only watches.
What you will learn in this article
- Which pairing styles exist and what each one is good for
- How to set up a remote session, technically and organisationally
- How Git handovers work smoothly with the mob tool
- How often roles and pairs should rotate
- What team leads can do so pairing does not feel imposed
What is remote pair programming?
In pair programming, two people work on the same task and the same code at the same time. One person types, the other thinks along, checks and keeps the goal in view. With remote pair programming you simply are not sitting next to each other; you connect through screen sharing, a shared editor and audio instead. The principle stays the same, but the sources of friction change.
At a shared desk you notice right away when your partner drifts off or gets tired. On a call that signal is almost entirely missing. That is why remote pair programming needs a bit more structure: fixed roles, a visible timer and agreed breaks. It sounds like bureaucracy, yet after two or three sessions it feels completely natural.
One distinction up front: pairing is not a real-time code review. In a review, someone looks at finished code after the fact. When you pair, the code is written together, decisions are discussed on the spot, and the knowledge ends up in two heads instead of one.
Which roles and styles are there in pairing?
There is no single correct style for pair programming, remote or not. Which one fits depends on whether you want to pass on knowledge, build a new feature test-first or hunt down a bug.
Driver and navigator
This is the classic. The driver has the keyboard and handles the next concrete step: the line, the function, the test. The navigator thinks one level higher, paying attention to names, edge cases and whether you are still heading in the right direction. After a fixed time you swap roles. This style fits almost every situation and is a good starting point for remote pair programming.
Ping-pong with tests
In ping-pong, one person writes a failing test, the other makes it pass and then writes the next failing test. In between, you tidy up together. Role switches happen on their own this way, and nobody can hide behind the keyboard. For test-driven development (TDD, meaning test first, then code) this is my favourite.
Strong-style for knowledge transfer
Llewellyn Falco coined a memorable rule for this: “For an idea to go from your head into the computer it MUST go through someone else's hands.” Whoever has the idea does not type it but explains it. That is ideal when an experienced developer walks a new colleague through a codebase. The newcomer has the keyboard, the experienced person navigates. As a result, knowledge has to be put into words instead of vanishing in quick keyboard shortcuts.
Keep in mind that strong-style is a transitional phase. Once the new person gains confidence, you switch back to driver and navigator on equal terms.
Three pairing styles and ensemble programming at a glance – each with a typical rotation rhythm.
Ensemble programming: the whole team on one piece of code
Ensemble programming, often called mob programming in the past, extends the idea to three or more people. One person types while the rest discuss and set the direction. Here too, whoever types implements what the group decides and does not go off coding on their own.
The authors of the INNOQ site “Remote Mob Programming” recommend that distributed teams rotate the typist roughly every ten minutes. In their experience, shorter intervals cost too much handover time when working remotely. They also consider three people the minimum and three to four the sweet spot, because speaking time per person shrinks in larger groups.
When is it worth it? For example, for an architecture decision that affects everyone, when getting to know an unfamiliar system, or when a bug is so tangled that everyone would chime in anyway. For routine work, on the other hand, a full ensemble is usually too expensive.
Setting up remote pair programming step by step
Prerequisites: two people with access to the same Git repository, a headset, a stable internet connection and a task you can sensibly tackle in one to three hours. That is all you need to get started.
Step 1: Choose a tool for the shared code
You essentially have three options. The simplest is screen sharing with remote control, which many video conferencing tools offer. You then work on one machine, and the other person can take over mouse and keyboard when needed. The second option is a shared editor such as Visual Studio Live Share: everyone keeps their own environment, keybindings and cursor. Note, however, that Microsoft now lists Live Share as being in maintenance mode, with no new features planned. The third option, for terminal fans, is a shared tmux session over SSH, which also copes well with a weak connection.
My advice for your first weeks of remote pair programming: use what you already have. A new tool plus a new way of working is too much at once.
Step 2: Camera on, good audio
It sounds trivial, but it makes a big difference. With the camera on, you can see whether your partner is thinking or confused. A decent headset saves you from constantly asking each other to repeat things. Mute chat and email notifications for the duration of the session.
Step 3: Set up Git handovers with mob
If you take turns working on your own machines, the code has to change hands with every role switch. Doing that by hand is tedious. The open source command-line tool mob does the work for you: it creates a temporary WIP branch (WIP stands for “work in progress”, meaning unfinished intermediate states), pushes an intermediate commit there on every switch and squashes everything at the end. As a result, your main branch stays clean.
# Installation (macOS, Linux or Git Bash on Windows)
curl -sL install.mob.sh | sh
# Person A starts the session with a 10-minute timer
mob start 10
# When the timer runs out: hand over the current state
mob next
# Person B takes over on their machine
mob start 10
# At the end: bring all intermediate states into the staging area of the base branch
mob done
git commit -m "Add rental extension for bike rental"
Expected result: after mob done, all changes are staged on your base branch and you write a single, meaningful commit. A typical mistake is forgetting mob next. The next person then misses the latest changes. So get into the habit of announcing the switch out loud.
Step 4: Agree on timers and breaks
Pair programming is even more intense remotely than working alone. In their article on martinfowler.com, Birgitta Böckeler and Nina Siessegger recommend working in Pomodoro blocks: about 25 focused minutes, then a five to ten minute break, and a longer one after three or four blocks. They also consider around six hours of pairing a day to be the maximum and eight hours unsustainable. Use the short breaks to actually switch off, not for a quick email check.
Step 5: The first five minutes
Before the first line of code, briefly clarify three things. First, the goal: what should be done or clearer by the end of the session? Second, the roles: who starts as driver, and how often do you switch? Third, the constraints: when is the next break, and who has a meeting at 11 a.m.? These five minutes spare you a lot of misunderstandings later.
Step 6: A short look back at the end
Finally, take five minutes for a mini retrospective. Three questions are enough: What worked well? Where did we slow each other down? What will we try differently next time? This way you improve your collaboration from session to session without scheduling a big retrospective.
How often should you rotate roles and pairs?
It helps to distinguish two kinds of rotation. Switching roles within a pair happens every few minutes. Changing who pairs with whom, by contrast, happens over days. Each serves a different purpose.
| Rotation | Typical rhythm | Purpose |
|---|---|---|
| Driver ↔ navigator | every 10–25 minutes or with every test (ping-pong) | Both stay alert and involved |
| Typist in an ensemble | roughly every 10 minutes | Everyone gets to the keyboard, handovers stay cheap |
| Pair composition | after a few days or when a topic is finished | Spread knowledge, avoid fixed “islands of two” |
Starting values – adjust them after your first retrospectives.
When it comes to changing pairs, restraint pays off. Every change costs ramp-up time, and newcomers in particular benefit from staying on a task longer. So rotate with a clear reason, for example when a topic is finished or when knowledge about a particular module so far sits with only one person. How to find such knowledge silos in the first place is something I described in Increasing your team's bus factor.
Common mistakes when pairing remotely
Most problems have little to do with technology. They arise because expectations are never spoken out loud.
The navigator just watches
In remote pair programming this happens especially easily: camera off, a chat window open on the side, and the pairing session turns into a demo. Short role switches, ping-pong and an agreement to keep cameras on all help. It also helps when the navigator thinks out loud instead of just waiting for mistakes.
Pairing all day long
If you declare pairing the default for everything, you will soon have exhausted people. Deliberately plan time for solo work, for research, email or simply thinking. One pairing block in the morning and one in the afternoon is a good measure for many teams.
Hierarchy on the call
When a team lead pairs with a junior developer, the more senior person often decides without anyone saying so. Then nobody learns anything. I think it is important to address this openly: in the session, the better argument counts, not the position on the org chart. At the same time, it takes courage to say “I don't understand this right now.” That vulnerability is part of pairing and should never be held against anyone.
Meetings wreck the session
If both people have different appointments, only fragments of the day remain. Block shared pairing time in your calendars, ideally on fixed days. If a meeting cannot be moved, the other person keeps working alone in the meantime and gives a short recap afterwards.
Pairing on assembly-line tasks
Not every task needs two brains. Bumping a dependency or fixing a typo in the docs is faster for one person alone. If you notice, however, that you keep writing the same boring code over and over, that may well point to a design problem – and then thinking it through together is worth it again.
What team leads can do
You cannot order pair programming, remotely or otherwise, but you can make it easy. The most important lever is to start it as an experiment rather than as a new rule. For example, agree as a team on four weeks in which every larger task is paired at least partly, and then review together: What did it bring, and what was annoying?
It also helps to talk honestly about the fear of “half the productivity”. Two people on one task look expensive on paper. In return, long review rounds, follow-up questions and bugs that only show up in production often disappear. Whether it pays off for you is something the experiment will show better than any debate.
In concrete terms, there are three things you can do as a team lead: protect calendar time so pairing blocks are not eaten up by meetings; never use pairing as a control instrument; and join in yourself if you still write code. By the way, a team that already juggles too many tasks in parallel will hardly find time to pair. In that case, WIP limits are often the better first step.
My take
I think remote pair programming is underrated. Distributed teams in particular often lack the moment of glancing over someone's shoulder. A regular pairing session brings exactly that exchange back, and in a more structured way than a chance conversation at the coffee machine.
Where I disagree, though, is with the stance of “pair always and on everything”. People differ. Some draw energy from working together, others need a quiet hour afterwards. A good team finds a rhythm that allows for both. AI assistants in the editor change little here: they suggest code, but they do not replace the conversation about why you build something the way you do.
FAQ
Which tool is best for remote pair programming?
To get started, screen sharing with remote control from your video conferencing tool is enough. If you prefer to stay in your own environment, use a shared editor such as Visual Studio Live Share, or tmux over SSH. For Git handovers between machines, the mob tool helps.
How often should driver and navigator switch?
A good starting value is every 10 to 25 minutes or with every new test. More important than the exact number is that you actually switch and adjust the rhythm after a few sessions.
What is the difference between mob programming and ensemble programming?
In substance, none. Both terms mean that three or more people work together on one piece of code. Parts of the community prefer “ensemble” because the word sounds friendlier.
Does pair programming halve productivity?
On paper, two people work on one task. In practice, though, review loops, follow-up questions and later bug fixes often disappear, and knowledge spreads across the team. A time-boxed experiment is the best way to find out whether it pays off for you.
How an AI assistant fits into these roles, and when it gets in the pair’s way, is the topic of my article on pair programming with AI.
Your next step
Pick a task for the coming week that is already giving you a bit of a headache, and ask a colleague for two hours of pairing. Use driver and navigator, a 15-minute timer and the five-minute look back at the end. That is enough to get a feel for whether it suits you.
Now I am curious: does your team pair remotely, and if so, what made the difference for you – the tool or the agreements?
Sources
- Birgitta Böckeler, Nina Siessegger: On Pair Programming (martinfowler.com, 2020)
- Llewellyn Falco: Llewellyn’s strong-style pairing (2014)
- Simon Harrer, Jochen Christ, Martin Huber: Remote Mob Programming
- mob.sh: a tool for fast Git handover in pair and mob programming
- Microsoft Learn: Visual Studio Live Share
This post was created with AI assistance.
👉 Next step: More for team leads: my cheat sheets put the essentials on one printable page.
📬 Stay updated: New articles on serverless, AI and leading tech teams via RSS, browser push or the weekly newsletter (in German).
Originally published on sascha-ms.de. More articles on serverless, AI in everyday development and leading tech teams: sascha-ms.de/en

Top comments (0)