Tuple - a Developer’s Guide to Remote Collaboration

In this post, we’ll define pair programming, explore its benefits, provide tips for getting started, and discuss the challenges of pairing remotely. Finally, we’ll show how Tuple makes remote pairing not just possible, but a joy for tens of thousands of developers.

What is Pair Programming?

Pair programming means different things to different people, but it always boils down to two developers working together on the same code. The two most common pairing techniques are Driver/Navigator and Ping Pong.

Driver/Navigator: The driver types the code and stays focused on the current task, while the navigator thinks ahead, ponders edge cases, spots bugs, suggests refactorings, asks good questions, and stays zoomed out.

Ping Pong: Great for test-driven development (TDD), the workflow loops as follows:

1. Person 1 writes a failing test.
2. Person 2 makes it pass.
3. Person 2 writes a failing test.
4. Person 1 makes it pass.

This approach naturally divides the work and keeps both developers engaged without the need to frequently swap drivers. Here, two keyboards are handy, or a remote pairing app like Tuple.

Pro Tips for Ping Pong Pairing:

1. Don’t stress about uneven typing time - it balances out as you switch roles.
2. Focus on writing minimal failing tests and the simplest code to pass them.
3. Always take time to refactor when all tests are passing.

These styles might sound formal, but we believe pair programming can be as casual as asking, “Hey Jess, you wrote this code - can you help me make these changes?” or “Hey Steve, I’m stuck on something. Can you take a look and help me think it through?” As long as two developers are working together on the same problem, that’s pairing.

The Case for Pair Programming

Is pair programming worth it? We think so. Pairing brings more brainpower to the table, which means catching bugs early, finding more creative solutions, and maintaining higher code quality. With someone watching, you’re less likely to cut corners or get distracted. This investment in better code pays off with a healthier codebase, making future development faster and smoother. Plus, when two people are deeply familiar with the code, you reduce the bus factor - the risk of losing critical knowledge if someone is unavailable.

Research backs this up: studies show that for a development-time increase of around 15%, pair programming improves design quality, reduces defects, lowers staffing risk, enhances technical skills, boosts team communication, and is more enjoyable. Another study found that paired teams completed tasks 40% faster than individuals.

As pairing gained popularity, variations emerged, including mob programming or ensemble programming. These terms are interchangeable, and like our definition of pairing, we like to keep it simple: mob or ensemble programming is when three or more developers work together on the same code.

In short, these practices can:

1. Make tough problems easier to solve.
2. Improve code quality and reduce bugs.
3. Spread knowledge across your team.
4. Increase developer satisfaction.

Tips for Getting Started

While the benefits of pair programming are well documented, getting started can be daunting. It’s a skill, and like any skill, it takes time to master. That’s why we created our Pair Programming Guide. Here are our three top tips to help ease the transition:

1. Pick a comfortable partner: Start with someone you already work well with. Pairing involves sharing work-in-progress, which can feel vulnerable. A familiar face helps ease the nerves.
2. Make it fun: Choose areas of the codebase you enjoy working on. Pairing should be enjoyable, especially at first when you’re still getting the hang of it.
3. Start small. Begin with short sessions - an hour or two max. Use a timer to break up that time together. "Hey I know we blocked 2 hours to work on this together. Mind if we set a 50m timer, take a 10m break, and then wrap up for the last hour?" It'll feel less exhausting with a built-in break, especially if you both know it’s coming.

The Remote Challenge

Pair programming originated in the days of in-person work, where it was easy to share a screen, switch roles, or sketch out ideas on a whiteboard. You could glance over to see if a colleague was free before asking for help. But as the software world shifted toward remote work, spontaneous, side-by-side collaboration became harder to replicate. Working from home introduced friction - suddenly, it wasn’t as easy to ask for help or collaborate in real-time.

Enter Tuple

Before COVID and the mass transition to remote work, Tuple’s founders left their cushy dev jobs to solve this very problem. They wanted to build a tool that could bring the magic of in-person pairing to the remote world. Existing tools like Zoom or Slack had screen sharing, but they weren’t designed for the specific needs of developers. Switching who was driving felt clunky. It was hard to point out specific lines of code in a crowded IDE, and sketching out designs or even just reading the code on a low-resolution, high-latency connection was a struggle. And unlike an office, you couldn’t just tap someone on the shoulder for a quick assist.

So, they built Tuple - a screen sharing and remote control app designed from the ground up for developers. Tuple makes you feel like you’re sitting right next to your pair, even when you’re miles apart. It has features you won’t find in generic screen sharing tools: seamless driver switching, shared control by default, built-in annotations for pointing things out, and even whiteboarding. Tuple prioritizes screen share quality over webcams, ensuring that tiny lines of code are crystal clear. Plus, Tuple is native on both macOS and Windows, using a cross-platform engine written in C++ to optimize performance and keep CPU usage low - perfect for compiling builds and running tests.

Picture this: you’re working on something tricky and need help. You hop on a call, pull up your IDE, and start talking through the problem with a pair. But with 50 lines of barely legible code on the screen, your pair is lost. A few frustrating seconds later, maybe 10, you’re finally on the same page, but the flow is gone.

Not with Tuple. With one click, you switch to annotation mode, circle what you’re talking about, and your pair digs in. They’ve got an idea - mind if I try something? With a single click, they take control, type it out, and you run the test. It passes. The flow is preserved, and a solution is found.

That’s what Tuple is about: making pairing easy, effective, and fun. It tackles the challenges of remote work and delivers an experience that feels as close to in-person collaboration as possible. Whether you’re into formal pair programming or just need to collaborate in real time, Tuple is the tool to make it happen.

Ready to see for yourself? Try Tuple free for two weeks - no credit card required.