Skip to content

Your Guide to the Ultimate Remote Pair Programming Tool

Writing code is hard. Figuring out how to fix your code when you're stuck can be even harder if you're working solo. 

That’s where pair programming comes in. Traditionally done in person, this collaborative approach involves engineers pairing up to write or debug code. 

The rise in remote work brought us a new approach: remote pair programming. 

But what happens when you hit a snag and your coding partner isn’t in the same room or time zone? Bridge the gap with a remote pair programming tool like Loom that complements the way you work. 

Loom makes it easier for developers to work together on code, even when they're working asynchronously. With Loom, developers can record their screen and webcam to capture their code and add crucial context when remotely pair programming.

Read on to learn how to choose the right remote pair programming tool and successfully incorporate it into your workflow.

What is remote pair programming?

Remote pair programming is a collaborative software development technique in which two developers work together on code, even if they are not in the same physical location. It’s similar to regular pair programming, except they don’t work on the same computer. 

Here’s how it works: Two developers connect virtually, sharing their screens and engaging in the coding process in tandem. This also allows them to review and improve the code continuously.

This method has gained popularity recently due to the rise of remote work and the need for more effective ways to collaborate across distributed teams.

Why remote pair programming is more prevalent than ever

Remote work is becoming a mainstay in the professional world. 

According to the Jamstack Community Survey 2022, 61% of respondents claimed to “strongly agree” when asked whether they like remote work or not. More than half even suggested they’d rather leave their jobs than work in person more often.

Remote work stats
Remote work statistics

The desire for flexibility is strong. 

It's safe to say remote work isn't going anywhere, which means remote pair programming is only bound to grow in popularity, and for good reason. 

Here are some of the key benefits of remote pair programming. 

Benefits of remote pair programming

  • Improved code quality: With two developers working together, code quality tends to be higher. They manage to catch errors earlier and follow best practices.

  • Faster problem-solving: Two heads are better than one when problem-solving. Developers can bounce ideas off each other and develop solutions more quickly.

  • Knowledge sharing: Remote pair programming is an excellent way for developers to learn from each other and share knowledge. Junior developers can benefit from the experience of more senior developers, while senior developers can gain fresh perspectives from junior developers.

All these benefits together lead to faster development cycles and better software.

Key features of the ultimate remote pair programming tool

Remote pair programming is well and good, but you need the right tools to make it work.

The ideal remote pair programming tool should enhance communication between developers, regardless of the location and time zone. At the same time, it should offer a range of features to make code sharing a breeze: 

Asynchronous communication

Remote work is fantastic. That said, different time zones can make real-time communication difficult, and constant back-and-forth disrupts everyone's workflow.  

Surely, there are ways to make remote pairing more convenient and shorten the feedback loop? Enter asynchronous video messaging.

Imagine being able to record a quick video explaining a complex code block, then adding comments and questions for your partner to review at their convenience. That’s async communication in action.

Loom Engineer Avanika provides code review using a quick Loom video

This setup creates a win-win scenario. You can collaborate with your fellow developer in real-time when needed while using async video communication for updates when live collaboration isn't possible or necessary.

Asynchronous communication also removes the pressure for an immediate response, allowing each developer more flexibility to finish their current task.

Screen-sharing to share code snippets 

Forget the days of endless screenshots, lengthy email threads, and text descriptions. 

Screen recording offers a simpler solution. You can document your code and walk your partner through complex bugs side-by-side, enhancing the overall remote collaboration experience. 

Loom’s annotation feature further helps you draw attention to specific sections, which brings us to our next point. 

Commenting and annotations for contextual knowledge sharing 

Recording a video and sharing your code isn’t always enough—you need contextual knowledge sharing when pair programming remotely. 

Look for code-sharing tools that let you leave comments at precise moments in the video and highlight key areas with annotations.

Loom drawing tool
How to use Loom's drawing tool while screen recording

The result? A transparent organizational culture, clearer communication, and ultimately, better code. 

Integration with task management and version control systems  

Integration with task management tools like Jira and Trello will allow you to link code changes to specific tasks or issues, making it easier to track progress.

At the same time, integration with version control systems like GitHub and GitLab will help you track and manage code changes. You can record and embed videos with the tools you use and collaborate on the same codebase without conflicts.

‍Yoann, Loom engineer, shows how the Loom Chrome Extension integration in GitHub works.

How to choose the right tool for your team

Now that you know what features to look out for, it’s time to select the right remote pair programming tool for your team. Here are some key factors to consider:

Team needs and preferences

Your remote pair programming tool should align with the specific needs and preferences of the team members who will use it. 

Consider their preferred communication styles, technical expertise, and comfort with new technologies. 

For example, if your team has engineers collaborating across different time zones, you might prefer an asynchronous video messaging platform like Loom. 

Scalability and cost

Selecting the right remote pair programming tool involves more than addressing today’s needs. Pick the tool that has the features you need and fits your budget today, but also offers financial and functional flexibility to scale with your team's growth.

Security and privacy

To protect your team's sensitive information, look for reliable security and privacy features. This should include end-to-end encryption, data access controls, and password protection. 

