Every time Devin starts working in Slack, we hand it these instructions:
Silence is your default. You see every message in this channel, and almost none of them are for you. Reply only when you can add something that doesn’t already exist in the thread. A wrong or unnecessary reply costs more than any number of skipped messages, and there is no credit for volume.
Most agents working in Slack can be really annoying, treating a channel like their own command line, driving up both cost and noise. We wanted to make Devin feel like a real teammate in Slack, where many of our customers already get work done.
In a Slack channel, Devin starts off as a guest. The channel existed before it arrived, and most conversations aren’t about it. Becoming a teammate meant learning which messages to notice and which to ignore, what to announce and how, and when to stay out of the way even in threads it’s already involved in.
This post is the story of how we refined Devin’s behavior in Slack over the past year, across prompts, Devin’s harness, and our usage of the Slack API.
Read the Room
There’s an unwritten code to being good at Slack. A good teammate reads the room before speaking. They skim around to get their own bearings, reply in threads instead of creating clutter, and keep an eye on channels they joined. We built Devin to adhere to the same etiquette.
A simple @Devin is often all you need. Devin will start a Cloud session and build context for itself, reading recent channel messages and the full thread to understand where help is needed.
- Devin reacts with 👀 — it's on the task — and responds in the thread.
- Devin lets the conversation flow, acking messages it takes into account as it works.
- Devin comes back with a PR and root cause analysis.
- Tags the correct code owner for review.
- A video proving the fix works is included in the thread.
- As more messages come in, Devin updates the PR.
A Devin session gets its own machine where it can do actual work - write, build, and test code. This allows Devin to record a video of its work and drop it in the thread for everyone to see, instead of describing its process verbosely. When the conversation goes quiet, Devin doesn’t nudge for more input. Its machine goes to sleep behind a snapshot of its working state, and when the thread reactivates, Devin picks up the work with the environment and context intact.
We also gave Devin the ability to proactively watch channels. A new message about “seeing 401s from the billing service this morning”, triggers Devin to pick up the task, start a thread, and come back with root cause analysis and a PR.
Our first version of watched channels was too eager. A dozen related messages about a flaky deploy turned into a dozen Devin sessions investigating in their own threads. The fix was architectural; every watched channel gets a long running triage agent that maintains a scratchpad of open issues. When a new message arrives, the agent first decides whether it’s a new problem to tackle, a symptom of something already tracked, or nothing at all.
In fact, “nothing at all” is the right answer most of the time.
When to Shut Up
In a normal Devin session, every message gets Devin’s full attention, even with multiple teammates participating. A Slack thread breaks that assumption. Devin is in the conversation, but most messages are people talking to each other. We modified Devin’s behavior in Slack by appending a note to each message the model has to consider. It took a few revisions to get it right:
Instructing the model to reply “only when needed” leaves ties unresolved, and a model trained to answer questions biases towards answering them.
These warnings never pile up in the session’s context. The note is injected with each message the harness decides to surface to the model. Otherwise, a long thread would bury the conversation under a mountain of identical warnings, running the risk of distracting the model. The only instruction that lives in the context for watched channels is the prompt at the top of this post.
Nailing the prompting still wasn’t enough, because our harness was working against it. In Devin Cloud, Devin must report back before it goes to sleep. In Slack, this creates noise. So for Slack, we had to make silence an acceptable exit condition of the agent loop.
Finally, no amount of prompting removes the need to override Devin’s behavior sometimes. Messages like “be quiet”, “stop”, or “shut up” are parsed as state commands in the harness, not part of the conversation. Devin stops receiving a thread’s messages entirely, until an @Devin pierces the mute.
Body Language
Silence does not have to mean absent. A teammate can stay quiet and still let everyone know it’s paying attention. We didn’t want Devin filling channels with “on it”, “done”, and “in progress” messages. So instead, Devin got body language with emoji reactions.
👀 lands on every message Devin picks up in a watched channel, before any model has processed it. Devin clears it when it has some results to report in the thread, or when it concludes no action is needed.
| Reaction | Meaning |
|---|---|
| 👀 | On it |
| 👍 | Acknowledged |
| ✅ | PR landed |
| 💤 | Devin's machine goes to sleep |
The vocabulary is not fixed either. Teams can customize Devin’s behavior on watched channels. In our channels, Devin reacts with 🎫 when it opens a ticket to track a new bug reported in Slack.
And reactions run both ways. Emoji reactions by humans on Devin’s messages are forwarded to the session as signal. A 👍 or a 👎 lands as feedback that Devin can consider to improve its work.
Introducing Slack Code
We spent the past year building Devin to be a good teammate in Slack, to the point where Slack became the primary way we work with Devin ourselves. Simple questions and answers in threads grew to entire work streams that begin and end in Slack. And that’s when threads started to crack.
A thread is built for conversations about work, and less for the work itself. A session that runs for hours can be buried under a thread with 47 replies with all of Devin’s work cramped in a column of messages. So together with Slack, we took the next step by giving Devin a dedicated channel that belongs to the session, and Devin is the host.
When Devin works in a thread and decides that the task is large enough to deserve its own workspace, it will automatically create a Code Channel and port its session there. You can also manually ask Devin to create a dedicated Code Channel with a task in mind, or by using the !new command.
Inside a code channel more of Devin is visible to everyone:
- A status chip shows Devin status and lets you stop Devin at any moment.
- A context bar keeps track of Devin’s Cloud session and all generated PRs
- Every working message expands to show Devin’s actions
- A sessions artifacts tab aggregates all code diffs, plans, videos and screenshots generated by Devin.
Closing
The surprising finding from our work on Slack was that once Devin stopped talking, people started trusting it more. One-off questions turned into fully collaborative threads with Devin, with teammates steering it, nudging it, and shipping more. And today with Code Channels, Devin gets more room to work with your team.
Start building with @Devin in Code Channels today: devin.ai