> ## Documentation Index
> Fetch the complete documentation index at: https://docs.zavu.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Coding Agent Skills

> Give your AI coding agent intelligent context about the Zavu API with pre-built skills — works with 40+ agents

Coding Agent Skills provide intelligent, contextual knowledge about the Zavu API directly inside your favorite AI coding agent. Instead of searching docs or copying code snippets, your agent automatically understands channels, message types, webhook patterns, and API conventions — and writes correct code on the first try.

<Info>
  Skills provide **context and decision-making intelligence**. For direct API execution, use the [MCP Server](/tools/mcp-server). They work great together — skills tell your agent *what to do*, MCP lets it *do it*.
</Info>

## Supported Agents

Skills work with **40+ AI coding agents**. The following are always included:

<CardGroup cols={3}>
  <Card title="Amp" icon="bolt" />

  <Card title="Cline" icon="terminal" />

  <Card title="Codex" icon="code" />

  <Card title="Cursor" icon="i-cursor" />

  <Card title="Gemini CLI" icon="gem" />

  <Card title="GitHub Copilot" icon="github" />

  <Card title="Claude Code" icon="message-bot" />

  <Card title="Kimi Code CLI" icon="terminal" />

  <Card title="OpenCode" icon="code" />

  <Card title="Warp" icon="bolt" />
</CardGroup>

Plus 30+ additional agents including Antigravity, Augment, CodeBuddy, Command Code, Continue, Cortex Code, and more. During installation you can select which agents to install to.

## Install

```bash theme={null}
npx skills add zavudev/zavu-skills
```

The installer will prompt you to select which agents you want to install the skills to. Your agent will automatically load relevant skills based on what you're building.

## Available Skills

<CardGroup cols={2}>
  <Card title="Send Message" icon="paper-plane">
    Channel selection decision tree, all message types (SMS, WhatsApp, Email, Voice), error patterns
  </Card>

  <Card title="Broadcast Campaign" icon="bullhorn">
    Full broadcast lifecycle — create, add contacts, send, monitor progress, handle review
  </Card>

  <Card title="Webhook Setup" icon="webhook">
    Webhook configuration, signature verification code (TypeScript + Python), retry policy
  </Card>

  <Card title="WhatsApp Templates" icon="whatsapp" color="#25D366">
    Template creation, Meta approval workflow, OTP authentication, button types
  </Card>

  <Card title="AI Agent" icon="robot">
    Agent configuration, provider selection, conversational flows, tools, knowledge bases
  </Card>

  <Card title="Contacts Management" icon="address-book">
    Multi-channel contacts, channel operations, merge suggestions, phone introspection
  </Card>

  <Card title="Phone Numbers" icon="phone">
    Search available numbers, purchase, regulatory requirements, sender assignment
  </Card>

  <Card title="Zavu Rules" icon="book">
    Always-loaded ambient context — SDK ecosystem, auth, conventions, business rules
  </Card>
</CardGroup>

## How It Works

Skills are markdown files that your coding agent loads automatically based on your task. When you ask it to "send a WhatsApp message" or "set up webhooks", it already knows:

* Which channel to use based on message type and recipient
* The correct SDK patterns for TypeScript and Python
* Business rules like the WhatsApp 24h window and email KYC requirement
* Error codes and how to handle them
* API constraints (button limits, pagination patterns, etc.)

### Example: Channel Selection

When you ask your agent to send a message, the `send-message` skill gives it this decision tree:

```
Is recipient an email address?
  → channel = "email" (requires KYC)
Is message type non-text (image, video, buttons, etc.)?
  → channel = "whatsapp" (auto-selected)
Need voice call / TTS?
  → channel = "voice"
Want cost-optimized routing?
  → channel = "auto" (ML-powered smart routing)
Default?
  → channel = "sms"
```

Your agent uses this logic to pick the right channel without you specifying it.

## Skills + MCP Server

For the best experience, install both skills and the MCP server:

```bash theme={null}
# Skills: context and intelligence (works with 40+ agents)
npx skills add zavudev/zavu-skills

# MCP Server: direct API execution
claude mcp add --transport stdio zavudev_sdk_api \
  --env ZAVUDEV_API_KEY="your_key" -- npx -y @zavudev/sdk-mcp
```

With both installed, your coding agent can:

1. **Decide** the right approach using skills (channel selection, template vs. free-form, etc.)
2. **Execute** API calls directly using the MCP server
3. **Write** production-ready code using correct SDK patterns

## What You Can Build

Once skills are installed, try asking your agent:

<CodeGroup>
  ```text Notifications theme={null}
  "Build a Next.js API route that sends order confirmation via WhatsApp
  template, with SMS fallback for users outside the 24h window"
  ```

  ```text Webhooks theme={null}
  "Create an Express server that receives Zavu webhooks, verifies
  signatures, and stores inbound messages in Postgres"
  ```

  ```text Broadcasts theme={null}
  "Build a campaign manager that reads contacts from a CSV, creates
  a broadcast, and monitors delivery progress"
  ```

  ```text AI Chatbot theme={null}
  "Set up an AI agent with a product FAQ knowledge base that responds
  to WhatsApp messages and can look up order status via webhook"
  ```

  ```text Full Setup theme={null}
  "Set up my Zavu project: buy a US phone number, create a sender,
  configure webhooks for inbound and delivery events, and create
  an order confirmation WhatsApp template"
  ```
</CodeGroup>

## Skill Details

### Always-Loaded: Zavu Rules

The `zavu-rules` skill loads automatically in every conversation. It provides:

* **SDK init patterns** for TypeScript, Python, Go, PHP, and Ruby
* **Authentication** conventions (`ZAVUDEV_API_KEY`, key prefixes `zv_live_`/`zv_test_`)
* **E.164 phone format** and channel enum values
* **Cursor-based pagination** pattern
* **Error handling** with `APIError`
* **Key business rules** (WhatsApp 24h window, email KYC, URL verification)

### On-Demand Skills

Other skills load when your agent detects they're relevant to your task:

| Skill                 | Triggers When You...                                                               |
| --------------------- | ---------------------------------------------------------------------------------- |
| `functions`           | Build Zavu Functions: `defineAgent`, `defineTool`, `zavu deploy`, debug executions |
| `send-message`        | Build code to send messages via any channel                                        |
| `broadcast-campaign`  | Work with bulk messaging or campaigns                                              |
| `webhook-setup`       | Set up webhook endpoints or signature verification                                 |
| `whatsapp-templates`  | Create or manage WhatsApp templates                                                |
| `ai-agent`            | Configure AI agents through the imperative API (no-code / dashboard setups)        |
| `contacts-management` | Manage contacts, channels, or merge logic                                          |
| `phone-numbers`       | Search, purchase, or manage phone numbers                                          |

## Requirements

* Any supported AI coding agent (Cursor, Claude Code, Copilot, Cline, etc.)
* Node.js 18+ (for `npx skills add`)
* Optionally: `ZAVUDEV_API_KEY` environment variable (for MCP server)

## Source Code

The skills are open source. Contributions welcome:

<CardGroup cols={2}>
  <Card title="GitHub Repository" icon="github" href="https://github.com/zavudev/zavu-skills">
    View source, report issues, or contribute new skills
  </Card>

  <Card title="MCP Server" icon="robot" href="/tools/mcp-server">
    Add direct API execution to your coding agent
  </Card>
</CardGroup>