software-engineering 8 min read

Lift Each Other Up: A Field Guide for Engineering Teams

A talk I gave my team to welcome new joiners: ask with context, own the next step, verify what you share, and leave a clearer path for the next person.

TL;DR

  1. Ask with context. Share the goal and where you’re stuck.
  2. Own the next step. Claim it, or make the handoff explicit.
  3. Verify what you share. Bring your own judgement to AI output and code.
  4. Leave a clearer path. Improve the doc, test or explanation for the next person.

A bunch of new folks joined my team recently, so I put together a short talk for them. Well, for them and for everyone who has been around long enough to still ask “which repo was that in?” 🙃

The point wasn’t onboarding trivia. Nobody is expected to arrive knowing every tool, permission check, repository or historical decision. The point was a handful of habits that make working together easier, habits we can practise on each other. This post is that talk, minus the slides. The examples are made up, but I bet you’ve seen every one of them.

👀 Fresh eyes are useful

If setup feels confusing to a new joiner, that’s not a them problem. That’s feedback.

  • If you’re new: ask early. Show where you got stuck. Your question might save the next person an hour.
  • If you’ve been here a while: explain the why. Pair when words stop helping. Put the answer where the next joiner can find it.

Because nobody learns the auth flow by osmosis.

Pause here: It’s day 3. Setup is stuck. The doc says “just run it”. The terminal disagrees.

What would you send in the team channel? And what would a helpful reply look like?

A hand-drawn setup doc that says "just run it", an arrow to a terminal showing "$ ./setup.sh", "ERROR: exit 1" and "permission denied" in red, and a confused stick figure with question marks above their head, labelled day 3.

💬 Hello, with the useful bit attached

I’ve written about this before, and I’ll keep repeating it till the heat death of the universe. Compare:

❌ “Hey, got a minute?”

The other person has to reply before they even know what you need. That’s an extra round trip, and if they’re in another time zone, an extra day.

Two hand-drawn timelines. Crossed out in red: "Hey, got a minute?", wait overnight, "sure?", wait until the next morning, then the actual question, costing an extra day. Ticked in green: one message with a hello plus the actual question, then answered.

✅ “Hey! The Jira tool returns a 403 locally. Setup completed. I’ve put the error and request ID in the thread. Could someone help me trace the access check?”

A hello and the question fit in the same message. It’s fine to be warm and chatty, we’re only cutting out the round trip that helps nobody. nohello.net says it better than me.

A help request people can answer

You don’t need a template, but a help request that covers these four things is one people can actually pick up:

A hand-drawn help request card with four parts. Trying: Run the Jira tool locally. Tried: Completed setup and retried the same request. Seeing: A 403. Error, environment and request ID are in the thread. Need: A pointer to the right access check, or ten minutes pairing.

A partial investigation is enough. Say where you’re stuck. If you couldn’t find an error or a request ID, say that too. Asking for help shouldn’t turn into homework.

And if you’re the one replying: a 403 doesn’t prove any particular cause. Help find the failing check first. (Also, never paste credentials into a help request. Ever.)

🪟 Our broken windows wear TODOs

The broken windows idea comes from Wilson and Kelling (1982). Its use in policing is controversial, so I’m only borrowing it as a metaphor: visible neglect sends a signal, and small bits of neglect start to look normal. In a codebase they look like this:

  • The flaky test: the third retry is now the test strategy.
  • The tool description: accurate last year, confusing today.
  • The setup doc: one missing step. Every. New. Joiner.
  • The “temporary” workaround: celebrating its second birthday. 🎂
  • The unowned TODO: waiting for its forever home.
  • The missing test: “We’ll add it after this PR.”

A hand-drawn house labelled codebase with six cracked windows, each with a sticky note: flaky test, stale tool description, setup doc, "temporary" workaround with a tiny birthday cake showing 2, unowned TODO, and missing test.

Make a small repair, or leave a clear owner and a follow-up. Keep it proportionate though: a small cleanup is helpful, a surprise rewrite in an unrelated PR is a nightmare to review. And a new joiner who points out a gap is already helping.

🚨 Visibility needs an owner

Pause here: Main is red. Six people have seen it.

Who owns the next move? What’s the first message you’d send?

A seventh pair of eyes does not count as a handoff.

A hand-drawn red CI badge reading main with a cross. Six stick figures look on, each thinking "someone's got it". Six people saw it. A seventh figure in green raises a hand and says "I'm checking it. Update in 15 min." One owns it.

