Onboarding & Teamwork
Pair Programming with a New Teammate: Agree on Roles, Pace, and Learning Goals
A complete fictional one-hour pair agreement, exchange and mixed debrief separate delivery, learning and access; a six-case offline Python helper demonstration is explicitly independent of workplace claims.
Before pairing with a new teammate, agree on a small task, a learning goal, who drives and navigates, when to switch, and how either person can pause. Check the workspace and access boundaries before sharing control. At the end, record what was completed and what each person can explain independently; record whether an explanation was independent or followed a prompt, rather than infer understanding from agreement.
Pairing can help expose assumptions and share context, yet it is not a promise that two people will finish every task faster. This LandOffer.ai guide combines a fictional one-hour pairing session with a separately executed, small local Python example. The conversation and learning outcomes are invented. The local checks verify only the displayed helper behavior; no workplace repository, employee session, account or production service was tested.

Choose one delivery goal and one learning goal
Start by asking what the new teammate already knows and what is unfamiliar about this task. Someone new to the team may know the language well while lacking repository context. Avoid treating “new” as a permanent skill label or assuming the experienced partner has every answer.
In On Pair Programming, Birgitta Böckeler and Nina Siessegger describe driver and navigator perspectives, small goals and regular role changes. Their January 15, 2020 practitioner guide also discusses different experience levels and the need to leave room for questions. Use those distinctions to design participation rather than make the newcomer a passive audience.
The fictional pair is Ari, an engineer who recently joined the team, and Ren, who knows its internal tooling. Their delivery goal is to draft one helper for strings, integers and missing fragments, preserving numeric zero while omitting only missing values and empty strings. Their learning goal is for Ari to explain why a generic truthiness filter would lose that value and identify the distinction between the input rule and a presentation-policy question.
They agree that completing the helper does not establish familiarity with the whole codebase, readiness for an on-call rotation, or performance in the role. Ren also wants to learn whether the repository explanation is clear enough for someone encountering it for the first time.
GitLab Support's pairing-session guidance describes collaboration and knowledge sharing across its support engineers. That is a company-specific practice covering more than programming; it does not mean every troubleshooting conversation has the same structure or that session attendance proves learning. Ask what this particular pair wants to leave able to do.
Fill the agreement before sharing control
Ari and Ren accept the following plan for a fictional May 12 session, 10:00–11:00 UTC. Their manager has allocated one hour for each person; this replaces optional developer-tool exploration, not required support coverage. Either person may ask to stop early and record where they reached.
| Agreement | Completed entry |
|---|---|
| Task boundary | Work on an invented example using strings, integers and missing fragments; draft code and expected checks, without merging or deploying |
| Driver responsibility | Type the current small change, explain the intention, and ask before an unfamiliar command; retaining the keyboard is not a requirement to know every answer |
| Navigator responsibility | Check the stated behavior, notice missing cases and keep broader questions visible; offer a prompt before taking over |
| Switch and pace | Review role changes at 10:25 and 10:45, with an explicit handoff; slow down or extend a discussion by reducing task scope, not silently skipping the debrief |
| Pause rule | Either person may say “pause” for a question, fatigue or uncertainty; no personal explanation is required |
| Access boundary | Use a disposable local example with invented inputs; no secrets, customer records, production terminal, shared credentials or recording |
| Review boundary | A draft and local examples still need the team's normal review before use; no merge or release authority is created by pairing |
Sharing a screen is not the same as approving remote edits or arbitrary terminal commands. If the team uses Visual Studio Live Share, Microsoft's security documentation distinguishes hidden files from excluded files and describes controls over shared access. Review the actual collaboration tool and workspace: do not assume another editor behaves the same way, or that a hidden file is inaccessible. No Live Share account behavior was tested for this article.
If the required environment is not available, narrow the session to reading an approved example or planning checks. Do not borrow the experienced partner's credentials just to keep the lesson moving. Record the access problem with its proper owner and return to it separately.
Run the hour with room to ask and switch
The filled schedule separates setup, active work, a break and the learning check. It is a sample agreement, not a universal timer that overrides someone's need to pause.
| Time, UTC | Roles and activity | Intended evidence |
|---|---|---|
| 10:00–10:10 | Both restate the task and check boundaries | Shared input rule and listed open questions |
| 10:10–10:25 | Ari drives; Ren navigates | A draft and explanations of the chosen checks |
| 10:25–10:30 | Pause, then confirm the role handoff | Brief reset; no typing during the break |
| 10:30–10:45 | Ren drives; Ari navigates | Ari questions whether an alternative handles empty strings |
| 10:45–10:55 | Ari drives a recap; Ren withholds hints initially | Predictions and explanation, with any prompts recorded |
| 10:55–11:00 | Both debrief | Completed work, supported understanding, gaps and next task |
Before a switch, the outgoing driver names the current goal, the last change and the next uncertainty. The incoming driver repeats the next step in their own words. If the explanation exposes a missing assumption, spend the time clarifying it rather than treating the handoff as a speed exercise. Agree whether a hint is wanted before supplying the exact answer. The navigator can ask a question, offer a small clue, or demonstrate once with permission; those forms of help should remain visible in the debrief. The pair can reduce the delivery scope to preserve the learning goal and the agreed stop time.
A role switch transfers the keyboard, not responsibility for thinking. The navigator can ask about the current assumption and give the driver time to explain the next change. The driver can request a minute to read rather than narrate continuously while also processing unfamiliar code.
Here is part of the completed fictional exchange during Ari's first turn:
Ari: “I would remove fragments that evaluate as false, then join the rest. Does that match the optional-part rule?”
Ren: “Before changing it, what should happen to the integer zero in the sample?”
Ari: “It should be shown. A truthiness check would remove it. I need to separate missing content from zero.”
Ren: “Yes. Which input values have we actually agreed to omit?”
Ari: “Only a missing value and an empty string. I want to write those separately. I am not sure whether spaces should count as empty.”
Ren: “That is a presentation-policy question. Let's retain it in the notes rather than decide it by accident.”
The answer followed Ren's prompt. Their debrief should not later call it an entirely independent discovery. Ari still contributes by identifying the implication and asking about a boundary the task did not settle.
After the switch, Ren proposes omitting only missing values. Ari notices that an empty string would then contribute an unwanted separator. Ren accepts the correction. Both partners have supplied information; the session has not become a lecture in which only one person can be right.
Keep a small check separate from a workplace result
The following helper was actually executed locally for this article using Python. It operates on a finite list of strings, integers and None; it performs no network, repository or account action. It does not trim whitespace, escape HTML, validate arbitrary types or define a product's display policy.
def join_parts(parts):
return " | ".join(
str(part) for part in parts
if part is not None and part != ""
)
Six bounded local checks passed. The table shows four informative cases; the other two were an empty input list and a list containing only None and an empty string, both producing an empty string.
| Input | Actual local output | What the check establishes |
|---|---|---|
['queued', None, 0] |
queued | 0 |
The missing fragment is omitted while numeric zero remains |
[0] |
0 |
Zero alone is retained |
['0', 0] |
0 | 0 |
String zero and integer zero both render |
[' ready '] |
The surrounding spaces remain | No trimming behavior is implemented |
The six results are not a performance benchmark or evidence that the fictional pair ran these checks at work. They verify this local helper against the stated examples. They also do not cover every Python value or another language's rules.
For an actual team task, preserve the distinction between a local demonstration, repository test coverage and review approval. If the work needs broader input handling, choose the additional requirements and checks with the relevant owner. A successful small example cannot approve its own use in a product.

