How to Use /task in RankTalk to Spawn RankOps Tasks

# How to Use the /task Command to Spawn RankOps Tasks from Chat

You're on a client call. The CMO mentions she'd love to see a competitive teardown of three competitors before the next QBR. You scribble it on a sticky note. After the call, you flip back to Asana, write the task with what you remember of the conversation, and assign it to your strategist. By the time she picks it up Thursday, you've forgotten which 3 competitors the CMO mentioned, and the task description reads "competitive teardown" with no specifics.

The /task command in RankTalk fixes this. Five seconds after the CMO mentions it on your shared channel, you type /task and turn the conversation into a structured RankOps task — with the exact 3 competitor names captured, the project pre-filled, and the strategist suggested as assignee. By the time the call ends, the work is already queued.

What You'll Learn

By the end of this article, you'll understand exactly what the /task command does, when to use it versus creating a task manually in RankOps, how the auto-pre-fill works based on channel context, what optional parameters you can pass inline, how the original chat message links back from the created task, and the common patterns agencies use to make /task part of their team's muscle memory.

Why This Matters (The Benefit)

The single most expensive moment in agency operations is the gap between "we should do X" and "X is a tracked task assigned to someone."

In typical agencies, this gap is minutes to hours. Someone says "we should audit their hreflang setup" in a meeting. The meeting ends. Someone has to remember to create the task. They open their PM tool. They write the task. They guess at the details since the original speaker isn't there to clarify. Half the time, the task never gets created at all.

The /task command closes this gap to 5-10 seconds. The conversation becomes structured work in real time, with the original message preserved as context. Agencies that build a /task-first habit report:

• 38% reduction in "orphan ideas" — work mentioned but never tracked
• 2x faster new-task creation throughput
• Higher quality task descriptions because the original conversation is preserved

Sana P. at her 14-client agency tracks the "tasks created via /task" ratio as a team-health metric. When it's above 75%, her team is operating efficiently. When it drops below 50%, something is broken in their workflow.

What /task Actually Does

The /task command spawns a RankOps task with the following auto-pre-filled fields:

• Project — derived from the channel you're in
• Project context — visible at the top of the task detail
• Linked message — the original chat message that prompted the task
• Channel link — clickable reference back to the chat conversation
• Suggested assignee — based on task type and team patterns

You fill in:

• Task title (often pre-fillable from the slash command itself)
• Task type (7 SEO-specific types)
• Priority (red/yellow/green dot)
• Due date
• Description (longer details if needed)

Step 1: Choose the Right Moment to Use /task

/task is the right action when:

1. Someone in the channel mentioned work that should happen ("we should...", "can we add...", "let's investigate...")
2. A decision was made that requires execution ("Yes, let's go with option B")
3. A client request was captured in chat that needs to be tracked

/task is the wrong action when:

1. The conversation is still exploratory — wait until there's a clear "yes, let's do this" before creating a task
2. The work is already a task — don't create duplicates; reply to or update the existing task
3. The work is too vague to scope — refine the conversation first, then create the task

Train your team on this distinction: every /task should represent a real commitment, not a half-formed idea.

Step 2: Type /task and Use Autocomplete

In any channel where you have posting access:

1. Click the message composer
2. Type / — slash command autocomplete opens
3. Select /task (or finish typing /task)
4. Press Tab or Space to confirm

The composer transitions into a task-creation context. You'll see a structured form below your message composer instead of a plain text input.

Quick Inline Mode

For fast capture, you can type the task title directly after the slash command:

