Building Your First OpenClaw Skill for Slack

What Is an OpenClaw Skill?

Before writing a single line of code, it helps to understand what you're actually building. In OpenClaw, a skill is a reusable, composable unit of agent behavior. Think of it as a function with intent — it describes what the agent should accomplish, which tools it can use to do it, and how it should behave when things go sideways.

When you deploy a skill through SlackClaw, your Slack workspace gains a new capability that the autonomous agent can invoke on demand — either when a user explicitly asks for it, or when the agent determines it's the right tool for the job based on context. Because SlackClaw runs on a dedicated server per team, your skill logic stays isolated, fast, and secure. No shared infrastructure, no noisy neighbors.

Skills can be as simple as "fetch the weather and post it to #general every morning" or as complex as "triage incoming support tickets, cross-reference them against open GitHub issues, update the relevant Linear project, and draft a response for the customer success team to review." The architecture is the same either way.

Setting Up Your Development Environment

Prerequisites

You'll need a few things before you start:

• Node.js 18+ (or Python 3.10+ if you prefer the Python SDK)
• An active SlackClaw workspace with at least one integration connected
• The OpenClaw CLI installed globally: npm install -g @openclaw/cli
• Your SlackClaw API key, available in Settings → Developer → API Keys

Initializing a Skill Project

The OpenClaw CLI does the heavy lifting for project scaffolding. Run this in your terminal:

openclaw init my-first-skill
cd my-first-skill
openclaw auth --key YOUR_API_KEY

This creates a project directory with a skill.config.json, a handlers/ folder, and a README.md that documents your skill's inputs and outputs. The config file is where most of the important decisions live.

Anatomy of a Skill Config

Open skill.config.json and you'll see a structure like this:

{
  "name": "weekly-standup-digest",
  "description": "Summarizes team activity from GitHub, Linear, and Notion and posts a digest to Slack every Monday morning.",
  "triggers": ["schedule:monday-9am", "user:!standup-digest"],
  "tools": ["github", "linear", "notion", "slack"],
  "memory": {
    "enabled": true,
    "scope": "team",
    "ttl": "30d"
  },
  "outputChannel": "#engineering",
  "autonomyLevel": "supervised"
}

Let's break down the key fields:

• triggers — What causes this skill to run. You can use schedules (cron-style), user commands (prefixed with !), or event-based triggers like event:github.pr.opened.
• tools — The integrations this skill is allowed to use. SlackClaw supports 800+ tools via one-click OAuth, so you're not reinventing auth flows for each one.
• memory — Whether the skill reads from and writes to persistent context. This is one of SlackClaw's most powerful features: the agent remembers what it learned last week, last month, or in a completely different skill run.
• autonomyLevel — "supervised" means the agent will ask for confirmation before taking irreversible actions. "autonomous" lets it run without interruption. Start with supervised while you're testing.

Writing Your First Handler

Handlers are where your skill's logic lives. Inside handlers/main.js, you'll write the steps the agent executes when the skill is triggered.

import { useTools, useMemory, useSlack } from '@openclaw/sdk';

export default async function handler(ctx) {
  const { github, linear, notion } = await useTools(ctx);
  const memory = useMemory(ctx);
  const slack = useSlack(ctx);

  // Pull recent activity
  const prs = await github.listPullRequests({ state: 'open', updatedSince: '7d' });
  const issues = await linear.listIssues({ assignee: 'team', updatedSince: '7d' });
  const pages = await notion.listPages({ updatedSince: '7d' });

  // Check memory for last digest timestamp to avoid duplicates
  const lastRun = await memory.get('last_digest_timestamp');
  const newActivity = filterAfter([...prs, ...issues, ...pages], lastRun);

  // Build and send the digest
  const digest = await ctx.agent.summarize(newActivity, {
    format: 'slack-blocks',
    tone: 'professional',
    maxLength: 400
  });

  await slack.postMessage({ channel: '#engineering', blocks: digest });

  // Update memory so next run knows where to pick up
  await memory.set('last_digest_timestamp', new Date().toISOString());
}

A few things worth noting here. The useTools hook automatically handles OAuth token refresh — you never touch credentials directly. The useMemory hook gives you a persistent key-value store scoped to your team, which survives across skill runs, server restarts, and even updates to the skill itself. The ctx.agent.summarize call invokes the underlying language model to do the heavy lifting of synthesis, so you're not writing prompt engineering logic inline. Learn more about our security features.

Connecting Integrations

One-Click OAuth in Practice

