Menu
Prefer to listen instead? Here’s the podcast version of this article.
AI coding has spent the last few years becoming remarkably good at helping one person build software faster. Slack now wants to answer a more interesting question: what happens when AI coding becomes a team activity instead of a private conversation between a developer and an agent?
That is the idea behind Slack Code, a new collaborative environment that brings AI coding agents into dedicated Slack channels where developers, product managers, designers, and even less-technical colleagues can participate in building software together.
Slack describes the concept as turning agentic coding into a “multiplayer” experience. Instead of an engineer disappearing into a terminal, IDE, or private AI chat and returning later with a pull request, a team can watch an agent work, provide context, review code changes, preview results, redirect the agent, and approve the final output from a shared workspace. Salesforce’s official introduction to Slack Code describes these spaces as project-specific code channels designed to keep the agent, conversation, code, documentation, and decision-making together. [Read Salesforce’s introduction to Slack Code]
Slack Code is essentially a dedicated workspace for a specific AI-assisted development task.
Imagine a product manager notices that a button is broken on a customer-facing page. Traditionally, the issue might become a ticket, get assigned to an engineer, enter a backlog, move into an IDE, generate a pull request, and eventually return to product or design for review.
With Slack Code, a teammate can bring a supported coding agent into the conversation. A dedicated code channel can then be created around the task, bringing relevant people and context together. Within that space, participants can see the agent’s plan, review code diffs, examine live HTML previews, provide feedback in natural language, and approve the work before deployment. Completed channels can be automatically archived while retaining the history as an audit record.
Computerworld’s coverage of the launch highlights the central idea particularly well: Slack is attempting to make coding agents available to multiple coworkers rather than keeping each agent interaction confined to an individual developer. [Read Computerworld’s Slack Code analysis]
This is a small interface change with potentially large organizational consequences.
Tools such as Claude Code, GitHub Copilot, Devin, Codex, Cursor, and other coding agents have already changed how developers approach programming. They can help explain unfamiliar repositories, generate code, investigate bugs, draft tests, and implement features.
But there has been a structural weakness in many AI coding workflows: the agent’s working context can remain invisible to everyone except the person operating it.
A developer may spend 45 minutes prompting an AI agent, rejecting approaches, clarifying requirements, fixing assumptions, and refining the solution. When the resulting pull request appears, everyone else sees the outcome—but not necessarily the reasoning that produced it.
Slack Code attempts to expose more of that process.
The Verge describes the product as a collection of collaborative “vibe-coding” channels in which teams can compare changes and preview HTML output before something ships. [Read The Verge’s coverage of Slack Code]
That distinction matters because software development is rarely just about writing syntax. Good software emerges from discussions about customer needs, design trade-offs, deadlines, security, accessibility, architecture, business rules, and countless small decisions. Much of that information already lives in Slack.
Putting an AI coding agent closer to those conversations could reduce one of the biggest headaches in AI-assisted development: context loss between the business conversation and the technical implementation.
Perhaps the most interesting part of Slack Code is not what it does for programmers. It is what it could do for everyone around them.
Product managers can clarify requirements while implementation is happening. Designers can examine a live preview instead of waiting for a completed build. Marketing teams can flag incorrect messaging. QA specialists can raise edge cases. Accessibility experts can identify issues earlier. Engineers can inspect the actual code diff before approving a change.
Non-technical contributors do not suddenly become senior software engineers—and businesses should not treat AI agents as a shortcut around engineering expertise. What changes is their ability to participate directly in the creation loop.
VentureBeat characterizes Slack’s strategy as moving AI coding “out of the terminal and into the group chat,” with teams able to watch, steer, review, and ship alongside AI coding agents. [Read VentureBeat’s analysis of collaborative AI coding]
That could shorten the distance between “here is what the customer needs” and “here is the software we built.”
One of Slack Code’s strongest ideas is making the output of an AI agent inspectable.
Code channels can surface code diffs, allowing participants to see what lines changed rather than simply accepting an agent’s claim that it “fixed the problem.” For web-related work, teams can also view live HTML previews and check what the proposed change actually looks like.
This is important because natural-language interfaces can create a dangerous illusion of simplicity. A request such as “fix the checkout button” sounds trivial. The underlying code change may not be.
Making diffs, plans, previews, comments, and approvals visible in the same workspace encourages teams to treat AI-generated code as something to review, not something to blindly trust.
Slack is not trying to win the AI model race by creating yet another coding model. Instead, it is positioning itself as the collaborative layer where multiple coding agents meet teams.
Salesforce says Slack Code is being developed with an ecosystem that includes Anthropic, Cognition, GitHub, OpenAI, and Vercel. Its launch materials cite agents including Claude, Devin, GitHub Copilot, ChatGPT, and Vercel’s agents. Availability and individual partner requirements can vary, so organizations will still need the appropriate access to whichever agent they intend to use.
That ecosystem approach is strategically significant.
Enterprises increasingly use more than one AI model or agent. A company might prefer one model for development, another for research, and another for specialized internal workflows. If Slack can become the interface through which employees collaborate with those agents, Slack becomes less of a messaging app and more of an orchestration layer for human-AI work.
AI coding demos tend to focus on speed: describe an application, watch it appear, celebrate.
Businesses have less glamorous questions.
Who authorized the change? What data could the agent access? Which repository was modified? Who reviewed the code? What permissions did the agent inherit? Who approved production deployment? Can we reconstruct what happened later?
Slack Code is notable because the product is being framed around visibility, permissions, human approval, and auditability, not merely generation.
Salesforce says code-channel agents inherit Slack’s existing security model, permissions, and administrative controls. It also states that higher-stakes actions—such as pushing code into production—can require expert human sign-off. Completed code channels preserve a record of the work rather than simply disappearing.
Computerworld also notes an important caveat: permissions become especially complicated in multiplayer agent environments, because organizations must carefully decide whose authorization an agent inherits and what data or systems it can access.
That means Slack Code should not be interpreted as permission to abandon normal engineering controls.
Organizations adopting collaborative AI coding should still maintain clear repository permissions, branch protection, automated testing, security scanning, code review, deployment controls, observability, data-governance policies, and named human accountability.
Slack Code may eventually matter for much more than software development.
Once organizations become comfortable placing AI agents into shared, auditable workspaces, the same interaction model can extend to other knowledge-intensive projects.
Slack has already suggested broader possibilities involving activities such as marketing projects and document review. The pattern is the important part: create a temporary workspace around a goal, give an AI agent controlled access to relevant context, allow multiple people to steer its work, surface its outputs for review, require appropriate approvals, and retain the final activity history.
That is essentially multiplayer agentic work.
A marketing team could collaborate with an agent on a campaign. A finance team might work with one on a reporting workflow. A legal team could review document revisions. Operations groups could coordinate agents working across connected systems.
In other words, Slack Code may be less about turning Slack into an IDE and more about testing a new model for how organizations interact with autonomous software.
Slack Code shows how AI coding is moving from a tool used by one developer to a shared team experience. Instead of keeping AI-generated code hidden inside a private chat or coding environment, teams can work together, review changes, give feedback, and approve updates in one place.
The biggest benefit is not simply faster coding. It is better collaboration between developers, designers, product managers, and other team members. Everyone can understand what the AI is doing and contribute before changes are released.
At the same time, human review remains important. AI coding agents can speed up development, but organizations still need strong security, testing, permissions, and approval processes.
Overall, Slack Code represents a broader shift in the future of work: AI is becoming a teammate rather than just a personal assistant. If this approach becomes widely adopted, software development could become faster, more transparent, and more collaborative—while still keeping people in control.
WEBINAR
