📎 Sharing Files and Snippets From Slack Ops Bots the Right Way

For a long time my bots dumped log output straight into channel messages, and it was awful. A 200-line stack trace turned a thread into a scroll-wheel workout, Block Kit truncated it, and nobody could grep it. The right tool was a file upload — attach the log as a snippet, keep the message short, let people expand or download it. The catch is that Slack changed how uploads work, and the old files.upload method everyone copy-pastes from Stack Overflow is deprecated. The current flow is three steps, and if you don’t know that, you waste an afternoon debugging a method that no longer exists.

I sorted this out with AI help, and file uploads are a sharp reminder that AI is a fast junior engineer: ask it to “upload a file to Slack” and there’s a real chance it hands you the deprecated single-call API from its training data, confidently. A human verifies the API is current and that nothing sensitive is in the file before it ships. The model is fast; you make sure it’s not fast and wrong.

The current upload flow is three steps

The modern path is files.getUploadURLExternal → upload the bytes to the returned URL → files.completeUploadExternal to share it. The SDK wraps this in client.files.uploadV2, which is what you should actually call:

await client.files.uploadV2({
  channel_id: channelId,
  filename: 'deploy.log',
  content: logText,                 // or `file`/`fileUploads` for buffers
  initial_comment: 'Full deploy log attached.',
  snippet_type: 'text',
});

If you call files.upload directly, you’re on a deprecated method. Use uploadV2, or wire the three raw calls yourself if you need fine control. Verify this against current docs — file APIs are exactly the kind of thing that shifts under you.

Snippets vs. files

For text — logs, diffs, YAML — use a snippet so Slack renders it inline with syntax-aware formatting and a download button. Set snippet_type to hint the language:

await client.files.uploadV2({
  channel_id,
  filename: 'plan.tf',
  content: terraformPlan,
  snippet_type: 'text',
  initial_comment: '`terraform plan` output for review',
});

For binaries — flame graphs, screenshots, exported reports — upload the bytes via file (a buffer or stream) instead of content.

Pro Tip: initial_comment is the message that announces the file, and it’s a normal channel message — so the same visibility rules apply. In an externally shared channel, that file is visible to the partner org. Gate file uploads on channel sharedness just like any other sensitive output.

Redact before you upload — always

This is the part AI will skip every time. A deploy log contains hostnames, sometimes tokens, sometimes a connection string someone logged by accident. Upload it raw and you’ve leaked it into searchable, downloadable channel history. Run a redaction pass before the upload, never after:

function redact(text) {
  return text
    .replace(/(xox[baprs]-[A-Za-z0-9-]+)/g, '[slack-token]')
    .replace(/(AKIA[0-9A-Z]{16})/g, '[aws-key]')
    .replace(/(postgres|mysql):\/\/[^\s]+/g, '[db-url]')
    .replace(/Bearer\s+[A-Za-z0-9._-]+/g, 'Bearer [redacted]');
}

await client.files.uploadV2({ channel_id, filename: 'app.log',
  content: redact(rawLog), snippet_type: 'text' });

Redaction regexes are necessary but not sufficient — they catch the patterns you anticipated. Treat the log as untrusted and review what your bot uploads, especially the first time it runs against real output.

Threading files into the right place

Attach the file to a thread, not the channel root, when it belongs to an ongoing incident. Pass thread_ts so the log lands under the incident message instead of starting a new conversation:

await client.files.uploadV2({
  channel_id, thread_ts: incidentTs,
  filename: 'timeline.txt', content: redact(timeline),
});

This keeps incident artifacts together, which your future self writing the postmortem will thank you for. It composes with your incident response dashboard, where the same artifacts can be linked from the system of record.

Where AI helps, where you don’t trust it

The model is good at writing the upload glue, the redaction regexes (as a starting point), and the threading logic. I scaffold with Claude or Cursor and refine prompts in the prompt workspace. But two things stay firmly human: confirming the API method is current (not the deprecated one the model remembers) and owning the redaction policy. Never paste a real log full of secrets into the model to “help it write the regex” — describe the patterns instead. And verify request signatures on whatever endpoint triggers the upload, because file-sharing bots are a tempting target.

Conclusion

Stop dumping logs into messages — upload them as snippets and files so they’re readable, searchable, and downloadable. Use the current uploadV2 flow (not the deprecated files.upload), redact before you send, thread files into the incidents they belong to, and respect channel visibility. Let AI write the plumbing fast while a human confirms the API is current and the content is safe. More in the Slack category, and ready-made prompts to scaffold the upload code.