Conflict Resolution and Difficult Conversations Questions

Direct answer

Open by naming the shared goal, a reliable outcome, not a battle over who is right, and ask for the senior engineer's reasoning before pushing your own. Then convert the disagreement from a debate you might lose on seniority into a testable question you can both agree to settle with evidence.

Structured elaboration

The move is to make the disagreement testable instead of rhetorical.

1. Acknowledge their point genuinely first. Their concern (usually speed, risk of an ill-understood fix breaking something else, or a bad past experience with a similar change) is almost always real, even if you disagree with the conclusion. Naming it lowers defensiveness before you say anything else.
2. Ask clarifying questions to find where the actual disagreement lives: is it about how big the risk is, how expensive the fix would be, or whether it matters at all for this code path? "Keep it as is" often hides a different worry than the one being argued.
3. Reframe from positions to a shared question: instead of arguing whether the code should change, agree on what evidence would tell you whether the risk is acceptable.
4. Propose a small, timeboxed, reversible experiment that answers that question, and offer to do the work yourself so the ask costs the other person as little as possible.
5. Agree in advance on what happens if the result is ambiguous or if you disagree on the interpretation, ideally a specific third person or the component's owner, rather than letting seniority alone decide after the fact.
6. If the conversation is getting heated in front of others, move it to a smaller setting. A public back-and-forth in review comments tends to entrench positions; a short call rarely does.

Worked example

A training pipeline you both worked on had occasional flaky runs. A senior engineer argued the variance was tolerable and that chasing it would slow the team down for little benefit. Instead of arguing the point directly, you asked what would change their mind, and they said seeing the flakiness actually caused by the non-determinism, not just correlated with it. You proposed pinning the random seed and a couple of other sources of variation for a week and comparing failure patterns against the unpinned baseline, and offered to make the change yourself behind a flag so it was trivial to revert. Over that week, the pinned runs were noticeably steadier and the flaky failures you'd both flagged before stopped recurring in the pinned runs. The senior engineer agreed to keep the change, in part because the test answered their actual question rather than yours.

Trade-offs and pitfalls

If you are not equally senior, arguing your position directly can look like you are pulling rank in reverse, insisting you're right because you feel strongly. Anchoring on a testable question sidesteps that, because the evidence decides it, not either person's standing.
The "run an experiment" move can be used in bad faith to stall indefinitely. If someone keeps moving the goalpost after a test resolves the original question, that is the moment to invoke the pre-agreed tiebreaker rather than repeating the same ask.
Watch the trap of optimizing for being right instead of being reliable. Sometimes the senior engineer's read on the risk is correct and you are the one who should update, that outcome is a success for the process even when it is not the outcome you expected.

Direct answer

In the room, the goal is to stay calm, briefly acknowledge the concern, and move the deep discussion out of the meeting rather than defend your approach point by point in front of the team. The real conversation, and the actual repair if one is needed, happens in the follow-up.

Structured elaboration

