Pairing with Juniors When Agents Are in the Room
Seniors are pairing with agents. Are they still pairing with juniors?
Guest post by Colette Molteni. Founder and author of Empathy Elevated, a Substack publication on emotional intelligence, Stoicism, and AI-human partnership for technical professionals
Aleix made a point in his early April post, Rethinking Pair Programming in the Age of AI, that there is no such thing as “pairing with AI”. No, in fact, the pairing is grounded as a human act.
When it’s a person and an agent, that is agentic development. It’s a different practice with a different set of rules.
Once you accept this distinction, an uncomfortable realization surfaces. Seniors are not always paired with AI. But are they still pairing with juniors now that agents are in the room?
Walk into most engineering teams right now, whether it is agentic, software, or backend, and you will see two things happening in parallel.
Seniors are getting faster with agents. Juniors are getting quieter. The two patterns are not unrelated; they are from the same dynamic but on different ends of the long table.
The most common AI-era pairing failure is not technical. It’s when seniors stop scheduling pairing sessions because the agent is perceived to be faster. Juniors stop asking them for the sessions because they do not want to appear as a bottleneck.
Nobody decides this intentionally.
It just happens.
What Seniors Stopped Transferring When Agents Showed Up
A pairing’s real product was never about the code only.
It was about judgment formation. That is something an agent cannot transfer to a junior. It is innately human work.
The underrated function of a pairing session was making the seniors’ reasoning observable. A junior could witness the wrong turn, the half-formed hypothesis, and the moment the senior could explain, “Actually, here’s why we do not want to do it that way. Let’s try this instead…”
Agentic development collapses the visible reasoning. The output can be read but not iterated on, as you would with a human colleague over Zoom or in person.
The final output appears, but the path to get there happens in milliseconds, without the reasoning absorbed. The deliberation disappears like a flame extinguished. The juniors see the answer, and not the thinking.
Juniors do not just need the correct code or way forward to troubleshoot. They need to watch how a senior decides between several plausible approaches.
That’s what builds an engineer’s judgment.
That’s exactly what solely agentic workflows skip by default.
Aleix named it in his piece that seniors discover agent productivity, but then the pairing calendar quietly empties. Nobody directly announces it. The slot just drops.
The cost builds up over time. A junior never watches a senior reason out loud. They miss more than just that weekly session at 10am on Tuesday. They miss the pattern of how seniors later change their minds. That is a pattern to be observed and make them senior one day.
Noticing what your team is absorbing from your behavior, not just from your output, is a quiet power. Seniors set the implicit curriculum whether they intend to or not.
Three Prompt Patterns That Build Judgment Instead of Bypassing It
The three prompt patterns can be used to move from simple diagnosis to practice in collaboration, iteration, and applying judgment.
Pairing is a human exercise. The agent is a tool. Like any tool, what matters is what the human decided to build before they picked it up.
The agent is a contributor to the session, not a substitute for a pairing session itself.
These are patterns you can leverage as a senior with your junior in your next pairing session.
Treat the output of these patterns as a third party: to be challenged, edited, or even discarded.
Pattern One: Articulate the problem before opening the agent
The junior writes three things before any prompt is typed.
The problem statement
The constraints
At least one hypothesis about the approach
Make this non-negotiable: written out, every time. Learning loss occurs in the seconds between knowing there is a task and assuming it is always a prompt. The thinking that should belong to the engineer gets handed to the agent before the engineer ever did it themselves.
This exercise is short, with just three to five minutes to do before writing out the prompt. But in those few minutes, the junior becomes the author of their work rather than the editor of the agent’s work. Skip this step, and the remaining session is a cleanup, rather than a collaboration.
Pattern Two: Pair upon the prompt itself, not just the output
Review the prompt together before the junior runs it.
Where is it unclear?
What context is missing?
What assumption is buried in the phrasing?
Reframe what code review is becoming. The artifact worth reviewing has shifted upstream, from the diff to the prompt.
Pattern Three: Require a counter-position
After the agent outputs, the junior has to articulate one reason they would push back on it.
Do this before accepting it.
This trains the muscle of disagreeing with a confident-sounding source. That muscle is the actual deliverable.
This pattern is the one juniors will resist the most. Pushing back on an output that sounds confident can feel presumptuous. The agent is great at sounding authoritative. But that’s exactly why it has to be practiced during a pairing. As a senior, you are there to validate the disagreement and challenge the agent. Building confidence in dissent is a skill.
The Review Question That Tells You Whether the Junior Actually Learned
A standard pull request review was built for a different world. You would comment on the differences, request changes, and approve. The workflow assumed the author wrote the code.
The difference is that the thinking is different now. The artifact is not necessarily someone else’s thinking. The mentorship has to move upstream of the diff.
Ask the junior to walk you through why the agent’s approach is correct. Do not accept that it just is. If the junior cannot articulate this, the pull request is not ready, regardless of the test results.
This is not about gatekeeping. This is about mentorship with the new interface of working in tandem with agents.
Ask in your next pull request review, “What did you consider and reject?”
If the answer is “nothing, the agent gave me this”, that’s the signal, not a fail. It’s a teaching moment.
Over time, the answers to this question will become ingrained knowledge within the team. The paths that are rejected weigh just as much as the accepted ones, as these are lessons that carry through. A senior who gathers these answers and reviews them can spot which agent failure modes the team is already recognizing, and where the teaching moments still are.
How often does the junior push back on the agent’s output during a review? An increasing frequency over time is an indicator of forming a judgment. A frequency of zero indicates dependency.
How seniors deliver this review matters as much as what we review. The goal isn’t to make juniors defensive about agent use. The goal is to make the team’s reasoning visible currency.
Pairing Is Still Human. The Stakes Just Got Higher
Pairing is still human, but the stakes aren’t only about throughput and sprint velocity. It is about the team’s long-arc capability and the judgment that ships next quarter and the quarter after that.
Agents quietly changed something about leadership.
The fastest path to short-term output now bypasses the slowest path to long-term capability. Every senior is now choosing between these two paths, each day. Most are not even aware of this choice.
The fastest path to short-term output now bypasses the slowest path to long-term capability. Every senior is now choosing between these two paths, each day. Most are not even aware of this choice.
This choice plays out one calendar invite at a time. The senior who skips a pairing session because the agent is faster has not necessarily done anything wrong on that day. The output shipped. The sprint moved. But compounded over time and repeated, it produces a team of engineers who can prompt but not think. The damage seeps in, like a tap slowly overflowing a sink.
Pairing is not just knowledge transfer. It is an investment in someone else’s reasoning, becoming independent of yours. Agents can make that investment easier to skip, but they do not make it less necessary.
You are paid to build a team, not just to ship a sprint.
About Colette
Founder and author of Empathy Elevated, a Substack publication on emotional intelligence, Stoicism, and AI-human partnership for technical professionals
Creator of The PACE System™ (Pause, Ask, Consider, Empathize), a framework for navigating high-stakes interpersonal moments in technical environments.
Data and Process Excellence Manager at ResMed, a global medical technology company
Has mentored junior employees through AI-assisted technical work
Lean Six Sigma Black Belt
 | A guest post by
|