I once worked on a coding project where I was effectively the junior. I had picked up a fix, worked through it and opened a pull request. I was pumped about it. I knew I still had a lot to learn, and I was looking forward to the review, because that was where the learning would happen.
Later, I noticed the pull request had been taken over. Someone else had made their own fixes to it and merged it. No review comments, no explanation. The task was done, and I was left looking at a merged pull request that no longer really felt like mine.
I was kind of mad. I still did not know what had been wrong with my version, or why the changes were needed. I did not get the learning I had been hoping for, and I did not get the simple good feeling of finishing something I had started.
They probably meant to help. From their side, they just fixed a problem quickly. But I think it showed something important: helping someone solve a problem and solving the problem for someone are two different things.
The other side of the table
These days I am usually on the other side of that situation. I am a lead DevOps consultant, I have worked in IT for over 20 years, and I regularly work with teams that include junior engineers.
By "lead" I do not mean a manager. I mean the tech lead or lead engineer who is still hands-on, reviewing code, making architecture decisions and jumping in when something breaks. That is the person others turn to when they are learning or getting stuck on a problem. How that person reacts in those moments has been on my mind for a while.
My former colleague Tuomo Niemelä wrote a great series called Where's the undo button?, and the second part, on psychological safety, stuck with me in particular. He makes the case for teams where people can speak openly, take risks and learn from their mistakes. In the third part he reminds us to take care of our juniors. I agree with all of it.
It got me thinking about where that kind of environment actually comes from in a lead's everyday work. What do we do when a junior opens a pull request that needs work? How do we respond when someone proposes an approach we can already see is flawed?
A lead still has to set the technical direction, and often bring the best solution to the table. That is part of the job, but only one part. The other part is helping build a team that becomes increasingly capable of solving problems without you.
Don't take over the pull request
When you see a pull request with problems, taking it over is tempting. You already know what the fix looks like. Writing review comments, explaining why, and waiting for the author to make the changes all take longer than just doing it yourself. The code gets merged either way.
But look at what the author is left with. Like me back then, they do not know what they could have done differently, and they lose ownership of their own work and the chance to finish it. Tuomo puts that last part well in the third part of his series: "don't ever rob people of feeling good about themselves". Finishing your own work is one of those feelings, and taking over denies them that.
There is also a longer-term cost, and in my case it was the one that lasted. After that pull request, I became hesitant. I started doubting my skills. I began polishing my pull requests on my own before opening them, so they would be as finished as possible before anyone saw them. That is the opposite of what you want from a junior. You want them to share work early and get feedback. One silent takeover taught me to hide my work instead.
None of this means letting poor code through. The bar for what gets merged stays exactly where it was. What changes is who does the work to get there. Explain the concern, leave review comments, ask questions or pair with them, and then let them make the change themselves. People learn by doing, and by getting things wrong. If you always fix their work for them, you take that away from them.
There are times when taking over is the right call. The question to ask yourself is whether taking over is an exception you make for a good reason, or your default response to someone else's imperfect work.
Ask how they got there before telling them they're wrong
A related habit is about how you respond to someone's thinking. A junior shows you an approach, and you can see straight away that it is not right. The quickest response might be:
That's wrong. You should do it this way.
It is quick, and it might even be correct, but it cuts their thinking off halfway and tells you nothing about how they got there. A different response is:
Can you walk me through how you arrived at this?
This is what I try to do now. I ask for their angle on what they are doing and let them walk the steps to me. That helps both of us. They get to go through their own reasoning, and I get to see where it went off track. Often it is a misunderstood requirement, a wrong assumption or a pattern they have not used before. Sometimes they made a perfectly reasonable choice and spotted something I had not considered.
When they walk me through their thought process, and if I spot something that could be improved, I ask how they would handle it. Let's say a junior sets up automatic PRs for Terraform version updates on a GitHub VM runner and a GitHub AKS runner that are served from different repos.
Instead of telling them that you cannot do it like this, I might ask: what happens if someone unconditionally approves only one of the updates and both runners handle the same Terraform? Usually they see it themselves: the runners end up on different Terraform versions, working on the same code and state.
A while ago I was watching Ao Ashi, a Japanese football anime, and one line stuck with me:
I won't tell you everything. I'll show you the ropes, but you have to find the answer yourself. Rather than being clearly told what to do, if it's an answer you grasped yourself, you'll never forget it for the rest of your life.
It made me think of the familiar split between teachers, who give you answers, and coaches, who guide you until you find them yourself. I do not fully agree with that split. Good teachers ask questions too, encourage exploring and help people build their own reasoning.
For me the real difference is not teacher versus coach, but handing someone the answer versus helping them find it. And I do believe the second one lasts. If someone just tells me what to do, I will probably forget it. An answer I worked out myself stays with me, and I have seen the same with the people I have worked with.
This does not mean turning every conversation into a quiz or refusing to give a straight answer. Sometimes a clear explanation is exactly what someone needs, and the kindest thing is to just give it. As Tuomo writes in the second part of his series, "It matters as much - if not more - how you say it than what you say."
The cost of always being urgent
Of course I feel the pull to just fix things myself too. Explaining a problem, asking questions and letting someone work through it all take time. Everything is moving so fast, and we need to get things done.
Sometimes delivery really should win. My rule of thumb is that taking over is justified when the cost of waiting becomes greater than the learning opportunity. That might be a production incident, a serious security concern, or a deadline where further delays have real consequences. It can also be a change that has gone through too many rounds of discussion when a simpler solution is clear.
When that happens, I do not do it silently. I explain the situation to the junior and to the project owner, make the fix, and then walk the junior through it afterwards. It is the same action as in the pull request I described at the start. The difference is that nobody is left guessing what happened or why, and the junior still gets something to learn from.
The real problem starts when everything is treated as urgent. If there is never time to explain, coach or let someone work through a problem, learning is always the thing that gets cut. Juniors do not get the chance to build judgement or independence, and the difficult work keeps landing on the lead, who slowly becomes the team's bottleneck.
Leads fall into this easily, because most of us got the role by being good at solving problems ourselves. There is a real satisfaction in walking into a difficult situation and fixing it and I know I have enjoyed that feeling myself. The result is immediate, visible and easy to point at. Helping someone else become able to fix the same problem is harder to measure and the payoff shows up months later in someone else's work.
But the skills that make a good individual contributor are not the same ones that make a good lead. Sometimes the fastest way to complete a task is not the best way to develop an engineer.
The takeaway
A lead's work is not measured only by the problems they fix themselves. It is also measured by how much more independent the people around them become.
Most of that happens in small moments: a pull request that needs work, an approach that is not quite right, a deadline that makes fixing it yourself look like the obvious choice. Those moments teach people more than we think. Every time a lead takes over, gives the answer without explaining it or makes a decision without the people doing the work, the team learns to wait for the lead. A few months later, the lead wonders why everything still goes through them.
It happens on a personal level too. A silent takeover can teach someone to hide their work until it feels perfect, while a question about their reasoning can teach them to share it early. Give people ownership where the risk is manageable, and when you do have to step in, say so and explain why.
Build better engineers, not just better software.
Have you been on either side of a pull request takeover? What did the experience teach you, and what did the best technical leads you have worked with do differently?
Top comments (0)