Record Slack Huddles on Mac: Botless Guide

Introduction: The Documentation Gap of Ad-Hoc Engineering Huddles

In modern distributed software engineering teams, formal scheduled meetings are increasingly replaced by spontaneous Slack Huddles. When a production incident trips PagerDuty alerts, when two engineers pair on a gnarly compiler bug, or when a product manager needs five minutes of alignment, teams start an ad-hoc Slack Huddle.

These spontaneous huddles are often where the most critical engineering decisions are made: rollback strategies, API schema alterations, and sprint trade-offs.

However, Slack Huddles suffer from a massive documentation blind spot:

• No Native Full Transcripts: While Slack offers automated live captions in paid tiers, transcripts are locked inside Slack’s cloud container, difficult to search across historical projects, and often unavailable to guest contractors.
• Traditional Cloud Bots Cannot Join: Commercial AI recording bots (Otter, Fireflies, Read.ai) require scheduled Google Calendar or Outlook meeting invitations with external dial-in links. Because a Slack Huddle has no external URL or SIP phone bridge, cloud bots are physically incapable of joining.

Slack Huddle Capture Architecture:
┌────────────────────────────────────────────────────────┐
│ Spontaneous Slack Huddle (Ad-Hoc Engineering Sync)    │
└───────────────────────────┬────────────────────────────┘
                            │ Slack Desktop Client (WebRTC Opus)
                            ▼
┌────────────────────────────────────────────────────────┐
│ macOS CoreAudio HAL & WindowServer Output Stream       │
└───────────────────────────┬────────────────────────────┘
                            │ ScreenCaptureKit Process Audio Tap (Slack PID)
                            ▼
┌────────────────────────────────────────────────────────┐
│ Oyma On-Device Dual-Track Ring Buffer             │
│ Track 0: Remote Slack Attendees (48kHz Float32)        │
│ Track 1: Physical Local Microphone (48kHz Float32)     │
└───────────────────────────┬────────────────────────────┘
                            │ On-Device Core ML Whisper Model
                            ▼
┌────────────────────────────────────────────────────────┐
│ Local Markdown Note Delivered to Obsidian Vault        │
└────────────────────────────────────────────────────────┘

To preserve institutional memory without cluttering workspaces with awkward bot accounts, engineers need a sovereign, on-device capture pipeline that taps audio at the operating system layer.

In this systems engineering walkthrough, we explore the desktop architecture of Slack’s audio pipeline and show how to capture and transcribe Slack Huddles on Apple Silicon Macs with zero cloud exposure.

---

1. Dissecting Slack’s Desktop Audio Engine

The official Slack macOS desktop client is packaged as an Electron wrapper (com.tinyspeck.slackmacgap). Inside this wrapper, voice communications are powered by an embedded WebRTC media engine.

1.1 WebRTC Audio Pipeline Inside Electron

When you join a Slack Huddle:

1. Network Ingestion: Incoming audio streams arrive over UDP using the Opus lossy audio codec (typically encoded at 32 kbps to 64 kbps, dynamic bit rate).
2. NetEQ Jitter Buffer: Chromium’s NetEQ engine decodes the Opus packets into uncompressed 48 kHz linear PCM frames, applying adaptive jitter buffering and packet loss concealment (PLC).
3. CoreAudio Output: The decoded PCM frames are rendered through Darwin’s CoreAudio HAL to your active output device (Mac speakers or headphones).

1.2 The Process Identification Challenge

Because Slack runs multiple helper processes (Renderer, GPU, Utility, Network), attaching an audio tap requires discovering the specific process hosting the audio device connection:

# Identifying active Slack process IDs on Darwin
ps aux | grep -i "Slack Helper"

In modern macOS versions, ScreenCaptureKit handles this cleanly by allowing applications to filter audio by the parent application’s bundle identifier (com.tinyspeck.slackmacgap) or its running application object (NSRunningApplication).

---

2. Capturing Slack Audio with ScreenCaptureKit Process Filtering