Write a debrief that shows the learning gap
The fictional session ends with a short record agreed by both partners. Ari explains the zero case again during the 10:45 recap before Ren offers a hint. Ari also recognizes the empty-string separator issue while navigating. Ari needs Ren's help locating the fictional example project's check-file convention, and neither person has a confirmed requirement for trimming spaces.
The completed debrief keeps those outcomes separate:
| Area | Evidence in the fictional session | Recorded status and next step |
|---|---|---|
| Numeric zero and missing fragments | Ari explains the distinction during recap without a new hint | Independent explanation in this limited example; not evidence of whole-codebase mastery |
| Initial discovery of the zero problem | Ren's earlier question prompted Ari to examine zero | Prompted reasoning, accurately retained in the learning record |
| Empty-string handling | Ari catches the missing omission rule during Ren's turn | Useful navigator contribution; keep the corresponding check |
| Repository check-file location | Ari finds it after Ren points out the relevant directory | Still needs support; include a bounded locating task next time |
| Whitespace policy | Both identify the uncertainty; no owner answer is available | Open question for the feature owner, not a silent decision to trim |
Ari accepts a twenty-minute follow-up exercise: locate the approved example check file, explain where a new case belongs, and draft one whitespace-policy question. Manager Dev confirms this replaces twenty minutes of optional tooling exploration. Ren accepts a ten-minute review in the next onboarding slot. These are fictional accepted plans, not completed later tasks.
The delivery note says a draft and candidate checks were produced, with no merge, deployment or broader compatibility claim. Ren records that the directory explanation was insufficient on its first attempt and will revise that explanation. Responsibility for improving the session is shared; Ren retains responsibility for improving the context they supplied, alongside Ari’s practice task.
Adjust the next session using what you observed
Ask each other whether the pace, role changes and pauses were usable. The answer may be to shorten the next session, choose a better-defined task, allow solo reading first, or use another collaboration format. Finishing early and naming an access or knowledge blocker can be a better outcome than silently pushing through confusion.
For the next pairing session, write one delivery goal, one learning goal and the access boundary before opening the workspace. Finish with specific explanations or predictions, the help still needed, and a next task whose scope and review time both partners accept. Return to LandOffer.ai for more workplace guides; the useful outcome is a clearer shared understanding and a bounded continuation, with any productivity claim left to evidence the session actually collected.
Sources and Further Reading
- Birgitta Böckeler and Nina Siessegger: On Pair Programming — driver/navigator roles, small goals, switches and differing experience; January 15, 2020.
- GitLab Support: Pairing Sessions — company-specific collaboration and knowledge-sharing practice.
- Microsoft Learn: Security Features of Live Share — tool-specific sharing permissions and hidden versus excluded files.


