How to Use Devin AI with Slack

Official Cognition documentation lists 17 inline Slack keywords and mode switches for Devin AI sessions started with @Devin, including !ask, !fast, !ultra, mute, sleep, and archive [Cognition Devin Docs]. The Slack Marketplace page for Devin covers install basics, a few keywords, and slash commands, but it does not walk through mode stacking, private status notifications, or how teams should store pull request notes, screenshots, and acceptance criteria after the chat thread cools off.

That gap is the reason this guide exists. Search interest around "devin slack" often outruns the longer "devin ai slack" phrasing, yet most public blurbs still stop at "tag @Devin." Production use needs more: every human on the team must link their own Slack identity, mode keywords only work at the start of a message, and chat is a poor long-term store for session artifacts.

The Devin AI Slack app lets teams tag @Devin in channels or threads so Devin can triage issues, answer codebase questions, and open engineering work without leaving Slack. Devin responds in-thread with updates and questions when tagged. Cognition ships it as a native communication connection next to Microsoft Teams, alongside source control (GitHub, GitLab, Bitbucket, Azure DevOps) and project tools (Jira, Linear). Slack is the intake and status surface. Source control is where code lands. Your team still needs somewhere durable for specs, design dumps, and review notes that do not belong in git or in a scroll of thread replies.

This guide stays close to official setup and usage steps:

1. Connect Slack from Devin settings and link each individual user
2. Tag @Devin (with optional attachments) to start a session
3. Use inline keywords for ask-only answers, mode switches, mute, and archive
4. Enable private Slack notifications on important runs
5. Keep a dedicated channel for shared runs
6. Move session artifacts into a shared workspace humans can search later

If you only need the short answer: open Settings → Connections → Slack, click Connect, install the Devin app, link your user, then tag @Devin with a clear task. The rest of this article is the production version of that path.

You connect from the Devin side. Official install is five steps, and the easy one to skip is individual user linking.

Install steps

1. In your Devin account at app.devin.ai, open Settings → Connections → Slack (the docs path may also appear as Settings → Integrations → Slack) and click Connect.
2. Install the Devin app for Slack in your workspace when prompted.
3. Link your individual user. Every person in the organization who will summon Devin needs to complete this step.
4. Confirm the email on your Slack identity matches the email on app.devin.ai/settings. Mismatched emails are a common reason "Connect" appears to work while @Devin does nothing for that person.
5. Tag @Devin in any channel to start a session.

After connect, you can start work in channels, threads, or DMs where the bot is present. Marketplace install is available for admins who prefer the Slack Marketplace listing, but Cognition's documented path still runs through Devin settings so user linking is not missed.

What "connected" actually means

Once the app is live and your user is linked, Devin can:

• Start sessions when tagged with @Devin
• Reply in the same thread with progress and questions
• Read thread history for context when launched mid-conversation
• Accept file attachments on the message that starts or continues a run
• Send private status DMs when you enable notifications on a run
• React with emoji to mark completed or failed work

Official permission docs explain why the bot asks for message history, file read/write, IM write, and user email read: Devin matches Slack users to Devin users by email, needs thread context for mid-thread launches, and needs file scopes for attachments.

Devin does not replace your engineering process. Branch protection, code review, and merge rules still live on the source-control side. Slack is the conversation spine. Devin is the agent that can take a well-scoped request and push toward a PR.

Slack plan note

Official docs draw a clean line between surfaces. The AI assistant sidebar experience (app container) requires a paid Slack plan. Tagging @Devin in channels and threads, /ask-devin, /dana, and message shortcuts work on any Slack plan, including free workspaces. If your team is on free Slack, skip the app-container path and use channel tags and slash commands.

Once the app is installed and your user is linked, usage is mostly conversational. Precision still matters.

Start a session Tag Devin with a concrete task:

@Devin fix the login redirect that fails when the session cookie is missing

You may attach files to the message. Devin responds in-thread. From there, keep talking in the same thread the way you would in the Devin web chat. Cognition's own docs warn that Devin can make mistakes, so treat answers and diffs as work that still needs human review.