This is the bystander trap: everyone sees it, everyone assumes someone else has it. Darley and Latané’s 1968 study called it diffusion of responsibility. You don’t need to know the root cause before you claim a bounded investigation. Pick whichever one is true:

  • You can investigate: “I’m checking it. I’ll update in 15 minutes.”
  • You’re at capacity: “I can’t take this. Can someone pick it up?”
  • You’re handing over: “Here’s what I checked, and the next useful step.”

Owning it can mean coordinating and asking for help. It doesn’t mean doing every task yourself, and being new doesn’t mean you’re expected to fix an unfamiliar failure alone.

🤖 No meat proxy

AI can help. You still own the answer.

❌ “The AI says it’s probably auth.”

The reader still has to go find the evidence. You’ve just forwarded a guess with extra steps.

✅ “I checked the trace. This access check returns the 403. I haven’t confirmed why yet. Can we pair on that step?”

Two hand-drawn flows from an AI robot to you to a teammate. Crossed out: the note "probably auth" is passed from the AI through you to the teammate unchanged. Ticked: you take "probably auth", check the trace with a magnifying glass, and pass on "verified: this check, not yet known: why".

Be clear about what you verified and what you still don’t know. No Meat Proxy puts it nicely: read, understand and verify AI output before you pass it on to people or submit it as work. Using AI is welcome, the responsibility just stays with you. For code, that means you can explain the change and the tests you ran.

🗺️ A PR should spare us a treasure hunt

Give the reviewer a starting point:

  • What changed: “Handle an error case in tool execution.”
  • Why it matters: “The client needs to see when the operation fails.”
  • What you checked: “Added a regression test and ran the affected suite.”
  • Where you need eyes: “Please check the error mapping and compatibility.”

A hand-drawn treasure map. A reviewer stick figure starts on a dotted path with four numbered stops: what changed, why it matters, what you checked, where you need eyes. The path ends at a red X marked LGTM!

Link the issue, and flag the decision you want the reviewer to look at. If you couldn’t run a check, say so. And if you’re new, a perfectly good review request is “can you check my understanding of how this works today?”

🎲 The engineer’s dilemma

This one is loosely inspired by the prisoner’s dilemma. It’s an analogy, not a payoff model:

A hand-drawn 2 by 2 grid. If I help and they help: we share the work, useful reviews, shared context. If I help and they skip: I carry it, work depends on one person. If I skip and they help: they carry it, my shortcut becomes their interruption. If I skip and they skip: we both lose time, more guesswork, more rework.

Skipping a review can save me time today. If we all skip it, everyone inherits the risk. 🔥

“Help” here means reviewing, sharing context and making docs usable. Sometimes you genuinely can’t help because you’re at capacity, and that’s fine. The point is to make it visible and find a handoff that works, not to label teammates as cooperative or selfish.

We’ll work together again tomorrow

In Axelrod’s tournaments in 1980, the strategy that won was Tit for Tat: cooperate first, then mirror what the other player did last. It won those tournaments, under that setup, so I don’t read it as a universal law. But the shape of it fits a team that works together every single day:

  • Help first: offer context before someone has to chase it.
  • Be clear: say what you can take on, and when.
  • Speak up kindly: challenge the risky change, and explain why.
  • Reset quickly: fix the mistake, keep the trust.

A hand-drawn loop of four boxes with arrows: help first, be clear, speak up kindly, reset quickly, then back to help first, around a heart labelled trust.

Reciprocity, with room for mistakes. (And no, “mirror the other player” doesn’t mean retaliating against your colleagues. 😅)

📝 Feedback someone can use

In a PR:

“Could we add a test for a missing cloudId? I think this path returns before we validate it.”

Name the concern. Explain the reason. Leave room to be wrong, and actually check the path before you make the claim.

After pairing:

“That setup step was missing. I’ve added it to the doc. Thanks for spotting it.”

Make the answer reusable so it isn’t trapped in a private chat, and credit the person who asked as well as the person who answered. A question that improves the docs is a contribution.

⛰️ One thing this week

What can we make easier for the next teammate?

Four hand-drawn steps rising left to right: ask with context, own the next step, verify what you share, leave a clearer path. A stick figure starts on the first step; at the top a flag and a cheering stick figure labelled next teammate.

Pick one small repair this week: a setup step, a flaky test, a tool description, a missing explanation. And thank the person who helps you make it. 🙌

New joiners can contribute just by naming the step that confused them. They shouldn’t have to fix the whole onboarding experience on their own. That part’s on the rest of us.


Fin.

Comments

    Supports `code`, ```blocks```, **bold**, *italics* and links.

    Keep reading