Before your skill can call github or linear, those integrations need to be authorized in your SlackClaw workspace. Navigate to Integrations → Browse and you'll find the full catalog. Click Connect next to GitHub, authorize the OAuth flow, and that's it. The connection is available to every skill your team builds from that point forward. Learn more about our pricing page.

This matters more than it might seem. In most agent frameworks, every developer on the team has to manage their own credentials, rotate tokens, and handle edge cases when integrations change their auth requirements. With SlackClaw, the workspace owns the connection. Your skills just declare which tools they need, and the platform handles the rest.

Scoping Tool Permissions

When you list a tool in skill.config.json, you can scope the permissions granularly:

"tools": [
  { "name": "github", "scopes": ["read:repo", "read:pr"] },
  { "name": "jira", "scopes": ["read:issue", "write:comment"] },
  { "name": "gmail", "scopes": ["read:inbox"] }
]

Principle of least privilege applies here. If your standup digest only needs to read GitHub pull requests, don't grant write access just because it's available. This keeps your skill auditable and reduces the blast radius if something unexpected happens.

Using Persistent Memory Effectively

Persistent memory is what separates a useful Slack bot from a genuinely intelligent agent. Without memory, every skill run starts cold — the agent has no context about what happened yesterday, what your team's priorities are, or what it already told someone last Tuesday.

With SlackClaw's memory layer, you can store structured context that accumulates over time:

// Store team preferences discovered during a run
await memory.set('team.preferred_summary_style', 'bullet-points');

// Store long-running project context
await memory.set('project.apollo.status', {
  lastUpdated: new Date().toISOString(),
  blockers: ['waiting on design review', 'API rate limit issue'],
  owner: 'maya@company.com'
});

// Retrieve it in a completely different skill
const projectContext = await memory.get('project.apollo.status');

A practical pattern is to use memory as a team knowledge base that skills contribute to and read from. Your standup digest skill writes what it learned about project status. Your incident response skill reads that context before drafting a postmortem. Your weekly review skill pulls the last month of accumulated entries to generate an executive summary. The skills become more useful the longer your team uses them — because the memory grows richer over time.

Testing and Deploying Your Skill

Local Testing

Run your skill locally against real (or stubbed) tool connections before deploying: For related insights, see OpenClaw for Slack: A Manager's Guide to AI Adoption.

openclaw dev --skill ./skill.config.json --dry-run

The --dry-run flag prevents any write operations — posts won't be sent to Slack, comments won't be created in Jira — but the skill will execute fully and show you exactly what it would have done. This is invaluable for debugging handler logic without spamming your team's channels.

Deploying to Your Workspace

When you're confident the skill works as intended:

openclaw deploy --workspace your-workspace-slug

The CLI packages your handlers, validates the config, and pushes the skill to your dedicated SlackClaw server. Deployment typically takes under 30 seconds. Once deployed, the skill appears in your workspace's Skills dashboard, where you can enable or disable it, review run history, and inspect memory usage.

Tip: SlackClaw uses credit-based pricing, not per-seat fees. This means deploying a skill that the whole team benefits from costs the same whether it's used by two people or twenty. It makes sharing skills across departments genuinely economical, instead of a budget conversation every time you want to automate something new.

Where to Go From Here

The standup digest example is intentionally simple, but the same patterns scale to surprisingly complex workflows. Some directions worth exploring once you're comfortable with the basics: For related insights, see OpenClaw Slack + Google Drive Integration: File Management.

• Event-driven skills — Trigger a skill whenever a PR is marked "Ready for Review" in GitHub, automatically cross-posting to the right Slack channel and tagging the assigned reviewer
• Multi-step approval workflows — Use autonomyLevel: "supervised" with interactive Slack Block Kit components so the agent presents options and a human confirms before it writes back to Jira or sends an email via Gmail
• Cross-tool synthesis — Build skills that connect Notion documentation, Linear roadmap items, and Slack conversation history to answer questions like "what was the reasoning behind this architectural decision?"
• Onboarding automation — A skill that detects new team members, creates their Notion onboarding page, invites them to the right Slack channels, and opens a kickoff issue in Linear — all from a single Slack trigger

The OpenClaw skill system is deliberately minimal in what it prescribes and generous in what it permits. Once you understand triggers, tools, handlers, and memory, the main constraint is imagination — and the 800+ integrations available in SlackClaw mean you're rarely blocked by a missing connection. Start small, deploy something useful this week, and let the memory layer do its job of making your agent smarter over time.