The Glue Trap

I've noticed a distressing pattern that junior developers fall victim to, particularly those who've switched careers: when they hit technical roadblocks, they pivot toward glue work — the documentation, coordination, and communication tasks that keep projects moving.

It's an understandable move. Glue work feels productive, leverages existing strengths, and provides immediate validation when coding feels impossible. Over time, a junior dev who consistently engages in this type of work may even become the "documentation person" or "unofficial project manager" on the team, with these tasks being directly assigned.

Be warned: this is a trap! It can be valuable for junior developers to learn how the business works and build relationships across the organisation, but if you're doing this at the expense of learning technical skills, you're stymieing your dev career.

Partly this is because technical competence is what employers evaluate in performance reviews and interviews, but more importantly you need a solid technical foundation to be effective at glue work itself.

Software is a sociotechnical system. Without deep technical understanding, you'll consistently misdiagnose problems — treating technical issues as communication failures¹, or proposing process solutions for architectural problems. If you focus on glue work as a distraction from your coding tasks, your impact will actually become less valuable over time — and you will be in for the shock of your life during your next performance review!

If you're caught in this trap, here's how to break out:

Build habits for managing cognitive load

Junior developers are excellent problem-solvers. When a junior developer gets stuck, it's almost never because they lack the capability to learn their way through the problem, but rather because they've exhausted their mental capacity trying to keep track of too many details.

This is why having reliable techniques to prevent the build-up of cognitive load is absolutely crucial. When you're deep into a coding task, you need habits you can rely on automatically to wrangle the mental overhead — freeing up your headspace to focus on learning and problem-solving.

The good news is these habits are entirely learnable. Start by practising attacking problems methodologically, avoiding cross-contamination, and managing distractions. Work on building these habits during solo work and in pair programming sessions, and ask developers in your network how they manage their cognitive load. You'll discover surprisingly simple techniques that make a massive difference!

Experiment with "page out" techniques

Even with excellent cognitive load management habits, there will be times when a problem genuinely requires you to hold more information than your brain can comfortably handle. When you find yourself in this situation – feeling mentally overwhelmed and starting to lose track of important details – you need techniques to quickly offload information.

Just as a computer "pages out" extra data to the hard drive when RAM is full, you can use external tools to temporarily store information your brain doesn't need to track moment-to-moment. This frees up mental space to focus on the core problem without losing important context.

Effective techniques that I've observed in the wild include:

• drawing diagrams of components and connections

• taking detailed notes and reviewing regularly

• leaving breadcrumb comments throughout the code

• physically modelling the system with cards on your desk

Experiment with different approaches to find the ones that work for you, and practise reaching for them early — before you feel overwhelmed, not after.

Ask for the right kind of help

If you've been stuck in the glue trap for a while, breaking out requires more than just personal habit changes — you need your teammates to support you differently, too. Even highly skilled developers often struggle with mentoring effectively. They might think they're being helpful by taking over when you're stuck or giving you "easier" coordination tasks, but this actually reinforces the trap.

Here are some ways you can gently nudge them towards giving the right kind of help:

During pair programming sessions

• Ask to be the driver: "Could I take the keyboard? I learn better when I'm typing."

• Resist accepting direct answers and instead ask for leading questions: "Rather than telling me the solution, could you help me think through what might be causing this?"

• When senior devs offer to "just fix it quickly," push back gently: "I'd really value watching you work through the debugging process — could you talk me through your thinking?"

During your next one-to-one with your manager

• Explain that you're refocusing on technical development and discuss what support you'll need from the team.

• Be specific about the types of tasks you want to take on and the mentoring style that helps you learn best.

When glue tasks come your way in standups or sprint planning

• Deflect diplomatically: "I'm keen to focus on building my technical skills right now — could someone else take this on?"

• Suggest pairing glue work with technical components: "I could write that process doc if I can also build the automation script to go with it."

Remember: a job is a relationship. Your manager and teammates want you to succeed, even if they don't always know how best to support you. By clearly communicating your goals and demonstrating your commitment to growth, you're making it easy for them to help you escape the glue trap and build the technical career you want.

1. Or worse, treating communication challenges as technical problems!