You might also want to research each tool’s track record in the security department. Online reviews on platforms like G2 reviews will come in handy here. 

Compatibility and integration

Your remote pair programming tool should be compatible with your existing software development ecosystem. Choose something that integrates with your project management, version control, and collaboration tools. For example, you can use Loom to streamline your development workflow with its GitHub and GitLab integrations.

Ease of use and accessibility

Your remote pair programming tool should be accessible to your entire team, regardless of their technical ability. You want to ensure that anyone and everyone who wants to use it can use it. 

Look for a tool that’s easy to use when running through your code and documenting your processes.

In this loom, I lay out that we prioritize system ownership above other technical docs so anyone on our team can find the Engineer who might be responsible for a bug to get more context.

Integrating the tool into your development process

Once you choose a tool like Loom for remote pair programming, take the time to integrate it into your development process. 

Here are some tips and best practices for integrating Loom into your workflow:

1. Introduce your team to Loom and provide onboarding sessions

While video recording and sharing is easy with Loom, you should still introduce your team to the tool. Offering training and onboarding sessions will ensure they use it correctly. 

Once they are comfortable with Loom, educate them on how to use Loom videos for pair programming. For example, they can create a Loom video to provide constructive feedback and collaborate asynchronously between live pair programming sessions.

2. Establish best practices

The next step is establishing guidelines and best practices for using Loom within your team. 

This includes standard operating procedures for creating videos, sharing them with team members, and incorporating feedback. You can also encourage your team to use async videos when video meetings aren’t necessary.

3. Leverage Loom for daily standups

You and your team can integrate Loom videos into daily standup meetings to update attendees, share progress, and discuss challenges. Your team can also create Loom videos to document their code and seek feedback.

Remember to use Loom as a complementary tool when there’s no need for synchronous video communication. It’s not a complete substitute for live communication tools. 

4. Use Loom for code reviews

Remote pair programming can be challenging if your message lacks essential context.

You can use Loom videos here to give detailed feedback with context when reviewing code. 

Instead of relying solely on written comments, create videos with screen recordings and annotations to explain code changes, making the review process more efficient.

Success stories: Teams thriving with remote pair programming

Hear from experienced engineers and see how they leveraged remote pair programming to improve their developmental process.  

Best practices for remote pair programming at Amex 

Thiago Ghisi, Director of Engineering at Nubank, recently tweeted about his remote pair programming experience from his time at American Express. 

Ghisi mentioned how pairing was an engaging and enriching experience that helped him build a better connection with his team. Pairing helped his team improve code quality, kept them hyper-focused, led to continuous learning, and resolved challenges faster. 

Ghisi also shared the best practices that contributed to his success in remote pair programming:

  • Ensure crystal clear audio: Invest in good headsets with microphones positioned near your mouth for the best audio experience. Don’t rely on speakerphones or computer mics. 

  • Keep your camera on (bandwidth permitting): Use video communication whenever possible to see each other’s facial expressions, which creates a stronger human connection.

  • Switch roles often: To avoid fatigue and consider both perspectives, switch programming roles at least once an hour—or even every 15 minutes if needed.

  • Optimize your screen resolution: Avoid the lag of remote desktop tools by transferring the work from one computer to another. Ghisi says, “As a Rule of Thumb, always use the smallest resolution of the two [screens] as a baseline. ”

Thiago Ghisi also stressed the importance of creating a positive and productive experience for both parties, suggesting that “remote pairing is more than using the right tools.”

For example, Ghishi suggests taking regular breaks. After all, remote pairing can be draining. Schedule regular breaks using the Pomodoro Technique, 25 minutes of work followed by a five-minute break, to maintain focus and prevent burnout. 

You can also use a mix of live videos and async video messaging. Use the former when it’s absolutely necessary and rely on async Loom videos for less taxing matters, so you don’t have to be alert at all times and can program at a slower, more convenient pace. 

A developer shares his personal experience 

Luke Perry, a dedicated practitioner of Extreme Programming (XP), shared his personal experience with pair programming

He spent about 40 hours a week pair programming in an innovation lab at a Fortune 100 company, working on software products in small teams. Perry and his team also spent a fair share of their time remote pair programming, including six weeks with a pair in another time zone.

He shares his key takeaways:

  • Team dynamics and learning: Pairing led to fun, deep team connections and rapid skill development, especially when pairing with experienced developers.

  • Enhanced problem-solving: Two heads were better than one, leading to better solutions and preventing over-engineering.

  • Challenges and adaptation: Not all developers adapted well to pairing, which required strong communication skills and empathy.

Sharpen your programming workflows with Loom

Remote pair programming may seem daunting at first, but the benefits exceed the initial effort. You’ll be able to improve code quality, foster team bonds, and debug code, even in distributed teams. 

The right remote pair programming tool, like Loom, streamlines the process and keeps your distributed teams in sync. 

Start your journey towards more efficient remote pair programming today. Share codebase context and build more innovative products with Loom. 

Try Loom for free and see how async videos and annotations enrich your collaboration and improve code quality. 


Apr 30, 2024

Featured In:

Share this article: