Five Minutes

A real email. A real response. The full tunnel cycle, start to finish.

← All posts

This morning I used the Tunnel to answer a real email from a real colleague about a real engineering decision. Not a demo. Not a hypothetical. An actual piece of work that would have been on my plate today regardless.

Here's what happened.

What arrived

9:57 AM

An email lands. Multi-recipient thread — six people, one CC. The subject line says "Re: Discuss Sandbox 2.0 Engineering Resources." It's a reply to a reply to an original message that included a resourcing plan with three phases.

The email client shows 16 KB. Here's what's actually in there:

Sixteen kilobytes. One question. Twelve words.

Does this reflect net new resources or current allocation?

Drop

9:58 AM

I drag the .eml file from Outlook into a Finder folder on my dock. MailDrop watches that folder. It fires automatically.

What MailDrop does in about one second:

• Parses the .eml with Python's email library. No AI. No cloud. Local.
• Strips the nested reply chain, the signature blocks, the legal disclaimers, the "Sent from my iPhone" footer, the HTML formatting artifacts.
• Extracts From, To, CC, Date, Subject into clean markdown headers.
• Writes one clean .md file to the outbox.

The result:

Clean. Structured. The question is visible. An AI reading this file gets exactly what it needs. No parsing soup, no guessing where the content ends and the disclaimers begin.

Draft

9:59 AM

I hand the clean markdown to Claude. Not by copy-pasting — Claude Code reads the file directly off my filesystem. I say something like: "Read this. I built the automation layer she's asking about. Phase 1 is existing resources — me and one teammate. Phases 2 and 3 are net new. Draft a reply."

Three sentences of direction. That's my entire creative input. But those three sentences contain things Claude cannot know on its own:

• Which phases are existing vs. net new (organizational knowledge)
• That I built the relevant tool (personal context)
• That the tool reduces the headcount the plan would otherwise require (architectural judgment)

Claude drafts a response. Four paragraphs. Answers the question directly, positions the existing automation as reducing the ops burden, supports the colleague who proposed the phased plan, offers to walk through the architecture with the new team. Professional. Accurate. Correctly positioned.

I read it. One pass. It's right. I mark it (g) — glass, meaning AI-generated prose — and the (g) is a hyperlink to the renderer so anyone who sees it can understand what it means.

Send

10:01 AM

I open Outlook. New reply. One line in the body: the thread ID. Attach the .md file. Send.

The email is the envelope. The markdown file is the letter. Anyone on the thread can read the attachment with their eyes. Anyone with an AI can feed it the file. The format works either way.

This is what it looks like:

Four words in the body. The document is the attachment. The subject line carries the thread ID. That's the whole email.

Response

10:40 AM

My colleague replies. She read the attachment. She understood the positioning. She's asking two people on the thread to review the automation tool by next week.

No confusion. No "can you clarify what you meant by..." No follow-up meeting to discuss the email. The structured document did what forty minutes of back-and-forth would have done. One round.

Archive

10:41 AM

Both files — the original email and my response — go into the archive. Organized by date. Indexed in a full-text search database that replaces Outlook search. If anyone asks "what did we decide about Sandbox resourcing?" six months from now, I type one query and the full exchange comes back in seconds. Not buried in an inbox. Not lost in a thread. Filed, indexed, retrievable.

Meanwhile

Here's the part that changes the math completely.

While the tunnel was running — while I was dropping the email, directing the draft, reviewing the response — another Claude Code terminal was open on the left side of my screen. That one was analyzing a Snowflake cost spike for one of my team members. Expensive queries hit a warehouse overnight. Could the work have been done on a smaller warehouse? Were the queries structured efficiently? Should the schedule be changed?

I didn't context-switch between these two tasks. I didn't "put one down and pick the other up." They ran in parallel. Two terminals, two problems, two AIs working simultaneously. I glanced left, reviewed a cost breakdown, said "check the warehouse size against the query profile." Glanced right, reviewed the tunnel draft, said "send it." Back to the left.

This is not multitasking the way people normally use the word. Normal multitasking means doing two things badly by switching between them fast enough to feel productive. This is actual parallelism. Each AI holds its own context. Each one is working on a different problem. I'm not holding any of that context in my head — they are. My job is to look at what they produce, apply judgment, and say go.

Review. Edit. Go. Review. Edit. Go. Two streams. Same five minutes.

The math

Five minutes. Two tasks. The email response was clearer, better structured, and correctly positioned on the first draft. The cost analysis surfaced the warehouse sizing problem and recommended a schedule change. I didn't rewrite either one. I reviewed, edited, and said go.

What I actually did

Let me be precise, because this matters:

• Judgment calls (me): Which phases are existing vs. net new. That the automation reduces headcount. That I should support the transition to another team's ownership. That the tone should be helpful, not territorial. Whether the cost spike was a sizing problem or a query problem. What to recommend to my team member.
• Production work (Claude): Drafting four paragraphs of professional prose from three sentences of direction. Analyzing warehouse query history and compute costs. Getting the structure right. Getting the tone right. Not over-explaining.

I spent my five minutes on the parts only I can do — the organizational knowledge, the political positioning, the judgment, the team guidance. Two AIs spent their seconds on the parts I shouldn't have to — the drafting, the analysis, the formatting, the professional polish.

That's the division of labor. That's the tunnel. That's the protocol. And the protocol runs in parallel.

What this means for tomorrow morning

I have twenty emails like this every day. Status requests. Resourcing questions. Architecture reviews. Proposals to respond to. If each one takes 25 minutes the old way, that's eight hours — a full day, gone, just answering email. Add the ad-hoc analysis requests from my team and it's twelve.

At five minutes each, with tasks running in parallel, the same workload compresses into under two hours. I get the rest of the day back for the work the emails are about.

This is not a productivity hack. This is not "email tips." This is a structural change in how knowledge workers spend their time. The tunnel doesn't make email faster. It makes email a solved problem. The parallel terminals don't make analysis faster. They make analysis something you supervise instead of something you perform. Your job becomes the thing it was always supposed to be — thinking, deciding, and directing — not typing, formatting, and context-switching.

Every pattern is this

The tunnel you just watched is one of four meeting replacements. All four work exactly the same way — a markdown file attached to an email. The only thing that changes is who sends to whom.

• Tunnel — point to point. You send, they reply. The email thread you just saw.
• Pulse — fan-in. Everyone sends their status to one person. That person's AI synthesizes a morning brief from all the attachments. Replaces the standup.
• Forge — fan-in, blind. Everyone submits ideas to the initiator. Nobody sees anyone else's submission until the deadline. The initiator's AI clusters, compares, and surfaces outliers. Replaces the brainstorm.
• Senate — token ring. Position statements circulate. Each person reads the previous positions, responds, and passes it on. Rounds continue until consensus or named dissent. Replaces the decision meeting.

Same envelope. Same attachment. Same four-word email body. The markdown file inside tells any AI what pattern it's looking at and what to do with it. If you receive a Forge, Claude reads the instructions block and tells you to submit blind by the deadline. If you receive a Senate, it tells you whose position to respond to and how to cast your vote. The file explains itself.

You don't need the system. You don't need the app. You need one markdown file and one email. The protocol does the rest.

Read how the Tunnel works →

← All posts