• Respond, don't defend. A short, neutral acknowledgment ("I hear the concern about risk") keeps you from either capitulating or arguing in the moment.
• Protect the meeting, not just yourself. Explicitly note you'll take the detailed discussion offline so standup keeps moving for everyone else, which also signals you're not avoiding the issue.
• Come prepared to the follow-up. Bring the actual evidence (data, a rollback plan, whatever's relevant) so the follow-up is a real technical conversation, not a rehash of who was right in the room.
• Stay genuinely open to being wrong. The goal of the follow-up is to actually evaluate the concern, not just to relitigate the public moment.

Worked example

My manager criticized my proposed approach to a refactor during standup, calling it risky in front of the team. I stayed neutral and said I heard the concern about risk and wanted to understand which part they thought was riskiest, then said I'd pause the deep dive so we didn't block the rest of standup, and asked for 15 minutes afterward. In the follow-up I came with the profiling results, a rollback plan, and compatibility test results I'd already been working on, listened to the specific risk they were flagging, and we adjusted part of the design based on it.

Trade-offs and pitfalls

Deferring to a follow-up can look like avoidance if you never actually raise the topic again, so the follow-up has to genuinely happen, not just get implied and dropped. Staying calm in public is important, but if you never privately address that the criticism was delivered in a way that undermined you in front of the team, the pattern repeats, that's a separate, quieter conversation worth having with your manager directly. And coming to the follow-up only to defend your original design rather than actually engage with the concern wastes the credibility the calm public response bought you.

Direct answer

Raise it early and privately, focused on the pattern rather than a single incident, and ask for one specific, small change rather than a general request to "communicate better." The framing matters: you're protecting the team's ability to deliver, not criticizing your manager's judgment.

The move: name the pattern, own the cost, ask for one thing

1. Choose a private one-on-one, never raise this in a team setting where it can read as public pushback.
2. Open with intent, not accusation. State plainly that you want the team to hit its commitments reliably, before you name the problem. This reframes the conversation as shared interest, not complaint.
3. Name the pattern with two or three concrete instances, not "you always" or "this keeps happening." Specifics are harder to dismiss and easier to discuss without defensiveness.
4. State the cost in terms your manager owns: rework, missed commitments, the team's confidence in future sprint plans, not your own frustration.
5. Make one small, specific ask. A heads-up in a shared channel when priorities shift mid-sprint is concrete and adoptable; a whole new change-management process is not a conversation, it's a project, and it will read as overreach.
6. Listen for their constraint. Late changes are often absorbed pressure from above them. Asking what's driving it turns the conversation from confrontation into problem-solving, and may surface a fix you couldn't propose yourself.

Worked example

Three sprints in a row, priorities shifted mid-week without warning, and the team reworked already-reviewed code each time. In a one-on-one, you say you want the team's commitments to hold, then walk through the three instances and what each cost in rework. You ask for one thing: a short heads-up before a change lands mid-sprint, even informally, so the team can flag what's already in flight. Your manager explains they're absorbing last-minute asks from their own leadership and hadn't realized the downstream cost; they agree to flag changes before committing to them upward.

Trade-offs and pitfalls

Escalating past your manager before raising it directly with them first skips the relationship and reads as going over their head, even when you're right about the pattern. Turning the ask into a formal governance process oversteps what a single conversation can carry, and it isn't yours to impose. If the pattern continues after a clear, direct ask with a stated cost, that's the actual trigger to escalate, framed as protecting the team's delivery, not as a personal complaint about your manager.

Direct answer

Interrupt the blame in the moment by redirecting the question itself, from "who caused this" to "what about our systems and process let this happen", and say it out loud as an explicit redirect rather than just steering the conversation quietly. A room that's turned adversarial needs to hear the norm restated, not just have it enforced silently.

Structured elaboration

This is the core discipline of a blameless postmortem: separate the person who made a change from the system that allowed that change to cause an outage.

1. Interrupt explicitly: pause and name what's happening ("we're drifting into blaming a person, let's get back to what let this happen") rather than letting it continue and hoping it self-corrects.
2. Redirect to the timeline and evidence: logs, timestamps, the sequence of what happened, not opinions about who should have known better. Facts are hard to argue with; character judgments are not.
3. Reframe the specific accusation as a systems question: "the config was wrong" becomes "what let a config like that reach production without being caught," which is a question about review process, tooling, or guardrails, not about the individual.
4. If the tension is genuinely personal, not just heat-of-the-moment, take it offline: tell the room you'll follow up with the two people individually, and actually do it. Don't let "we'll talk later" become a way to avoid an uncomfortable moment.
5. Convert the discussion into specific, owned action items before the meeting ends, so the room leaves with something concrete instead of residual tension.

Worked example

In a post-incident review for an outage caused by a misapplied configuration change, one engineer says, in front of the group, "this happened because Sam pushed a config change without checking it." Sam gets defensive and the exchange starts to escalate. You interrupt: "let's park who pushed it and look at the path it took to reach production, config change, review, deploy, what step should have caught this?" That question can't be answered with blame, only with a description of the pipeline, and it surfaces that there was no required second reviewer for that config path, which is the actual fixable thing. After the meeting, you check in with both engineers individually, since even a well-handled public moment can still leave one person feeling singled out.

Trade-offs and pitfalls

• "Blameless" can drift into "consequence-free" if repeated carelessness never gets addressed anywhere. That conversation still needs to happen, just privately and separately from the incident review, framed around the pattern, not the incident.
• Interrupting too gently, a soft "let's stay positive," often doesn't land as a real redirect. It needs to be specific enough that everyone in the room understands exactly what changed.
• Redirecting to systems can become a way to avoid ever naming that a specific action needs to change, which trades honesty for comfort.
• If you personally have a stake in the outcome, it was your team, your call, your redirect can read as protecting your own team rather than the process. Bringing in someone more neutral to facilitate is sometimes the better call.

In the moment, I would stop the blame loop and focus on the shared outcome. I would acknowledge the miss, ask for the facts, and clarify the handoff point that failed. By handoff, I mean the moment one team passes work to another with clear expectations.

I would say something like, "Let's separate what happened from who to blame. What was the requirement, what was the agreed due date, and what did each side believe was done?" If our requirements were unclear, I would own that and propose the next concrete step, such as a revised spec, a quick review, or a smaller interim deliverable so the project does not stall completely.

For the next milestone, I would prevent repeat issues by adding written acceptance criteria, a short handoff checklist, and a scheduled signoff before work starts. For example, if an API needed three required fields and one edge-case behavior, I would list those explicitly in the ticket and get both teams to confirm them before implementation. That lowers ambiguity and makes accountability much easier.