What I Built Into Claude Inside My Slack

I’ve spent the last few months turning my Slack workspace into the home for an AI agent — my apprentice. Not a chatbot, not a menu of slash commands, but an actual agentic AI that lives in my channels, reads what’s happening, drafts work, and asks before doing anything risky.

This isn’t a how-to. (For that, see the setup guide.) This is a tour of what becomes possible once it’s wired up — the patterns and behaviors I’ve found genuinely useful, not the inner workings of any specific business.

If you’re wondering why you’d put an AI in Slack in the first place, start with Turning Slack Into Your AI Command Center. The short version: most people go to their AI; the better pattern is the AI coming to you.

Per-channel behavior

The first thing I built was making the apprentice behave differently in each channel. A newsletter channel, a podcast-booking channel, a calendar channel, a writing channel — each one has its own brief. The AI knows what voice to use, what files to look at, what tools to reach for, and what to leave alone.

Same model. Different rules per room. You don’t have to re-explain the project every time — the channel is the context.

Brain-dump triage

You know that feeling when your brain is full and you just need to get it all out? “Follow up with that sponsor. Newsletter idea about productivity habits. Maybe a YouTube video on X. Book the flight for next month. Check in with the contractor.”

I have a single channel for that. Paste the wall of text in, walk away. The AI reads it, splits it into discrete items, figures out what kind of thing each one is, and routes each piece to the channel where it belongs. One dump. Everything sorted.

Approval-gated execution

This is the one that makes the rest of it safe.

Reading is fast and quiet. The AI can pull from my notes, search documentation, look up posts, watch the calendar — none of that needs a check-in. But anything that changes the world — sending an email, publishing a post, deleting a file, writing to a database — pauses and asks. I get a Slack message with a preview of what’s about to happen and two buttons: approve or decline.

This pattern uses a feature of agentic frameworks called hooks — small bits of logic that run before and after every tool call. A “before” hook is what intercepts a destructive call and surfaces the approval prompt. For the technical reference, Anthropic’s official hooks documentation walks through every available hook event and how to wire one up.

The result is that I can let the apprentice work fast without ever giving up the steering wheel.

Reactions as commands

An emoji reaction is a one-tap command. A green check marks a task done. A bookmark files it. A specific emoji drops it from the queue. The AI watches reactions on its own messages and on mine, and acts accordingly.

The advantage is speed. On my phone, in line at the airport, I can clear ten items by tapping ten emojis. No typing, no decisions to compose into sentences.

Quiet hours

Approval prompts are great in working hours and terrible at midnight. So I told the apprentice when my evenings start. Between those hours, anything that would normally ping my phone queues silently instead. In the morning, a single batch lands — everything that built up overnight, ready for one pass of approve/decline.

The AI keeps working through the night. I keep my evenings.

Universal search

Type one query and the apprentice searches across notes, files, Slack history, email, and connected docs at the same time. Results come back in one ranked list. The thing I half-remember turns up in seconds, regardless of which app I last touched it in.

This is mostly thanks to the Model Context Protocol (MCP) — an open standard for plugging external tools into an AI agent. With MCP, the agent can talk to your Drive, your email, your Notion, your database, your calendar — whichever ones you opt in.

Calendar, from inside Slack

Schedule a meeting. Look up what’s on Thursday. Move something. Cancel. All from a Slack channel, in plain language. If the meeting involves an external person, the apprentice drafts the invite email and queues it for one-tap send.

Same pattern, different verbs: I never leave the channel.

Direct publishing

Drop an idea in a publishing channel. The apprentice drafts the piece, checks it against my established voice, and queues it to publish. I review and tap approve. The post goes live.

Same shape works for newsletters, social posts, community updates, and short-form content. Idea in. Draft. Approve. Live. The interface is identical across destinations.

Outreach pipelines

Give the apprentice a list of targets — podcasts to pitch, businesses to research, partnerships to explore. It runs the research on each, proposes the strongest options, and drafts personalized messages for the ones I pick. I get a queue of ready-to-send outreach. Each message has its own approve button.

What used to be a spreadsheet, two browser tabs, and an afternoon is now a paste, a coffee, and ten taps.

Self-running maintenance

This part is mostly invisible — and that’s the point.

The system manages its own memory on a schedule. Old logs rotate out. Stale projects get flagged before they become problems. If something breaks overnight, the apprentice recovers, restarts itself, and tells me in the morning what happened. I stopped having to maintain the maintenance.

Recursive improvement loops

Every approval is a signal. Every decline is a sharper one. Every time I move an item the apprentice routed to the wrong place, that correction gets logged.

Once a week, those signals get folded back into the prompts that drive the apprentice. Routing gets more accurate. Drafts get closer to publishable on the first pass. Things I’ve approved 47 times in a row get promoted to auto-allow.

This isn’t model retraining. It’s prompt-and-rules learning, in the open, that I can read and edit. The apprentice gets sharper at my work the longer I use it — without me ever being a machine learning engineer.

Scheduled briefings

At the times I’ve set, briefings land in my Slack:

• A morning brief with everything that needs a decision today
• A nightly progress note — what shipped, what stalled, what’s blocked
• A weekly synthesis on Sunday for portfolio-level decisions
• A longer Saturday note pulling threads across the week

Same structure, every day. I always know where things stand without going looking.

Why it adds up to more than the sum of its parts

Each of these capabilities is useful on its own. The interesting thing is what happens when they stack.

The morning brief surfaces a decision. I tap approve. The approval triggers a draft. The draft routes to the right channel. The channel pings the right tool. The tool publishes. The publish updates a metric. The metric flows into next week’s synthesis. The synthesis shapes next month’s prompts.

None of those steps are dramatic. The whole loop is.

The interface doesn’t change. My Slack still looks like Slack. But the work that used to need fifteen apps and a lot of context-switching now happens in the one place I already keep open. That’s the difference.

---

Why this matters: Turning Slack Into Your AI Command Center. How to build it: How to Set Up Claude in Slack — A Practical Guide.