`` /task Fix hreflang setup on /products page `

Press Enter and a quick dialog opens with the title pre-filled. You finish the other fields and save.

Detailed Form Mode

If you just type /task and press Enter, a full task creation form opens. Use this when the task needs more context than fits in one line.

Step 3: Verify Auto-Pre-Filled Fields

Before filling in the rest, check what RankTalk auto-pre-filled:

Project

The project should match the channel you're in. If you're in #acme-co-seo-q2, the project should be "Acme Co. SEO Q2."

If the project doesn't auto-pre-fill (rare), you're in a non-project channel like #general. Manually pick the project from the dropdown.

Linked Message

The original chat message that prompted the /task should be linked. You'll see a small "From message: [first 50 chars]" reference in the task form. Click it to verify the right message was captured.

Channel Reference

The channel name should appear in the task's "Source" field. This becomes a clickable link from RankOps back to the channel.

Step 4: Fill in Task Type, Priority, and Assignee

Now the fields you have to provide:

Task Type (Required)

Pick from the 7 SEO-specific types:

• On-Page — content + technical page work
• Links — outreach and placements
• Local — citations and GBP
• Audit — technical investigations
• Research — keyword and competitor work
• Client — client-facing deliverables
• Collab — cross-team coordination

RankTalk will sometimes auto-suggest a type based on keywords in your description. "Hreflang" suggests Audit. "Outreach" suggests Links. Verify the suggestion before saving.

Priority

• Red (high) — must close this sprint
• Yellow (medium) — default
• Green (low) — pulls if capacity allows

Assignee

Pick from the channel's project members. RankTalk shows Managers and Staff assigned to the project; you can't assign across project boundaries.

For some task types, RankTalk auto-suggests an assignee based on patterns. If you always assign Audit tasks to Dev and Links tasks to Aisha, it'll suggest those.

Due Date

Pick a date inside the current sprint. Tasks with no due date are invisible to Sprint Forecast.

Step 5: Add a Description (Optional but Recommended)

For tasks beyond a single sentence, click Add Description and provide more detail.

Best practices:

• Specific scope — "Top 30 product pages" not "product pages"
• Definition of done — "verified in GSC after deploy"
• References — link any specific URLs, docs, or related tasks
• Quote the chat context — RankTalk will offer to embed the linked message; use it

The description is what your team member reads when they pick up the task. The more context here, the less back-and-forth later.

Step 6: Save and Verify

Click Create Task.

You'll see two things happen:

1. In RankTalk — a confirmation appears in the channel with a link to the task: "✓ Task created: Fix hreflang setup on /products page"
2. In RankOps — the task lands in the project's Backlog (or To Do, depending on due date) with all metadata filled in

Click the confirmation link to verify the task in RankOps. The assignee should appear correctly, the linked message should be visible in the task detail, and the channel source link should work.

Common /task Patterns

Pattern 1: Client Call Capture

During a client call (with the project channel open), when the client mentions any work item:

` /task Add competitive teardown of CompetitorA, CompetitorB, CompetitorC to QBR pack `

5 seconds. Captured before they finish the next sentence.

Pattern 2: Audit Finding Capture

While reviewing audit results in chat:

` /task Fix 3 broken canonical tags on category pages (per audit) `

The senior who spotted the issue creates the task; the assignee gets the original audit message as context.

Pattern 3: Cross-Team Hand-off

When one team member needs another to pick up work:

` /task Hand off keyword research output to content team for brief production `

The receiver sees both the task and the original context.

Pattern 4: Recurring Reminders

For client-mentioned items that recur monthly:

` /task Monthly: recurring CWV check on top 10 pages (client requested this cadence) `

Set the task to recurring; first instance gets the original client request as context.

When /task Differs from Manual RankOps Task Creation

Both work. They produce identical tasks. The difference is context preservation.

| Action | Context Preserved | Speed | Use When | |---|---|---|---| | /task in chat | Yes — linked message + channel source | 5-10 seconds | Work emerges from conversation | | Manual in RankOps | No external context | 30-60 seconds | Work is planned independently of a conversation |

For 80% of agency work, /task is the right approach because most work emerges from conversation — calls, audit reviews, client requests, team discussions.

Common Mistakes

• Using /task for vague intent that isn't yet a commitment. "We should probably do an audit eventually" isn't a /task candidate. Wait until there's a decision: "Yes, let's audit this month."
• Not verifying the auto-pre-filled project. If you're using /task from #general instead of a project channel, the project field will be blank. Always check before saving.
• Skipping the assignee field "to assign later." Tasks with no assignee become invisible to your team. Always assign at creation time, even if you reassign later.
• Writing one-line task titles without specifics. "Audit" is not a useful task. "Audit top 30 product pages for CWV regression — fix list by Friday" is. The 4 extra seconds you spend on specifics save 30 minutes of clarification later.
• Treating /task confirmations as task tracking. The confirmation in chat is a notification, not a tracking mechanism. The task lives in RankOps; manage it there. Chat is for conversation; RankOps is for work.

Pro Tip

Build a "during the call" /task habit by running RankTalk in a second monitor during every client call. During the call, keep the project's main channel open. Every time the client mentions a work item, type /task and capture it in real time — sometimes mid-sentence. The client doesn't see you doing this; they just see attentive note-taking. By call's end, you have 5-12 structured tasks captured with full context, instead of "I'll write these up after." Diego R. trains his entire team to do this. He estimates it captures 90%+ of client-mentioned work versus 40% in his pre-RankTalk workflow. Client retention reflects it.

What to Read Next

• Related: Article 6 [How to Use Threaded Replies, Mentions, and Reactions] — how to handle the conversation around tasks
• Related: Article 4 [How to Use Public, Private, and External Channels] — where you can use /task`
• Related: Article 9 [How to Use System Messages, Goal Alerts, and Workflow Notifications] — how created tasks surface in alerts

Apply This With the Rankar Toolkit

RankTalk works best when paired with the rest of the Rankar suite. Spin up the relevant tools directly: RankTalk • RankOps • RankAudit • RankWriter • RankTracker • RankAIO • RankBridge • RankLinks • RankLocal • RankLaunch • RankSpy • RankUX • RankLead. Each tool pushes events into RankTalk automatically — task creation, goal alerts, ranking changes, and approval requests all surface as native messages in the right channels.