Slack as spec

This after­noon I had a Slack DM with a team lead about how we cal­cu­late a KPI for next month. Normal back-and-forth — infor­mal, idiomatic, inter­nal jargon, the kind of thread where two people who share three years of con­text resolve a real method­ol­ogy ques­tion in twenty minutes. She made the call. We agreed on the statuses. We agreed on the cutoff logic. The thread ended with “ok, let’s do it this way.”

Forty min­utes later I sat down in front of Claude Code and typed one line into a small skill I wrote called slack-get:

Claude Code
/slack-get my today's convo with nata on kpi improvements

Three seconds. The agent had the full tran­script of our DM ren­dered as AI-readable Markdown, had sum­ma­rized the deci­sions back to me, and was ready for the next instruction. I gave it one: “Load the KPI files from the repo and the cur­rent month’s snapshot.” It did. From then on, the Slack thread was the spec. No Linear ticket. No PRD. No re-explanation.

Writing a real spec for that change from scratch would have been twenty min­utes of typing and at least one round of “wait, what did we decide about returns?” The con­ver­sa­tion already had every­thing in it. It just needed a reader.

I want to give this pat­tern a handle: Slack-as-Spec. The con­ver­sa­tion isn’t a pre­cur­sor to the spec. It is the spec — once some­thing can read it.

The standard pitch is to put an agent in the room

The stan­dard pitch is: bring an agent into the conversation. Put it in your Slack channel. Give it a seat at the meeting. Make it a participant. A whole prod­uct cat­e­gory is built around this — meeting-summarizing bots, Slack-resident agents, “AI teammates.”

I’m not saying this never works. I’m saying the mechan­ics are uglier than the pitch admits. To “have an agent in the room” for the con­ver­sa­tion I had today, we’d have had to do one of three things: move out of our DM into a chan­nel where a bot can live, @mention a bot in the spe­cific threads we wanted it to see, or copy-paste frag­ments of the chat into a sep­a­rate con­ver­sa­tion with the bot afterwards. Each of those is a small tax. None of them are free.

And once you’re paying that tax, the second-order effect kicks in: people start writ­ing for the bot. They san­i­tize jargon. They explain things they wouldn’t nor­mally explain. The con­ver­sa­tion slows down. The medium loses what made it useful — the speed, the short­hand, the trust. My DM with Nata works because we don’t trans­late for anyone; pull a bot in and we’d be explain­ing our­selves at the agent, three times as slow, for a worse decision.

The Slack-as-Spec alternative

The alter­na­tive: humans con­verse in their nat­ural medium, at their nat­ural pace, with their nat­ural vocabulary. Then, when it’s time to exe­cute, the tran­script becomes the brief.

The agent is a reader of artifacts that humans already produced for human reasons, not a participant in conversations that humans had to perform for the agent’s benefit.

This decou­ples two cog­ni­tive styles that resist shar­ing a room:

Forcing both into the same medium — either “every­one talks like the agent prefers” or “the agent tries to follow real human chat­ter live” — pro­duces fric­tion in both directions. Separating them pro­duces neither.

What makes the seam invisible

This works in prac­tice, not just in theory, because the bridge between the two modes has to be near-zero effort. If I had to copy-paste a Slack thread, strip the noise, paste it into Claude, and then re-explain who’s who and what we agreed on, I’d just write a spec from scratch and skip the transcript. The tran­script becomes the spec only if load­ing it costs almost nothing.

slack-get is unre­mark­able as code — it takes a fuzzy descrip­tion, resolves the chan­nel or DM, expands thread replies, for­mats every­thing as AI-ready Markdown. Its role mat­ters: it’s the seam between two media, and it has to be quiet enough that you forget it’s there. The moment you notice the seam, you start avoid­ing the workflow.

When this breaks

The obvi­ous fail­ure mode is dis­trib­uted deci­sions — when a call gets half-made in a DM, half in a chan­nel, half in a Zoom you didn’t record. There’s no single tran­script for slack-get to grab. For those I reach for a dif­fer­ent skill, slack-weekly-review, which pulls a week’s worth of my con­ver­sa­tions across the entire work­space and cross-references them with what I’ve been doing else­where (Linear, GitHub repos, PKM). Different tool, dif­fer­ent trade-offs.

So Slack-as-Spec isn’t a work­flow for every decision. It’s a work­flow for the threads where two people who share con­text closed some­thing out.

Hypothesis

My cur­rent bet is that the more durable pat­tern for AI in team work­flows is the agent as reader of arti­facts humans already pro­duced for human rea­sons, not the agent as participant.

Human-to-human medium stays human-to-human, the agent reads what already exists, the team’s nat­ural com­mu­ni­ca­tion keeps its shape; nobody re-engineers it for the model. The cheap­est spec you can write is the one you wrote with­out real­iz­ing you were writ­ing it.