Remote Work

Remote work doesn't change the principles of good product development. Balanced teams, short iterations, pairing, and user-centered design all work remotely. They just require more intentional design -- the things that happen naturally in a shared office need deliberate structure when the team is distributed.

Five rules for remote leadership

1. Write first, not speak first

Default to written communication for decisions, context, and updates. Writing creates a searchable record, includes people across time zones, and forces clarity of thought.

• Strategy, priorities, and decisions go in shared docs -- not just verbal announcements
• Meeting outcomes are documented and shared -- if it wasn't written down, it didn't happen

2. Default to trust

Remote work makes it impossible to see what everyone is doing all day. That's fine. Focus on results, not hours. If the team is shipping working software every week and hitting iteration goals, the process is working.

• Avoid surveillance tools or "always-on" camera requirements
• Judge by outcomes: stories completed, demos delivered, blockers resolved

3. Over-communicate

In an office, context leaks through overheard conversations and hallway chats. Remote teams don't get that. Compensate by sharing more:

• Post standup notes in the team channel even if everyone attended
• Share context that might seem obvious -- it probably isn't obvious to everyone

4. Be intentional about social connection

Remote teams don't build relationships by accident. Create space for non-work interaction:

• Informal check-ins at the start of standups (1-2 minutes)
• Optional social time -- virtual coffee, end-of-week hangout
• Celebrate wins visibly. A message about a good demo goes further than you think

5. Have hard conversations quickly

Conflict festers faster when people can't read body language. If something is off, address it directly -- a quick video call beats a long message thread.

Adapting ceremonies for remote

Ceremony	Remote adjustment
Standup	Camera on (builds connection). Keep to 15 min. Post notes in team channel after. For cross-timezone teams, consider async standup via written post
Iteration planning	Use a shared board for real-time collaboration. Share the backlog on screen. Allow extra time for questions -- remote planning runs ~10-15 min longer
Demo	Screen share working software. Record the demo for anyone who can't attend. Encourage stakeholders to react in chat
Retrospective	Use a shared board for silent writing. Anonymous input can help with psychological safety. Rotate facilitators
Pairing	Use dedicated pairing tools (Tuple, Pop, VS Code Live Share) -- not just screen sharing. Take breaks every 45-60 min

Trust as infrastructure

Trust is what makes remote work function. Without it, teams compensate with surveillance, micromanagement, and excessive meetings -- all of which reduce productivity.

Build trust by:

• Focusing on results, not hours -- track iteration velocity and story completion, not keystrokes
• Granting autonomy -- let people organize their own work within the iteration commitment
• Maintaining psychological safety -- retros should surface honest feedback without fear
• Establishing clear accountability -- everyone knows what they committed to and follows through

Common pitfalls

• Meeting overload -- remote teams compensate for lack of presence with too many meetings. Default to async; meet only when discussion is needed
• Invisible blockers -- in an office, you can see when someone is stuck. Remote, you have to say it. Normalize asking for help early
• Time zone tyranny -- don't schedule all ceremonies in one time zone's prime hours. Rotate or find overlap windows
• Assuming co-location norms -- "just walk over and ask" doesn't work. Build async-first habits

Try this today

Audit your team's meeting load for this week. For each meeting, ask: could this have been a written update instead? Cancel one meeting and replace it with a shared doc. See what happens to the team's energy and output.