Async Video Is Just a Slower Meeting

Loom and Claap are growing. The pitch: skip the meeting, send a video, let people watch when they have time.

I've watched this framing become consensus. It's wrong in a specific way.

What async video does and doesn't solve

A synchronous meeting has two costs: everyone has to be available at the same time, and the meeting runs at the pace of the slowest participant.

Async video solves the first cost. It does not solve the second.

A 15-minute Loom is still 15 minutes of someone's time to watch. If the information in it is "here's what's blocked, here's the decision I need," the recipient still has to watch 15 minutes to get to the 90-second piece that matters. Async video removes the scheduling requirement. It doesn't remove the consumption cost.

The deeper problem it doesn't solve: the information in an async video is produced by a human, manually, at a point in time when that human has decided to produce it. That information could have been produced by the system automatically.

What the coordination problem actually is

I built Ordia because of a specific, concrete problem: every morning I opened Jira, GitHub, and Slack separately and manually constructed a picture of what was blocked and what wasn't. The information existed in all three tools. None of them knew about the others. I was the integration layer.

That reconstruction took 30–45 minutes. It was not optional — decisions depended on knowing the state of the system. And it was entirely manual.

The solution wasn't async video. Replacing that 30-minute manual process with a 15-minute Loom someone records at the end of the day would be an improvement in that I'd be interrupting my morning less. It would not address the structural problem: a human doing work a system should do.

The ritual optimization trap

Teams adopt tools that change the interface to existing workflows without changing the underlying structure. The standup becomes a Loom. The Loom becomes an AI-summarized Loom. The information is still produced by a human, reviewed by a human, and requires a human interpretation step.

This is automating the ritual, not the problem.

The ritual exists because the system doesn't produce the status automatically. The standup exists because nobody knows the state of the work without asking. Async video makes asking cheaper. It doesn't make asking unnecessary.

Asking becomes unnecessary when the system knows its own state and presents it legibly without human intervention.

What async-first actually means

Async-first isn't about the medium. It's about where the information originates.

In a truly async-first workflow: a PR's state is visible without asking. Blockers surface automatically from ticket dependencies. The team's attention is drawn to the things that need it, by the system, not by the person who noticed the thing and sent a Loom about it.

This is not 85% achieved by switching from Zoom to Loom. It's achieved when the tools that hold the work state — the issue tracker, the code repository, the deployment pipeline — know about each other and present a coherent picture without a human synthesizing between them.

The human synthesis step is the bottleneck. Async video moves the synthesis to a recording instead of a meeting. It's a lower-bandwidth synthesis. The bottleneck is still there.

What actually shifts the constraint

The tools to automate the information layer exist. GitHub Actions with webhook integrations, n8n for workflow automation, purpose-built coordination layers — the technical components to eliminate the human-as-integration-layer are available and not expensive.

What doesn't happen automatically is the design decision to treat coordination overhead as a system problem rather than a communication preference.

Teams that adopt Loom are making a communication preference change. Teams that wire their issue tracker to their code repository to their deployment status are making a structural change. The second is harder to set up. It's also the only one that removes the human synthesis step entirely.

The Loom still needs someone to watch it and extract what matters. The automated status dashboard doesn't.

The honest case for async video

None of this argues that Loom is useless. Async video is genuinely better than synchronous meetings for knowledge transfer, demos, and design reviews — situations where the content is richer than a status update and the nuance of explanation matters.

The mistake is positioning it as the solution to coordination overhead. It reduces one friction point in the coordination problem. It doesn't solve the structural issue of humans doing work that systems should do.

The productivity gain from replacing synchronous meetings with async video is real — scheduling overhead is real overhead. What it doesn't touch is the human labor cost of status production and synthesis.

That's still there. It's just recorded now.