<span id="hs_cos_wrapper_name" class="hs_cos_wrapper hs_cos_wrapper_meta_field hs_cos_wrapper_type_text" style="" data-hs-cos-general-type="meta_field" data-hs-cos-type="text" >Keeping The Pair Programming Magic Alive When Working Remotely</span>

Keeping The Pair Programming Magic Alive When Working Remotely

A review by Teresa Hume

In light of the COVID-19 pandemic, Andgo has had to quickly adjust to working remotely over the past couple of months. We realized early on that the way we closely work together doesn’t translate very well into working remotely given the tools that we use day-to-day. The biggest challenge being how to effectively pair when working remotely?

There are a ton of benefits to pair programming: knowledge sharing, code review, and getting practice on those communication skills to name a few, so making sure we can work together seamlessly is really important for our developers. Here are a few of the tools we’ve tried out and where we landed for pairing while working remotely.

There are a few features, in particular, we were looking for when researching and trying out tools: 

  • Voice & video quality for smoothly flowing conversations. 
  • Screen sharing capabilities to easily interact with code posted on a pair’s screen.
  • Security. We don’t want our application code available to the public.
  • Integration with our existing toolset.


Our company uses Slack for most of our internal communication. Slack is a great tool for chat. Seeing as we were already using it, it was the obvious first tool to try out for remote pair programming. Its text-based chat game is really strong, but we found its built-in voice and video calls suffer from latency issues. This makes it hard to have a smooth conversation. The screen sharing is pretty laggy, and while you can draw on the shared screen, the drawing is slow as well. All of this combined led to the pairing experience being awkward overall.

The Pros:
  • Currently using it for internal communication so wouldn’t be introducing a new tool
  • Built-in screen sharing
  • Supports video/voice chat with many people.
  • Draw feature on shared screens.
The Cons:
  • Too much latency to have smooth conversations.
  • Screen sharing latency issues.
  • Screen sharing interaction is limited to drawing.


Zoom is the new, popular video call software. It boasts very solid video and call quality, screen sharing with shared drawing interaction, and of course, the ability to set goofy backgrounds. I had tried out Zoom with family calls and found the quality to be way better than the built-in Slack calls, so I figured it was worth looking into. Conveniently, Zoom also has a Slack integration, meaning it would fit in well with our current set of tools. Zoom is not really geared towards pairing though, and the articles on Zoom’s security and privacy policy that have recently come out are kind of scary.

The Pros:
  • Video and voice quality is top-notch.
  • Nicely supports many call participants and different ways to view participants.
  • Screen sharing is reasonably fast and easily lets you switch which desktop you are sharing.
  • Integrates with Slack.
  • All participants in a session can share their screen.
  • Fun backgrounds.
The Cons:
  • Screen sharing interaction is fairly limited. You can draw on the shared screen, but you can’t click around and interact with the sharer’s screen.
  • There are some obvious security concerns, although, with the increased scrutiny that Zoom has been under, they seem to be tightening things up.
  • Zoom isn’t really geared towards pair programming.


We do most of our development using an IntelliJ IDE, so I did some research into potential tools to hook into PyCharm. What I found was Floobits. Floobits allows pairing developers to interact with the same code in a shared environment. Unfortunately, it has a major drawback that took it out of the running before we even gave it a test run. All of the application code you intend to pair on must be uploaded to a third-party server. Security-wise, this is just not acceptable for our needs, but it’s probably a tool worth trying out if you are working on open source projects.

The Pros:
  • Integrates with IntelliJ IDEs, so it should fit in well with development workflow.
  • The shared screen is interactive for all developers in a session.
The Cons:
  • Have to upload your application code to their server.
  • I can’t speak to the call quality of Floobits as we wouldn’t be able to use it for security reasons anyway, so did not end up testing it out.


First off, kudos to the team at Screen for opening up their software to the world while it’s still in beta to try and help people who are suddenly having to manage working remotely. The developer behind Screen actually co-founded Screenhero, which is Slack’s current built-in video call & screen sharing application. We figured they knew what they were doing. As a bonus, it also has a Slack integration that can be configured, therefore hooking into our existing tools. Screen has some definite potential. The voice quality is great, all session participants can directly interact with the shared screen, and you can see a video of everyone in the call. Ultimately, we found that it still had some issues that need to be worked out before it could be a serious contender. It doesn’t handle showing all participant videos. Once you pass a certain number of people, their videos just fall off the end of the screen. And while the screen interaction is a cool feature, it was much too slow for us to actually make use of it. When multiple users try to interact with the shared screen at the same time, things get even slower.

The Pros:
  • Voice and video quality is an improvement compared to Slack’s built-in calls.
  • Full-screen interaction capabilities.
  • They are offering their software’s standard paid version for free in an effort to help out during the COVID-19 outbreak.
  • Solid privacy policy, using P2P connections when possible.
  • Integrates with Slack.
The Cons:
  • Screen has some obvious bugs that are yet to be worked out.
  • The screen interactions are clunky and slow.

USE Together

USE Together is a tool that is very much geared towards pairing remotely. It supports session sizes of up to four participants, is voice only, has great screen sharing and interaction, and integrates with Slack. As an added bonus, their privacy and security policy is great. Sessions are P2P so your data isn’t going through a third-party server, and they don’t capture or store any of your calls. This was hands down the best tool we found for remote pairing. There is essentially no latency interacting with the shared screen. Multiple users can interact with the screen at the same time without any issues, and the call quality is fantastic, more like a phone call as far as responsiveness.

The Pros:
  • High call quality.
  • Next to zero latency full interaction with the shared screen.
  • Any session participants can switch to sharing their screen.
  • Great security and privacy policy.
  • Integrates with Slack.
The Cons:
  • It only supports 4 participants per session. But when pairing you probably don’t want more than 2-3 people involved anyway.
  • If you choose to log in via Slack option when creating your USE account, it creates an account with your listed Slack email address. This proved to be problematic when inviting team members. New invited team members’ emails must match the address that the invitation was sent to. We recently aliased our email domain, so several people had trouble initially joining the team. This is easily avoided by not creating your account through Slack, and just using a password manager instead.

What Did We Choose?

In case the reviews didn’t give it away, we decided to adopt USE Together as our remote pairing tool. Everyone on our team also really preferred Zoom to Slack’s built-in calls for things like daily standup meetings, retrospectives, and other meetings that don’t really need full-fledged screen interaction tools. Therefore, we decided to adopt Zoom as well, and just make sure the required configuration for members of the team is set to as secure as we can make it by default. Our team is now set up to successfully pair while working remotely.

Having the right tools really makes remote working and pairing much easier. Hopefully, this helps a few other teams find tools that will work for them!

About the Author

Teresa, Tech Lead at Andgo

Teresa Huma is a Tech Lead with Andgo. She has been an integral part of the crew since 2015. She is a full-stack web developer working with the Django web framework, celery, backbone, CoffeeScript, Javascript, and MySQL. At Andgo, Teresa is a great mentor and colleague, always willing and eager to share her knowledge and offer support. She never backs down from a challenge and is actively involved in the local tech world.

More about Andgo

Andgo Smart Absence Management was developed specifically for complex scheduling environments. By working with Andgo, you get the benefits of working with a knowledgeable and experienced team familiar with complex scheduling processes, procedures, and requirements.

Andgo’s Smart Absence Management system has created immense value for each of our clients through the automation of complex scheduling workflows. At Andgo we understand no two organizations are the same. With this in mind, we have designed our system to accommodate the unique requirements and use cases of your organization.

Contact us to see how Andgo can help you!

Can SMART automation revolutionize my scheduling practices? Innovation in a time of crisis