Marketplace and docs both surface a second path for questions that do not need a full agent run: start with @Devin !ask (or the /ask-devin slash command) for a quick codebase answer.

Inline keywords (snippet table)

Official docs document these keywords. Mode keywords (!fast, !lite, !ultra, !fusion, !swe, !normal) and !new only count when they appear at the beginning of the message, right after the @Devin mention. They can be stacked. A keyword buried mid-sentence is ignored. Sending a mode keyword in an active Devin thread switches that session's mode mid-run.

Stacked example:

@Devin !ultra !new reproduce the flaky checkout test and open a PR with a fix

Human-side thread comment that Devin should ignore:

(aside) I already checked staging; the bug only shows on prod with feature flag X

Slash commands and shortcuts

The Marketplace listing also documents:

• /ask-devin [question] for codebase questions
• /dana [prompt] for Dana sessions
• A "Create a new session" shortcut and message shortcut

Prefer keywords and slash commands that match the job. Full agent runs cost more context and quota than !ask answers. Dana is for data work, not for generic code edits.

Practical prompt patterns

Weak:

@Devin look at this

Stronger:

@Devin !fast the 500 on POST /api/checkout started after PR #1842. Error: "cart_id null". Open a PR with a regression test.

Include the error string, the suspected change set, acceptance criteria, and whether you want a plan only or a PR. If the thread already has the bug report, say so and tag Devin so it can read prior messages.

Keep Devin session files where the team can find them

Use Fast.io workspaces with Intelligence Mode, version history, and MCP access so artifacts from @Devin runs stay searchable after the Slack thread ends. Every org starts with a 14-day free trial.

Start 14-Day Trial

Marketplace blurbs almost never cover notification setup. Official docs do, and it is one of the higher-value defaults for busy teams.

Private status notifications

On any run, open the menu at the top of the session and click Enable Slack notifications. Devin then privately messages you on status updates. Use this when you kick off long Ultra Mode work and walk away, or when a run is waiting on an answer you do not want buried in a busy channel.

Notifications are per-run and personal. They do not replace the public thread for teammates who need to see progress. They reduce the "did Devin finish?" tab-checking loop for the person who owns the session.

Dedicated channel pattern

Cognition recommends a shared channel such as #devin-runs so agent work is discoverable. That channel becomes a living catalog of prompts that worked, failure modes the team has already hit, and examples juniors can copy. Keep production incident chatter in incident channels; use the dedicated Devin channel for deliberate agent sessions so mute/aside hygiene stays clean.

Operating rules that prevent chaos:

• One primary human owner per run, even if others watch
• Use (aside) or !aside for human-only comments inside the thread
• mute when the thread turns into design debate Devin should not treat as instructions
• archive or EXIT when the PR is up or the task is abandoned so quota and attention stop leaking
• Prefer !ask for "where is X implemented?" so you do not burn a full session on a lookup

Renaming the bot

If @Devin collides with an internal name or culture, rename the bot user in Slack: Workspace Admin → Configure apps → Installed Apps → Devin → App Details → Configuration → Bot User. The mention string follows the bot name you set. Document the new mention for the team so people do not keep typing a dead name.

Permissions worth knowing

Official permission rationales matter when security reviews the app:

• History scopes let Devin read prior thread messages when launched mid-conversation
• File scopes cover attachments in both directions
• IM scopes power private notification DMs
• User email read is how Slack identities map to Devin accounts

If attachments fail, re-check that the app still has files:read / files:write and that the file was attached to a message Devin can see. If only one person can summon Devin, that person is usually the only one who finished individual user linking, or the only one whose Slack email matches Devin.

Chat is a weak archive. Threads scroll, permissions follow channel membership, and PR descriptions rarely hold the full trail of prompts, failing screenshots, and acceptance notes. After Devin works from Slack, decide where durable artifacts go before the thread ages out.

Common storage options

Teams usually try one of these first:

• Local folders or a shared drive next to the repo checkout: fine for a solo spike, weak for multi-person review and agent re-entry
• Object storage (S3 or similar) for large logs and dumps: strong durability, weak collaboration UX
• Google Drive or Dropbox: familiar sharing links, weak agent-native access and semantic search unless you build extra tooling
• The git repo itself: right place for code and tests, wrong place for transient screenshots, customer redacted logs, and half-written acceptance checklists

