Here is the failure mode that costs more than almost anything else in a distributed team, and it has nothing to do with talent or effort: someone sends a clarifying question with no context attached, to someone nine time zones away, and goes to sleep. The person on the other end reads it in the morning, doesn't have enough information to answer fully, and sends a clarifying question of their own back. That message then sits for most of a day, waiting for the first person to wake up. Two round-trips like that and a problem that a well-written first message could have solved in an hour has eaten most of a week.
Nobody designs this on purpose. It happens because writing a complete, self-contained message takes more effort in the moment than firing off a question and assuming a conversation will follow — and in an office, a conversation does follow, instantly, for free. Remote work removes the free follow-up and quietly keeps charging you for the bare question anyway. Pair this with if remote work sits inside a wider growth programme. Pair this with XenGrowth if remote work sits inside a wider growth programme.
What happens when nobody trains for this
Yang, Holtz and colleagues tracked over 61,000 Microsoft employees through the company's 2020 remote-work mandate and found exactly the shape of damage you'd expect from that gap going untrained at scale. Employees added new collaborators more slowly. They also dropped existing ones more slowly, so the whole network calcified rather than reorganizing around new patterns. Time spent collaborating across group boundaries fell about 25%, and communication shifted from synchronous channels toward async ones — chat and email — even as total meeting hours barely moved. Good async habits are, in effect, the individual-level version of the connective tissue that study found thinning at the organizational level. The kind of documentation discipline advocates for commercial teams solves the identical problem: making sure work is legible to someone who wasn't in the room when it happened.
That study is observational, one company, one abrupt mandate — it can't tell you exactly how much of the 25% drop was bad async habits versus simple loss of incidental contact that no habit fully replaces. What it does establish is the size of the gap that opens up when synchronous glue disappears and nothing deliberate is put in its place. Deliberate async practice is the something.
The clarifying-question-then-wait loop, in detail
Break the failure mode into its parts and the fix becomes obvious, even though almost nobody does it by default. The first message is bare: 'the deploy is failing, any idea why?' It's true, and it's nearly useless to whoever receives it, because it forces them to ask everything the sender already knows and didn't write down — what changed, what the error actually says, what's already been ruled out. approaches this from the the operations side of this side. The XenGrowth resource library approaches this from the the operations side of this side.
Message quality | What the recipient has to do | Round-trips to resolution |
|---|---|---|
Bare question, no context | Ask what changed, ask for the error, ask what's been tried, then finally answer | 3 to 4, each one a full day across a timezone gap |
Question plus error message, no attempted fixes | Ask what's already been tried, then answer | 1 to 2 round-trips |
Full context: what changed, exact error, what was tried and what happened, current hypothesis | Answer directly, or ask one genuinely new question | 0 to 1 round-trips |
It's worth noticing how ordinary the bare version of that first message feels to write. Nobody sends 'the deploy is failing, any idea why?' out of laziness — they send it because in the moment, typing three extra sentences feels like friction, and a live conversation would resolve the whole thing in ninety seconds anyway if the other person were online. The math only looks bad in hindsight, once the day is gone. That's exactly why this has to be a habit rather than a judgment call made fresh each time: in the moment, the judgment call reliably goes the wrong way.
A message that makes the other person ask a question back before they can help you has already cost you the day you were trying to save by not scheduling a call.
The habit that collapses this is almost mechanical: before sending anything, write three things — what you tried, what you expected to happen, and what actually happened instead. That's it. It reads like overkill for a quick question and it isn't, because the alternative isn't a quick answer, it's an asynchronous interrogation spread across days.
Over-communicating context is not the same as over-communicating volume
The instinct against this habit is usually 'I don't want to write an essay for a simple question,' and that instinct is protecting the wrong thing. Volume and context aren't the same axis. A message can be short and complete — three sentences that answer every question the recipient would otherwise have to ask — or long and useless, three paragraphs of narrative that never states what actually broke. The goal is density: everything needed to answer, nothing that isn't.
State what you tried, in the order you tried it — this rules out the recipient suggesting something you already ruled out, which is the single most common wasted round-trip
State what you expected, briefly — this tells the recipient what model you were working from, which is often where the actual misunderstanding lives
State what actually happened, with the exact error text or exact behavior, not a paraphrase — paraphrased errors lose the one detail that would have solved it in one message
State your current best guess, even a weak one — a wrong hypothesis the recipient can correct in five seconds is more useful than no hypothesis at all
Only then ask the actual question, as narrowly as you can phrase it
Habit | What it replaces | Cost of skipping it |
|---|---|---|
Writing tried/expected/actual before asking | The instant back-and-forth a hallway conversation would give you for free | Each skipped round-trip costs roughly a full day across a wide timezone gap |
A quick acknowledgment before a full reply | The visible cue of someone reading a message in real time | Silence reads as ignored, which erodes trust faster than a slower full answer would |
Proactive, no-reply-needed updates | The incidental visibility of being seen working in an office | Good work goes unnoticed by exactly the person deciding what your contribution looks like |
Timestamping updates with real state, not just 'still working on it' | A manager's ability to glance over and gauge progress | Vague updates get treated as no update, and get chased with an interrupting question |
Proactive updates: the async substitute for being seen
A status update nobody asked for looks, from the outside, like busywork — a habit for people who like narrating their own progress. It isn't. In an office, a manager or teammate picks up your state through a dozen free, incidental signals: what's on your screen when they walk past, what you mention at lunch, the tone of your voice in standup. None of that survives being remote, and none of it gets replaced automatically. A timestamped update that doesn't require a reply — 'still working through the auth migration, hit an edge case with expired tokens, expect a PR by tomorrow' — is the async version of that incidental signal, deliberately reconstructed because nothing reconstructs it by accident. Writing for someone who wasn't in the room is the same discipline is built around at the content layer — an answer has to be complete enough to be useful to someone who never talked to the person who wrote it. For the AI agents and marketing automation angle, see . For the AI agents and marketing automation angle, see XenGrowth on AI agents and marketing automation.
This connects directly back to the visibility problem a different post in this cluster covers in full: a manager who can't see your work by default has to reconstruct it from what you choose to write down. A proactive update is one of the few habits that puts good work in front of the person deciding what your contribution looks like, without asking that person to go looking for it.
It's worth separating this from a different, more common complaint: 'my team just doesn't respond fast enough.' Sometimes that's true and a real process problem. Often, on closer look, it's the clarifying-question-then-wait loop wearing a different name — the response felt slow because the first message forced a round-trip that a more complete one wouldn't have needed. Before concluding a teammate is unresponsive, check whether your own last message actually gave them enough to act on without asking you anything back.
And the same failure mode shows up one level up the org chart, not just between individual contributors. A manager who asks a report 'what's the status on X?' with no context about why they're asking, mid-timezone-gap, is running exactly the same bare-question pattern, just with more authority behind it. The fix is identical: state what prompted the question, what you already know, and what specifically you need — a stakeholder update due tomorrow, a decision blocked on this, or just curiosity that can wait for the next scheduled sync. The habit doesn't change direction based on who's asking.
What actually doesn't work
Answering every message instantly, all day — this recreates synchronous availability with worse latency and burns the focus async work is supposed to protect
A 'quick question' sent with none of the context you already have, on the assumption that a fast back-and-forth will follow — it usually won't, not across a timezone gap
Updates that only happen when someone asks — this is reactive, not async competence, and it leaves the same visibility gap the Microsoft data shows opening up by default
Writing everything down except the one detail that actually matters — the exact error, the exact number, the exact line — because it felt too small to mention
None of these habits require a personality change, and none of them are specific to engineering — they're closer to a writing discipline than a soft skill. What makes them worth naming specifically for engineers is that the cost of skipping them is unusually easy to hide: a slow week of clarifying-question loops looks, from a distance, exactly like a hard problem taking a while. It's only visible up close that most of the delay was actually spent waiting for information that should have shipped in the first message. goes further into AI search, GEO and discovery. XenGrowth on AI search, GEO and discovery goes further into AI search, GEO and discovery.
The test for whether any of this has actually become a habit, rather than a thing you know you should do, is what happens on a bad week — tight deadline, something broken, everyone stretched thin. That's precisely when the bare question and the silent disappearance both come back, because they're the lower-effort default under pressure. A habit that only survives on calm weeks isn't the habit yet; a habit that survives a bad week is the one actually worth having, and the only way to get there is doing the more complete version enough times that it stops costing extra effort to reach for.
None of this replaces the case for protecting some genuine synchronous time, which a companion post in this series argues for directly. Async habits are what make the hours outside that protected window actually work, rather than just quietly draining a day at a time across a gap nobody's watching closely enough to notice.
Further reading from XenGrowth
Where this work meets go-to-market
Writing so a stranger can act without asking a follow-up question is the same discipline a distributed revenue team needs for its own handoffs. publishes operator guides built around exactly that kind of documentation-first handoff.
Further reading from XenGrowth
Where this work meets go-to-market
Working on remote work inside a commercial team? publishes operator guides on the revenue side of this work.
Further reading from XenGrowth
The XenGrowth resource library — what you'll learn: how the commercial side of this work is run, across search, automation and revenue operations.
XenGrowth on AI agents and marketing automation — what you'll learn: how the teams who own AI agents and marketing automation plan and measure it.
XenGrowth on AI search, GEO and discovery — what you'll learn: how the teams who own AI search, GEO and discovery plan and measure it.
Where this work meets go-to-market
Working on remote work inside a commercial team? XenGrowth's work on go-to-market systems publishes operator guides on the revenue side of this work.
Three questions about your own habits, then a specific diagnosis of where the gap probably is.
