Skills and Teaching: Turn Successful Tasks into Reusable Skills
The previous lesson drew the boundaries: Approvals and Auto Review lets you let the Bot act with confidence. This lesson solves the next question—you got it right this time, but how do you avoid teaching it from scratch next time? The answer is Grok Bot Skills: save the steps, decision rules, expected output, and safety boundaries of a successful task as a reusable skill that can later be invoked by name; if you don't feel like writing instructions, you can also use Teach a task to do it once and show it how.
The main thread of Workflow Guide is: first succeed once → save it as a skill → then hand it to a routine to run automatically. This lesson is that middle step, and it's also the order the official docs stress repeatedly—first make the one-off task reliable, then save the method, and only then automate.
The whole thing takes about 12 minutes. The first two steps can be done right in chat; publishing follows the official path on desktop, and teaching is explicitly not available on mobile.
What You'll Be Able to Do After This Lesson
- Use a single ask to save the flow you just got working as a skill, with all six official elements written out: when to use it, inputs and permissions, steps, validation, returns, approval boundaries
- Invoke skills from the Bot by name, and stop using
@on skills—@is for Bots, groups, routines, and apps - When a Bot can't find a private skill, enable it for the Bot in Connect apps under Private skills
- Publish a private skill to your team: add a description before publishing, then Sync to push changes, Copy link to share, Unpublish to take it down
- Use Teach a task to record a browser demonstration of up to 10 minutes, and know that what's learned is a draft—complete the boundaries before scheduling
Your Current Pain Points
- "The same weekly report—every week I have to re-explain the format, definitions, and caveats, and the Bot still does it a bit differently each time"—the method lives only in that one chat and never gets solidified
- "I want another Bot to use the flow I've trained, but it says it doesn't know this skill"—the private skill library is shared across all Bots, but it hasn't been enabled for that Bot yet
- "Four people on the team are each training the same flow in four separate chats"—without publishing, the standard practice doesn't circulate
When to Use This Technique
When you need to:
- Turn a task you got right once into a capability that can be invoked with a single sentence next time
- Let multiple Bots reuse the same flow, or share the team's standard practice with everyone
- Replace "write a long set of operating instructions" with "do it once and show it"
And you don't want to:
- Describe the flow from scratch every time you assign work
- Keep process documents where the Bot can't see them (wiki, notes, message 38 in a chat thread)
- Put a draft learned from a single demonstration straight onto the schedule
🎒 Preparation Before You Start
- You've completed Memory: How the Bot Remembers You and How to Correct It—you can tell apart the memory the Bot stores on its own from the skills you explicitly save, and this distinction is used throughout this lesson
- You have a task on hand that you "recently got right": satisfying results, clear boundaries. If not, go back to Approvals and Auto Review and get it right the first time
- The apps used by the task are connected (Slack, Gmail, etc.)—skills work across Bots, but at execution time the Bot still needs the corresponding app or login
- If you want to publish to your team, confirm you've joined the team—Publish is only available to team members
- A cup of water ☕—most actions in this lesson take a sentence or two; the hard part is thinking the six elements through
Core Idea
A skill is a "reusable set of instructions": write out the steps, decision rules, expected output, and safety boundaries of a task clearly, and save it as a named capability. Later, you (or any Bot that has it enabled) can request it by name, without describing the flow all over again.
First, distinguish three easily confused things:
| What's stored | Who decides to store it | Sharing scope | |
|---|---|---|---|
| memory | Preferences, facts about you, work summaries | The Bot decides on its own, without asking you first | Each Bot has its own; a small amount of facts about you are shared across all Bots |
| skill | A complete flow for doing one thing | You explicitly ask to save it | The private skill library is shared across all Bots (one library) |
| routine | When to run automatically (on a schedule or triggered by events) | You create it explicitly | Belongs to a single Bot |
One sentence to remember: memory is the Bot remembering you, a skill is you teaching the Bot, and a routine is you telling the Bot when to start running.
Don't skip steps in the officially recommended order: first get a one-off task working → make it reliable → save it as a skill → only then automate. The official use-cases manual is more specific in its six steps for "turning a character into a persistent Bot": step 4 "save it as a skill and test with a second input," step 5 "create a routine only after defining retries and failure handling," and step 6 "keep external actions with consequences behind approvals."
A good skill should cover all six elements in full (follow along in the next section):
| # | Element | Question it answers |
|---|---|---|
| 1 | When to use | What tasks should call it |
| 2 | Required inputs and permissions | What data it needs, which apps it connects to |
| 3 | Order of work | What to do first and what to do later |
| 4 | How to verify results | What counts as done right |
| 5 | What it returns | What the deliverable looks like |
| 6 | What needs approval | Which step must stop and wait for you |
Follow along with me
Step 1: Save the workflow you just got working as a skill (the core action of Grok Bot Skills)
Why: If the method only exists in the chat history, it will sink to the bottom as the conversation goes on. Saved as a skill, it becomes a capability you can invoke by name.
In the same conversation where you just got the task working, simply send an ask. The official example:
Save the process we just used as a skill called "Weekly account health." Include the source systems, risk definitions, output format, and the rule that customer contact always requires approval.
(Save the workflow we just used as a skill named "Weekly account health." Spell out the source system, the risk definition, the output format, and the rule that "contacting customers must be approved first.")
What makes this example good: the skill name, source system, judgment criteria, output format, and approval boundary are all spelled out in one go — covering nearly all six elements. When you swap in your own task, speak with this level of density:
- Pick a name you can call out later ("Weekly account health," not "skill1")
- Carry over the approval boundary you drew in the previous lesson as-is — element 6 is exactly that
You should see: The Bot confirms it created this skill and can recite its applicable scenarios, inputs, and boundaries.
- Have the Bot recite the skill's six elements, and fill in any missing one on the spot
Step 2: Invoke it by name and test with a second input
Why: Saving it doesn't mean it was learned correctly. The official six steps explicitly require "testing with a second input" — the same input can't reveal whether the workflow is truly reusable.
Start a new conversation (or stay in the current chat) and say:
Run this week's data using the "Weekly account health" skill.
Note how it's invoked: skills are requested by name. @ is reserved for Bots, groups, routines, and apps — if @ doesn't bring up a skill, it isn't broken; that's just not how it's used.
You should see: The Bot no longer asks you to re-describe the workflow; it starts working straight from the skill, and stops at the approval boundary to wait for you (for example, presenting an approval card before contacting a customer).
- The second input runs through, and the result is usable without you having to fix anything
Step 3: Enable private skills for the Bot in Private skills
Why: The private skill library is a single library shared by all Bots, but if a particular Bot can't find a skill, it most likely just hasn't been enabled for it yet.
- Open Connect apps in the sidebar.
- Click the connected count next to the title.
- Under Private skills, enable the relevant skill for the current Bot.
While you're there, take a look around: Connect apps is also where you discover and install supported apps and packaged skills — before building your own wheel, check what's on the shelf.
You should see: Once enabled, this Bot can find and execute the skill by name.
Step 4: Publish the skill to your team (the Grok Bot Publish skill)
Why: Rather than everyone on the team tuning their own version, one standard skill shared by all is better. After publishing, both teammates and their Bots can use it.
On the desktop app:
- Open Connect apps, click the connected count next to the title, and open the skill you want to publish.
- Select Publish in its header. If you belong to multiple teams, choose the target team under Publish to.
Before publishing, you must fill in the description — teammates and their Bots rely on this description to judge when the skill applies, so being clear matters more than being pretty.
After publishing:
| Button/menu item | What it does |
|---|---|
| Published (button state) | Listed for the team |
| Sync | Pushes your later changes to the team's copy |
| Copy link | Copies the share link |
| Unpublish | Takes it off the shelf |
If publishing is rejected, the error message will explain why — match it to your case:
| Reason | Solution |
|---|---|
| You haven't joined a team yet | Join a team first |
| An admin has disabled member publishing | Ask an admin to publish it for you |
| The skill comes bundled with an app or a Bot template | These skills can't be published — you can build your own modeled on them |
You should see: the button changes to Published; teammates can enable it in their own Private skills.
Step 5: Use Teach a task to record a browser workflow by demonstration (Grok Bot teaching)
Why: Some workflows are harder to write out than to perform. Teach a task lets you simply demonstrate it—this is also one of the official five differentiators: Bots learn workflows through demonstration, and walking through a multi-step path once can be saved as a skill.
Follow the official six steps:
- Open a one-on-one Bot conversation and its computer view.
- Select Teach a task.
- Describe the outcome you want to teach.
- Perform the workflow once.
- Stop recording and review the skill the Bot created.
- Before scheduling it, test on a safe example first.
First, remember four hard limits:
| Limit | Content |
|---|---|
| Duration | Only records visible computer interactions, up to 10 minutes |
| Sound | Does not record the microphone—explanations rely on the text description in step 3 |
| Platform | Teaching is not available on mobile (grouped with some advanced desktop controls as unavailable on mobile); use the desktop version when needed |
| Rollout | The feature is rolling out gradually—if you don't see the control, fall back to step 1: have the Bot create a skill from written instructions and completed tasks |
⚠️ Don't expose passwords while teaching
The recording captures everything that happens on screen. The official guidance is explicit: avoid exposing secrets during teaching, and handle credentials via the secure handoff flow—store passwords in Vault and log in with Secure Form; see Vault and secure login for details.
The most important one: a learned skill is a draft. A single demonstration can't reveal decision rules, failure handling, and approval boundaries—you must fill these three in manually, test after completing them, and only after passing is it a finished product.
You should see: after stopping the recording, the Bot generates a draft skill awaiting your review; only after you complete the boundaries and it passes testing on a safe example does it deserve to be scheduled by a routine.
Checkpoint ✅
- Your saved skill has all six elements, with a name that's easy to say out loud
- Skills are invoked by name successfully;
@is only for Bots, groups, routines, and apps - When a Bot can't find a private skill, you can enable it in three steps: Connect apps → connected count → Private skills
- Published skills have a description; you know Sync pushes changes and Unpublish takes them down
- You know about teaching: ≤10 minutes, no microphone recording, learned skills are drafts, rolling out gradually (go by what your account actually shows)
Pitfall reminders
❌ Using @ to invoke a skill
Symptom: You @ the skill name in chat, and either nothing happens or it matches a different Bot.
Cause: @ targets Bots, groups, routines, and apps; skills are by design requested by name.
Correct approach: Write the skill name into a sentence—"Use the skill "Weekly account health" to check this week's data."
❌ Typing a real password into a login form while teaching
Symptom: During the demonstration, at the login step you casually enter the real password, and the screen recording captures it all.
Cause: Teaching records visible computer interactions, so everything that happens on screen goes into the demonstration; the official guidance explicitly recommends avoiding exposing secrets during teaching.
Correct approach: Handle credentials via the secure handoff flow (Vault / Secure Form); before demonstrating, decide which steps to skip or do with a test account.
❌ Scheduling a teaching draft directly
Symptom: Right after recording a version, you attach the draft skill to a routine that runs automatically every day.
Cause: A learned skill is a draft—decision rules, failure handling, and approval boundaries are incomplete; a single demonstration also can't cover exception paths.
Correct approach: Complete the three items (decision rules / failure handling / approval boundaries) → test on a safe example → only then consider automation. The order of the official six steps was set for exactly this reason.
❌ Assuming every skill can be Published
Symptom: Clicking Publish is rejected, or the button is unavailable.
Cause: Three situations can't be published—you haven't joined a team; the admin has disabled member publishing; or the skill came bundled with an app or Bot template.
Correct approach: Check the reason given in the error message; if the admin disabled it, ask the admin to publish on your behalf; bundled skills can't be modified or published, but you can model your own private version on them and publish that.
Advanced tips (optional)
Duplicate a Bot and its skills travel with it. On iPhone, Duplicate a Bot, and the copy carries over the profile, settings, enabled skills, routines, and avatar, but not conversation history, memory, or attachments—great for setups like "one account-health Bot per region." Remember to rename it and give it a new scope before assigning work.
Bot templates expose skills along with them. When you share a Bot as a template, the public link exposes the identity, description, skills, and routines—before publishing, check that nothing inappropriate is in there (API keys, internal URLs, customer data). See Bot templates for details.
Skills depend on app connections. Skills are available across Bots, but at execution time the Bot still needs the corresponding app or login. If a Bot says mid-run that it can't connect to a tool, first go to Connect apps (plugins) to connect the app, then rerun.
Lesson summary
✅ Grok Bot Skills core action: in a conversation where a task has run successfully, send a one-line ask to save the workflow as a named skill, with all six elements written out—when to use, inputs and permissions, steps, validation, return, and approval boundaries.
✅ Invocation is by name; @ is reserved for Bots, groups, routines, and apps. The private skill library is shared across all Bots; if a Bot can't find one, enable it in Private skills.
✅ Publish to the team: add a description before Publish; use Sync to push changes, Copy link to share, and Unpublish to take it offline; skills bundled with the app or with templates cannot be published.
✅ Teaching a task via Teach a task: one-on-one conversation + computer view, records visible actions for up to 10 minutes without recording the microphone; what it learns is a draft—complete the decision rules/failure handling/approval boundaries before scheduling (rolling out gradually, so go by what your account actually shows).
Quick reference for key paths:
| Action | Path/How-to |
|---|---|
| Save a skill | Send an ask in a conversation where the task ran successfully, covering the six elements |
| Invoke a skill | Ask for it by name in a sentence (no @ needed) |
| Enable private skills | Connect apps → connected count next to the title → Private skills |
| Publish to the team | Connect apps → open the skill → Publish (description required) |
| Teach a task | One-on-one conversation + computer view → Teach a task → demo it once → review the draft |
Next lesson preview
Now that the skill is saved, the next lesson sets an alarm for it: Routines: scheduled and event-triggered automation (including Webhooks).
You will learn:
- Create a routine from a conversation template and confirm 6 items: the responsible Bot, time zone, input sources, expected results, approval boundaries, and missing-data strategy
- Scheduled and event triggers: Slack messages, GitHub/Linear/Sentry/PagerDuty events, email, webhooks
- Limits and rates: up to 50 routines per Bot, scheduling interval of at least 5 minutes
- A newly created routine does not run immediately—use Test to verify it right away