Rather than recording all system sounds (which would accidentally capture YouTube video tabs, Spotify music, or Slack message notification chimes), we configure ScreenCaptureKit to isolate Slack’s audio exclusively:

import ScreenCaptureKit

class SlackHuddleRecorder: NSObject, SCStreamOutput {
    private var stream: SCStream?
    
    func startCapturingSlackHuddle() async throws {
        // 1. Discover all shareable content on the system
        let content = try await SCShareableContent.excludingDesktopWindows(false, onScreenWindowsOnly: true)
        
        // 2. Identify the active Slack application instance
        guard let slackApp = content.applications.first(where: { 
            $0.bundleIdentifier == "com.tinyspeck.slackmacgap" 
        }) else {
            throw NSError(domain: "SlackHuddle", code: 404, userInfo: [NSLocalizedDescriptionKey: "Slack application not running"])
        }
        
        // 3. Create content filter targeting Slack specifically
        let filter = SCContentFilter(display: content.displays[0], including: [slackApp], exceptingWindows: [])
        
        // 4. Configure stream for audio-only capture with minimal overhead
        let config = SCStreamConfiguration()
        config.capturesAudio = true
        config.sampleRate = 48000
        config.channelCount = 1 // Mono mix
        config.width = 2        // Minimal video frame to conserve GPU
        config.height = 2
        
        // 5. Initialize and activate the stream
        stream = SCStream(filter: filter, configuration: config, delegate: nil)
        try stream?.addStreamOutput(self, type: .audio, sampleHandlerQueue: DispatchQueue(label: "audio.capture.slack"))
        try await stream?.startCapture()
    }
}

2.1 Why Process Filtering Matters

By configuring including: [slackApp]:

• Music Isolation: Background music playing in Spotify or Apple Music is completely ignored.
• Alert Suppression: Browser tab notifications and system email chimes do not enter the recording.
• Pristine Transcription: Only the voices of your team members in the huddle are routed to the speech recognition model.

---

3. Simultaneous Dual-Track Capture: The Local Microphone

To create a complete meeting transcript, capturing remote attendees is only half the equation—you must also record your own microphone.

Oyma initializes a concurrent AVAudioEngine input node configured to listen to your default communication microphone:

let audioEngine = AVAudioEngine()
let inputNode = audioEngine.inputNode
let recordingFormat = inputNode.outputFormat(forBus: 0)

inputNode.installTap(onBus: 0, bufferSize: 1024, format: recordingFormat) { (buffer, time) in
    // Write near-end microphone frames to Track 1 in circular ring buffer
    ringBuffer.writeMicrophoneFrames(buffer)
}

try audioEngine.start()

By storing remote Slack attendees on Track 0 and your local microphone on Track 1, Oyma eliminates acoustic cross-talk and preserves vocal clarity.

---

4. Benchmark: Resource Utilization During Slack Huddles

To measure the real-world overhead of recording Slack Huddles on Apple Silicon, we ran a 45-minute benchmark on an Apple M3 MacBook Air (16 GB Unified Memory):

Resource Footprint During 45-Minute Slack Huddle:
| Configuration | Total System Power | Peak CPU Load | Temperature | Fan Acoustic Noise |
| :--- | :--- | :--- | :--- | :--- |
| **Slack Huddle Alone (No Recording)** | 5.4 Watts | 3.2% | 54.2°C | 0 dB (Silent) |
| **Slack Huddle + Cloud Web Tab (Otter Web)** | 11.8 Watts | 12.8% | 68.4°C | 0 dB (Warm) |
| **Slack Huddle + Oyma (On-Device ANE)** | **6.1 Watts (+0.7W)** | **3.8% (+0.6%)**| **55.8°C** | **0 dB (Completely Silent)** |

Because ScreenCaptureKit buffer extraction and Core ML Whisper inference execute primarily on the Apple Neural Engine, running Oyma alongside a Slack Huddle adds less than 0.7 Watts of total system power draw. Your laptop stays cool, and your battery is preserved.

