How to Turn a Slack Thread into a Tracked Task (and Get a PR Back)

A lot of engineering work starts the same way: someone drops a message in Slack.

"The export button breaks on Safari." A few replies later, someone posts a screenshot, someone else finds the cause, and everyone agrees it should be fixed. Then the thread scrolls out of view, and nothing happens.

The decision was made. It just never became a task, and it definitely never became code.

In this guide, I'll show how to close that gap with Sharkly.ai: turning a Slack thread into a tracked Task, handing it to a coding agent, and getting a pull request back, without the context getting lost along the way. Everything here is based on Sharkly's Slack integration docs and its integrations overview.

Why Slack Threads Are Where Tasks Go to Die

Slack is great for deciding things. It's bad at remembering them.

A typical thread has everything a developer needs: the bug report, a screenshot, the steps to reproduce, and often the fix someone already suggested. But to turn that into work, someone has to:

1. Open the tracker
2. Create a ticket and copy the important parts of the thread
3. Re-upload the screenshots
4. Paste a link back to Slack so people know it's tracked
5. Remember to update the thread when it's done

Every one of those steps is a chance for the work to stall. And now that coding agents can pick up well-defined tasks, the cost of that handoff is even more obvious. The agent could fix the bug in minutes. The problem is getting a clear task in front of it.

What you want is a single path: thread → task → agent → pull request → back to the thread.

How Sharkly's Slack Integration Works

Before the steps, it helps to know that Sharkly's Slack integration is really three separate connections. Each one is set up on its own, and connecting one doesn't turn on the others.

Connection	What it does	Who sets it up
Workspace connection	Create Tasks from Slack with a slash command, global shortcut, or message shortcut. Adds linkbacks and link previews.	Org Owners or Admins
Task assistant	A built-in assistant per Space. @-mention it in a thread and it reads the conversation, writes up the request, and files a Task.	Any member of that Space
Agent bot	Gives one Sharkly Agent its own Slack app, so you can DM it or mention it in channels.	The Agent's owner, or Owners and Admins

For this workflow, you mainly need the first two. The Agent bot is useful for chatting with an agent directly, but the docs note that Agent bot conversations don't create Tasks automatically, so it isn't the right tool for turning a thread into tracked work.

On the code side, Sharkly's GitHub integration links pull requests back to Tasks, which is how the PR finds its way home.

Step by Step: From Slack Thread to Pull Request

Step 1: Connect your Slack workspace

An Organization Owner or Admin does this once:

1. In Sharkly, go to Integrations → Slack.
2. Under Connected Slack workspaces, select Connect.
3. Complete the Slack OAuth installation.
4. Turn on Linkbacks and Unfurls, so the thread gets a reply with the Task link and Task links expand into previews.

One thing to know: a Slack workspace can only be connected to one Sharkly Organization at a time.

Step 2: Bind the Task assistant to your Space

This is the part that does the heavy lifting. Each Space has a built-in Task assistant, and you just need to give it a Slack app:

1. Open Integrations and go to the Slack page.
2. Under Task assistant, find your Space.
3. Select Bind Slack.
4. Pick the Runtime for the assistant.
5. Create and install its Slack app in the same dialog.

You don't need to create an Agent first. The assistant's Description and Instructions come from your admin's template, and you can override them per Space.

Step 3: Turn the thread into a Task

Back in that bug thread, you have two options.

Option A: mention the Task assistant. Reply in the thread with something like:

@TaskAssistant turn this into a task. Fix the Safari export bug
from the screenshot above.

The assistant reads the conversation, writes up the request, and files the Task in that Space. You don't have to copy anything.

Option B: use a message shortcut. Open the message's shortcut menu and create a Task from it. You pick the Space, task type, and status. Images, videos, and other attachments you select are carried into the Task body, so the screenshot comes with it.

Either way, the thread gets a linkback, so everyone can see the work is now tracked.

Step 4: Keep the thread connected

The docs describe Task-bound threads: when a Task is created from Slack by an agent, the thread can be bound to it. Once bound, Task comments and thread messages stay in sync, and status changes can post back to the thread.

In the Task view, you'll see thread connected in #channel. You can stop the sync there at any time without deleting the Task or the Slack history.

This is what stops the thread from going quiet. The people who reported the bug see progress right where they reported it.

Step 5: Assign a coding agent

Now the Task is a normal Sharkly Task, so you assign it the same way you'd assign a teammate. Sharkly describes Agents as "saved Agents you assign like teammates," and you can assign an Agent or a Crew directly from the Task.

One setup detail matters here: the agent needs access to your code. In Sharkly, an Agent's repositories are configured on the Agent, and it runs on a Computer, which clones using that machine's SSH key, HTTPS token, or host credentials.

The agent then does the work with your coding tool of choice, such as Claude Code or Codex.

You can also update the Task from Slack itself. From the Slack Task card, members can change the status, priority, assignee, labels, and dates, and the changes sync back to Sharkly.

Step 6: Get the pull request back

The agent works on the Task in its own worktree, and its results and blockers come back as comments on the Task. According to Sharkly, a run that's waiting for human review lands in the responsible person's Inbox.

To connect the code itself back to the Task, set up the GitHub integration:

1. Install the Sharkly GitHub App.
2. Under Link git PRs & commits to tasks, turn on Link pull requests (and optionally Link git commits).
3. Make sure the Task ID appears in the PR title, the PR description, or the branch name. A bare ID like ID-123 is enough.

Once a pull request that includes the Task ID is opened, Sharkly links it to the Task and can post a linkback comment on the PR. Now the PR points to the Task, the Task points to the Slack thread, and the thread shows the progress.

A reviewer checks the PR, merges it, and marks the Task done, which can post the status change back to the original thread. The person who reported the bug sees it fixed without asking.

Tips and Things to Know

A few details from the docs that are easy to miss:

• Merging doesn't close the Task. Words like "fixes" or "closes" in a PR have no special meaning, and merging a PR doesn't change the Task status. Someone still marks it done.
• Linking a PR isn't the same as code access. The GitHub App links PRs to Tasks, but it doesn't let an agent clone your repo. That comes from the Computer's credentials.
• Agents see the last 20 thread messages. For longer threads, the agent can page back through Slack history using the CLI, but it's better to keep the key details near the end.
• You can stop a run from Slack. Add the ❌ reaction to the message that started an agent run, and it stops in Sharkly too.
• Turn on Slack DMs for yourself. Connect your personal Slack account under Settings → Notifications → Slack to get assignments, status changes, comments, and agent activity as DMs. Only events after you connect are delivered.
• People outside your org can still report. Slack users who aren't Sharkly members get an external account. It takes no seat and can't sign in, but their messages still count as context.

Final Thoughts

Most teams don't have a shortage of decisions. They have a shortage of follow-through. The bug gets discussed, everyone agrees, and then the thread disappears.

With Sharkly's Slack integration, the path from conversation to code is much shorter:

1. Mention the Task assistant in the thread, or use a message shortcut
2. Keep the thread bound to the Task so updates flow both ways
3. Assign a coding agent like you'd assign a teammate
4. Link the PR with the Task ID and review it as usual

The context from Slack travels with the work, the agent gets a clear task, and the people who raised the issue see it resolved in the same thread.

If you want to try it, you can get started at sharkly.ai.