Many people now use AI to write code,
and the typical workflow is:
Engineers open:
Claude.
Codex.
Copilot.
Devin.
or other coding agents.
They chat privately with the AI for a while.
The AI modifies the code.
Finally, the engineer sends it to the team saying,
"I’m done, take a look."
The problem is,
others usually only see the
final result,
but don’t know:
What was the initial request to the AI?
What assumptions were made?
What changes happened along the way?
Did someone already realize
the requirement was misunderstood?
Slack’s latest feature,
Slack Code,
aims to fix this.
What is Slack Code?
Simply put, it transforms
one person + one AI coding agent
private work
into
the whole team + AI agents
collaborating together in a project space.
Slack calls this space a
Code Channel.
When a development task becomes more complex,
the team can summon supported coding agents inside Slack
and create a dedicated Code Channel for that task.
This space isn’t just for chatting;
it shows:
the plan,
code changes,
code diffs,
live HTML previews,
team feedback,
and final approvals.
In other words,
the AI’s work process becomes visible.
The real issue isn’t that AI can’t code
AI coding agents are already very capable.
The real problem is:
AI works too fast.
Say a product manager tells the engineer:
Add a free trial button on the homepage.
The engineer asks the AI to handle it.
Ten minutes later:
it’s done.
Looks efficient,
but the designer may not know
the button position changed.
The marketing team might not know
the copy was edited.
Another engineer might not realize
the login flow was also altered.
The speed is great,
but the team context
is broken.
Slack Code’s idea: Bring AI back into a visible space for everyone
For example, if a Slack channel is discussing,
"The mobile registration button is too small,"
someone might previously say,
I’ll fix it later.
Then leave Slack,
open a coding agent,
and return after 20 minutes.
Now, you can summon the agent directly,
have it create a
Code Channel,
and everyone can watch together
how it plans to make changes.
If anyone knows additional constraints,
they can add them right away.
Key feature one: The plan is no longer for one person only
One of the biggest risks in AI coding is:
a wrong understanding early on,
but perfectly executed code after that.
For example, the requirement might be,
"Change only the mobile version,"
but the agent interprets it as
changing both desktop and mobile.
Working privately with AI,
the team usually realizes this
only after it’s finished.
By placing the work plan into a shared space,
others can speak up
"Wait, this assumption is wrong."
before major changes happen.
Key feature two: Code diffs are instantly visible
Code diff means
what exactly was changed?
Instead of only hearing
"modifications completed,"
you see
what the code was before
and after.
Slack’s official description says Code Channels
can show code diffs directly,
so the team doesn't have to rely solely on
the agent’s text summary.
They can inspect the actual changes.
Key feature three: Live previews
This is especially important for non-engineers.
Designers don’t necessarily want
to read code.
Marketing doesn’t need to understand
React, CSS, or API details.
But they do understand
the final result.
For example, after the AI changes the website,
live preview lets the team see
button placement,
mobile views,
forms,
and page structure.
This allows non-technical colleagues to say,
"This isn’t what we wanted,"
without needing to learn how to read
code diffs first.
What makes Slack Code special
It’s not about making everyone an engineer.
It enables different roles
to contribute at their comprehension level
to AI development.
Engineers look at code,
designers at previews,
product managers at requirements,
others provide context,
and AI agents do the actual work.
Key feature four: One project, one Code Channel
Slack threads work well for quick Q&A,
but if a coding agent runs tens of steps,
threads become a mess of messages.
Slack Code creates dedicated
Code Channels
for full development tasks,
handling only that work.
Once done,
the channel auto-archives,
but its contents remain searchable.
Why keeping archived records is crucial
Because three weeks later,
someone may ask,
"Who changed this login flow?"
Before, the answer might be
"probably the AI,"
but no one remembers
who asked it to change,
what was requested,
who saw the changes,
and why those decisions were made.
Keeping everything inside a Code Channel lets you trace back
discussions, commands, changes,
and approval processes.
Slack likens this to an
audit log.
Why this matters in the AI era
In the future, the real problem may not be,
"Who wrote this code?"
since often the answer will be,
AI.
The important questions become,
"Who asked the AI to make this change?"
and
"Who finally approved it for launch?"
AI can be the executor,
but responsibility and approval still rest with humans.
Which agents does Slack Code support?
Slack officially launched Slack Code on August 20.
Currently, it supports:
Claude, Devin, GitHub Copilot,
and Vercel.
Slack also lists OpenAI as a partner,
but ChatGPT support is noted as
"coming soon."
So users cannot yet create Slack Code Channels with ChatGPT directly.
This timing difference is important to understand.
Using Slack Code feels similar to regular Slack
Suppose someone in a dev channel says,
Customers report the mobile checkout button is missing.
Previously:
Create a ticket,
assign an engineer,
engineer opens coding tool,
finished,
reviewed.
Now it might become:
Call the coding agent directly,
agent creates a
Code Channel,
step one: read context,
step two: propose plan,
step three: start modifying,
step four: show code diff,
step five: generate preview,
step six: engineer and team confirm.
This is
AI coding workflow inside team conversations.
Non-engineers can also participate
Example: a product manager spots,
"The subscription page price text is wrong."
Before, they’d
open an issue,
describe the problem,
and wait for the engineer.
Now, for simple issues,
they can call the coding agent
to prepare the fix first,
and then engineers review.
Slack even gives examples where non-technical staff use natural language to describe issues,
have the agent prep fixes,
then tag engineers for approval.
This doesn’t mean everyone can deploy to production
This is very important.
Letting non-engineers
request changes
and
allowing non-engineers to deploy those changes
are two very different things.
Slack Code’s value is in pulling people back to
review.
Slack states that
high-risk changes can be
routed to a person for approval.
Meaning AI works to a stage,
then a person
approves before launch.
How does this differ from Replit Plan Mode?
Replit Plan Mode lets you
see AI plans before it changes your app.
Slack Code focuses more on
how the whole team watches AI’s work together.
They complement each other.
Level 1: AI plans.
Level 2: People review plans.
Slack Code adds
Level 3: Other stakeholders can join in real time.
Because the most dangerous AI mistakes aren’t always technical
For example, AI builds a button
with no bugs,
passes tests,
but the product manager knows
the feature isn’t due for release until next week.
Or legal knows
the copy can’t be written that way.
Or customer support knows
the customer only wants to change the explanation,
not delete the feature.
These are not coding problems,
but
context problems.
So "seeing together" doesn’t slow AI down
At first glance,
AI coding alone seems fastest.
Ten minutes done,
two days later the requirement is wrong,
redo it all,
that’s not fast.
Real efficiency is
finding errors at the cheapest stage.
Finding errors in planning is cheapest,
preview stage is okay,
production is most expensive.
A notable internal Slack statistic
Slack says over
70% of Code Channels
are started and completed within the same day.
This is Slack’s own usage data, not independent research,
and shouldn’t be taken as
"any company using Slack Code will finish projects in a day."
More reasonably, it shows many tasks fit for Code Channels are
bugs,
small features,
UI fixes,
quick iterations,
that can be closed fast.
The best initial use cases are not rewriting entire systems
First Slack Code trials suit
small bugs,
copy edits,
simple UI tweaks,
internal tool adjustments,
single features,
easy-to-preview work,
because
errors are easy to spot,
easy to revert,
and review scope is small.
The recommendation is to avoid large tasks at first
Examples:
Redesign our entire membership system.
or
Rewrite the payment process.
or
Change the entire production database schema.
While agents might be capable,
such high-impact work
does not suddenly become safe just because
everyone can see it.
Visibility isn’t a safety guarantee
This matches what we’ve discussed about AI agent principles.
Code Channels raise
transparency,
not
correctness.
The whole company might watch AI
make mistakes.
If no one understands
what’s wrong,
those mistakes persist.
The best approach isn’t
"just let AI run since Slack logs it,"
but to clearly assign
who owns the requirements,
who reviews code,
and who gives final approval.
Slack Code inherits existing Slack permissions and admin controls
This matters greatly for companies.
Slack says Slack Code uses the existing
permissions
and admin controls,
so enterprises don’t have to treat Code Channels as
completely separate systems outside Slack’s governance.
However,
which repo, data, or services coding agents can access
still depends on each agent’s authorization.
So companies should ask: What can this agent access?
Not just,
"Who can see the Slack channel?"
But also,
Which repos can the agent read?
Which branches can it change?
Can it open PRs?
Can it merge?
Can it deploy?
Can it touch production?
This is the real
permission boundary.
A very simple first workflow
Say the company website has a
mobile button issue.
Step 1
Describe the problem in Slack.
Step 2
Tag a coding agent.
Step 3
Join the Code Channel.
Step 4
Review the agent’s understanding and plan.
Step 5
Allow the agent to make changes.
Step 6
Review code diffs.
Step 7
See the preview.
Step 8
Engineer review.
Step 9
Final human approval before production release.
This is
team-based AI coding.
It may change who can propose product improvements
Many small issues disappear not because
no one saw them,
but because people thought,
"This is too small to bother an engineer."
Examples:
button spacing,
a typo,
simple sorting,
small internal tools.
Slack says previously
bug reports and minor UI fixes
often got ignored.
Now, the agent can be started directly from the discussion,
making small improvements more likely to get done.
But beware of the opposite risk: changes becoming too easy
When anyone can ask AI to modify,
companies might shift from
"small issues don’t get addressed"
to
"everyone keeps asking AI to change everything."
Today marketing tweaks,
in the afternoon product changes again,
tomorrow sales wants another update.
Without ownership, priority, and review,
products may just become more chaotic.
AI coding bottleneck might shift from "writing code" to "deciding what to write"
Traditionally, engineer time was costly,
limiting immediate implementation of all ideas.
If agents greatly reduce coding cost,
the new scarce resource may be
decision making.
What should be done?
What shouldn’t?
Which requirements are final?
Who can approve?
These won’t disappear just because coding speeds up.
This is Slack Code’s most notable insight
The real problem isn't
"The AI needs a better chat window,"
but
once AI agents actually start working, humans need a shared visible workspace.
Meaning AI is not a secret outside contractor.
AI should be like a team member:
work with context,
visible processes,
changes reviewed,
and accountability clear.
Is Slack Code useful if you’re not an engineer?
If you have no
software projects,
websites,
or internal tools,
Slack Code isn’t the most essential product today.
But if you work in
small SaaS,
website companies,
startups,
product teams,
design studios,
digital marketing,
e-commerce,
or solo businesses with outsourced engineers,
the key isn’t whether you can code,
but
whether your requirements keep getting distorted in translation with engineers.
If yes,
Slack Code’s collaborative approach is definitely worth attention.
Start small on your first run
Don’t
rewrite the app.
Pick
a fix you can see the result of, for example:
a bug,
a button,
a simple UI change.
Keep the whole record of
plan,
diff,
preview,
and review.
See if your team really saves
coding time or
communication time.
A key takeaway today
The biggest change in Slack Code
is not
"AI got better at coding."
It is
AI coding is shifting from a private conversation with one person to a shared team workflow where everyone can view, change, and approve.
As AI coding speeds up,
the real scarcity may no longer be
how fast code is written,
but rather who provides accurate context,
who finds mistaken assumptions,
and who has authority to approve final changes.
This marks the next phase of AI coding entering companies.
Today, make progress with AI a little every day.
Learn one AI trick daily,
save some time daily,
boost your skills daily.
SasaDaily grows with you.
Recommended reading
AI One-Minute Tutorial｜2026/08/20: Replit's Plan Mode Lets You See Plans Before Changing Your App
