Pair Programming, Structured for New Developers
Pair programming is a core part of mentoring early-career developers in Shopify's Dev Degree program. It combines agile software development with direct mentorship, from sharing technical context to close collaboration on problems.
Two developers work together to achieve a shared goal. Effective pairing builds not just coding skill but also communication, curiosity, and teamwork. This framework covers the essentials: roles, structure, agenda, environment, and communication. Use whichever pieces fit your context, goals, and experience level.
Here is what we recommend, pick and choose per session.
Choose a Working Style
Driver and Navigator
This is the classic pairing model, structured like a road trip: one person focuses on the road, the other on maps and signs. Switch roles frequently — driving is taxing.
The driver types and owns the flow, narrating their thought process: what they're doing and why. The navigator watches the code appear, reviews it, and spots edge cases, suggesting refactors and improvements as they go.
This model works best when you're pairing with a junior or intern after a few sessions together. They will have built context and comfort by then. Use the model often once they're comfortable.
Tour Guide
Imagine a city tour: one person knows the city and leads. The tour guide creates a comfortable pace.
Your experienced developer is tour guide: they drive the session while the partner observes, probes, and asks. Use this when your partner is new to the team
Or flip it—-let the less experienced person be the guide. This is a strong move late in an intern's training, when their technical confidence is growing.
Unstructured
An unstructured pairing lets both minds wander.
Freestyle coding without formal roles, good when both are trying out—like exploring a new language with a colleague at equal level. There's real value: team creativity flows, with two people just hacking at a problem together, throwing solutions around.
The cost? Without a mentor overseeing them, it's possible to build bad habits or miss careful process. Fix that by having pairs share what they found with a mentor after the session to ground it.
Beyond Coding: Pairing on Purpose
Pairing can look like many things, and be adapted to specific purposes.
- Code reviews: It’s oddly hard for beginners to understand code review without an example. An experienced mentor sitting alongside scaffolded what to look for early. But the junior's fresh eyes are useful for the mentor, too — prompting them to unpack decisions they take for granted, which also helps the team's documentation culture.
- Technical design or documentation walkthroughs: Try whiteboarding the logic for planned features. Mentorship strengthens the junior, and better team docs result.
- Writing tests only: Never underestimate this for onboarding. The beginner built the feature, manually tested it, knows it works. Writing its test pushes them: Which patterns do they use?
- Onboarding: For helping a new teammate understand your codebase, your community and quirks — the wealth of team knowledge gets shared hands-on.
- Bug hunts: Proactively pairing on hunting a bug (not in a crisis, but predating critical incidents) is a win for team and product, sharing exposure.
Set a Clear Agenda
Be deliberate.
Discuss your pairing aims and expectations before you touch your keyboards:
- What did you want to pair on today?
- How did you see the flow? I drive? You head? Both?
- Where did we expect to end up?
- What would you like targeting seeing yourself building?
- Where did you feel stuck now?
Clarity makes the difference between running and stumbling.
Use the same intentionality about how you end the session: the moment, you stop was better be pre-agreed on.
Pair programming can be used for more than just writing code. Try pairing on other problems and using tools like a whiteboard to work through ideas together.Ground Rules for a Productive Session
Before diving into code, take a moment to shape the environment for the session. Think of yourself as a teacher setting up a classroom: the atmosphere you create determines how much learning actually happens.
Establish that this is a judgment-free space. Statements like "there are no wrong answers here" go a long way. If you're the senior person in the pair, saying "I don't know" is powerful — it signals that you're approachable and human. Accessibility matters too. Not everyone communicates best verbally; a digital whiteboard or a chat platform can work just as well. Invite your partner to share how they work best and adapt accordingly.
Silence during a pairing session is rarely a good sign. Without conversation, neither person has insight into the other's thinking. Get in the habit of verbalizing your thought process as you work. If you need a moment to collect your thoughts, say so rather than dropping into unexplained silence.
Respect is foundational. Value your partner's opinions, even when they diverge from yours — their perspective might surface a better solution. Empathy matters especially in remote pairing. Pay attention to your partner's state: are they overwhelmed by your pace? Are they getting space to contribute? If someone makes a mistake, treat it as a learning opportunity, not an embarrassment. Point it out politely and move on without making a fuss.
Communication: The Core of Pairing
Pair programming is fundamentally an exercise in communication. When working remotely, you lose the body language and gestures of an in-person session, which makes intentional communication even more critical. Good tooling helps: Tuple, for example, is a macOS application that supports remote pair programming with screen sharing and seamless control handoff, without an intrusive UI on screen.
Ask Questions That Open Dialogue
Open-ended questions create room for critical thinking and longer conversations. Closed questions usually just yield a "yes" or "no." Compare these two queries about naming a React button group component:
- Is ButtonGroup a good name for the component? (closed)
- What do you think of the name ButtonGroup? (open)
Other open-ended questions that work well include:
- What are some approaches you took to solving this issue?
- Before we try this approach, what do you think will happen?
- What do you think this block of code is doing?
Even if your partner doesn't have an answer, the process of formulating one helps them learn something they'll carry forward.
Celebrate Small Wins
Positive reinforcement is especially important for people early in their careers. Knowing what went right is just as useful as knowing what went wrong. Don't wait for a feature release to acknowledge progress — pause mid-session when you see your partner do something well. Messages like "Great work on catching the error" or "Huge win today! The PR we worked together is going to help not only our team, but others as well" build momentum and confidence.
Pitfalls to Avoid
A careless comment can derail a pairing session and erode trust. Remember that coding in front of someone is vulnerable, particularly for newcomers. Steer clear of these patterns:
Passive-aggressive or aggressive comments. If you're frustrated, address it directly and constructively rather than hinting at it. Silent treatment, eye-rolling, sarcastic remarks, or subtle digs ("Well… that's an interesting idea") are passive-aggressive behaviors that poison the session. Outright hostility — insults, condescension, or accusations like "Typical intern mistake, rookie" — should never appear.
Absolute words. Terms like "always" and "never" imply certainty that rarely exists in programming. They also come across as condescending. Software is full of nuance, and overgeneralized judgments about what's right or wrong are usually misleading. Replace "always" with "usually" and "never" with "rarely." These moments can become teaching opportunities: if a solution rarely works, explain the edge cases where it might — those exceptions often spark the most interesting conversations.
One developer describes the experience of arriving at Shopify this way: given the volume of resources to explore, even experienced people can feel overwhelmed. Pair programming is the fastest route to context and onboarding, especially in a digital-by-design environment. It's an approach that works for newcomers and veterans alike — a starting point, not a fixed prescription. Early trials with this framework have produced positive feedback from interns, who found it flexible enough to hit their learning goals. It's still being refined, but it's ready to try.