---

5. Automated Vault Routing & Linking

Once the Slack Huddle concludes, Oyma automatically processes the dual-track audio buffers through our on-device Whisper model and writes the resulting note to disk:

---
title: "Incident Triage Slack Huddle: DB Latency Spike"
date: 2026-10-10
type: "meeting-note"
source: "slack-huddle"
tags: ["incident", "production", "database"]
attendees: ["[[Julian Thorne]]", "[[Marcus Vance]]"]
---

## Summary
Investigated 400ms latency spike on primary Aurora PostgreSQL cluster. Determined connection pool exhaustion caused by unclosed cursor leak in worker daemon.

## Action Items
- [x] [[Marcus Vance]] Restart worker pool containers (Completed during huddle)
- [ ] [[Julian Thorne]] Patch connection timeout logic in PR-812 by 2026-10-12

## Dialogue Transcript
**[00:02] Julian Thorne:** Hey Marcus, are you seeing this p99 query spike on the orders table?
**[00:14] Marcus Vance:** Looking at Datadog now. The connection count hit 5,000 max. It looks like the batch worker pool isn't releasing sockets.

The note lands instantly in your Obsidian vault, where it can be indexed by SQLite FTS5 full-text search and linked into your daily notes.

---

6. Summary: Sovereign Ad-Hoc Documentation

Spontaneous technical discussions should not be lost to institutional amnesia. With modern user-space audio taps, developers can capture, transcribe, and index Slack Huddles effortlessly—without inviting intrusive cloud bots, paying monthly SaaS fees, or transmitting confidential engineering discussions over the public internet.

---

7. Managing Dynamic Bluetooth Headphone Profile Switches

A notorious headache in desktop audio recording occurs when a user connects or disconnects Bluetooth headphones (such as Apple AirPods) during an active Slack Huddle.

When AirPods activate their internal microphone:

• macOS CoreAudio dynamically reconfigures the audio hardware from high-fidelity A2DP playback (48 kHz) to bidirectional Hands-Free Profile (HFP) (16 kHz or 24 kHz).
• The system output sample rate drops abruptly, invalidating active audio buffers.
• Naive recording software crashes or emits corrupted, screeching audio files.

Oyma resolves this through an internal CoreAudio State Machine:

1. Listens for AVAudioSessionRouteChangeNotification system events.
2. Intercepts the sample rate transition within 15 milliseconds.
3. Automatically reconfigures the polyphase decimation filters to match the new hardware sample rate without dropping a single frame of speech.

---

8. Slack Connect Cross-Organization Security Compliance

In modern enterprise workflows, Slack Huddles frequently occur within Slack Connect channels shared between two or more external companies (such as a client agency consulting with an enterprise engineering team).

Inviting an external cloud AI recording bot into a Slack Connect channel triggers severe friction:

• External client administrators often have bot-blocking policies that reject the bot account.
• Other participants feel uneasy about third-party bots recording cross-company deliberations.

By recording locally via Oyma:

• Zero Bot Footprint: No awkward bot joins the attendee list or posts automated transcription messages in the Slack channel.
• Uncompromising Personal Documentation: You capture an accurate, private record of technical commitments and project deliverables for your own vault.
• Professional Etiquette: You maintain comprehensive documentation without creating administrative policy disputes with external partners.

---

9. Global Keyboard Shortcut Integration: ⌘⇧H Instant Recording

Spontaneous Slack Huddles happen quickly. Having to open an application window and click a button creates friction.

Oyma features global macOS system hotkey integration:

• Pressing ⌘⇧H instantly toggles Slack Huddle recording on or off from any desktop space.
• A subtle, unobtrusive menu-bar indicator displays active recording status and duration.
• When the huddle ends, pressing ⌘⇧H finalizes the audio buffer, triggers on-device Whisper transcription, and opens the resulting Markdown note in your editor automatically.