Those options all work for narrow cases. They break down when an agent produces files and a human two time zones away needs the same bundle with permissions, version history, and search that does not depend on who was in the Slack channel.

A practical handoff pattern around Devin AI

Treat Slack as the control surface and a shared workspace as the artifact surface:

1. Kick off the session in Slack with @Devin and a scoped prompt (mode keyword if needed).
2. When Devin produces notes, patches context, screenshots, or exportable outputs, store the human-facing bundle in a durable location outside the thread.
3. Put the PR URL, session link, and workspace path in the thread summary so late joiners can catch up without rereading fifty replies.
4. When the run is done, archive or EXIT so the agent is not still listening to unrelated chatter.

Fast.io fits this pattern as an intelligent workspace for agentic teams: org-owned workspaces, per-file version history, granular permissions, and an append-only audit log. Enable Intelligence Mode so files are indexed for hybrid search (full-text, semantic, and metadata). Humans use the UI; agents can use the Fast.io API or MCP server over Streamable HTTP at /mcp (legacy SSE at /sse). See mcp.fast.io/skill.md for the current tool surface. Ownership transfer lets an agent prepare structure and hand the workspace to a human while keeping admin access when that model fits your process.

Plans are Starter at $29/mo, Business at $99/mo, and Growth at $299/mo. Every org starts with a 14-day free trial that requires a credit card. Creating a user account alone is not enough for production work; real usage runs under a paid organization subscription.

For structured extraction from PDFs, invoices, or design PDFs that arrive as Slack attachments, Metadata Views turn documents into a queryable table with fields you describe in natural language. That is separate from Intelligence Mode: Intelligence is search and chat over content; Metadata Views is the structured extraction layer.

Example end-to-end flow

1. In #devin-runs, someone posts: @Devin !fast customers on plan "growth" cannot download invoices after the billing refactor. Repro steps in the thread. Open a PR.
2. Devin works in-thread, asks one clarifying question, then opens a PR on the connected git host.
3. The owner drops failing response payloads and the acceptance checklist into a Fast.io workspace folder for that incident, enables Intelligence if it is not already on, and pastes the workspace link plus PR URL back into Slack.
4. A reviewer who was offline opens the workspace, searches for "invoice download", checks the checklist, and reviews the PR without digging through mute/aside noise.
5. The owner archives the session when the PR merges.

Devin remains the coding agent. Slack remains the coordination channel. The workspace is where files stay useful after the emoji reaction says the run finished.

When @Devin is silent or sessions feel wrong, work the short list below before you reinstall the app.

Common failures

Bot never responds for one user: That user has not linked their individual Slack identity, or Slack email ≠ Devin settings email.

• Mode keyword ignored: The keyword was not at the start of the message after @Devin, or it was buried mid-sentence.
• Devin reacts to human design debate: Use (aside) / !aside, or mute until you are ready to give instructions again.
• Attachments missing: Confirm file permissions and that the file is on a message in a conversation Devin can read.
• App container features missing on free Slack: Expected. Use channel @Devin tags, /ask-devin, /dana, and message shortcuts instead.
• Quota burn on simple questions: Prefer !ask or /ask-devin over a full Ultra Mode session.

Devin plan context

Devin's own pricing is separate from Slack's. Public plans on devin.ai/pricing include Free, Pro ($20/month), Max ($200/month), Teams ($80/month base plus per-seat pricing), and Enterprise (contact sales). Cloud agent access and higher quotas sit on paid tiers. Check current plan details before you assume every seat in your Slack workspace has the same Devin capacity.

When not to use Slack as the primary surface

Use the Devin web or desktop UI when you need a longer interactive session with heavy multi-file context that is awkward to steer in a noisy channel. Use Slack when work starts from a conversation the whole team already sees: bug reports, customer escalations, and "can someone look at this?" threads. The best teams use both, with a shared workspace for anything that must outlive either UI.

For agent onboarding text and MCP entry points, see fast.io/llms.txt and mcp.fast.io. For Fast.io plan details, see /pricing/.