KiraBots All-Access Skill Vault

Every KiraBots Claude skill in one vault — the complete library at the best price (less than buying the individual packs separately). Build and ship WhatsApp Business Platform integrations (Cloud API, carousels, interactive Flows, coexistence, Meta OAuth preflight), run GCC/MENA Meta-ads campaigns, design on-brand carousels, extract a consistent brand voice, drive a source-first content engine, and work the Instagram Graph API — all of it. Ten battle-tested skills that install into your Claude skills directory and activate automatically. One purchase, the whole toolkit, every future-proof workflow KiraBots ships.

This pack includes 10 Claude skills:

brand-voice, branded-carousel-generator, content-engine, gcc-meta-ads-media-buying, instagram-graph-api-playbook, meta-oauth-preflight, whatsapp-carousel-template, whatsapp-cloud-api, whatsapp-coexistence-guide, whatsapp-flows-builder

---

Brand Voice

What it does

Brand Voice is a Claude skill that turns scattered, inconsistent AI writing into a single, consistent brand voice. Instead of re-explaining "write like me" every session (which always drifts), it extracts a compact **voice profile** from real source material once, and reuses it for every future piece of content.

It gives Claude:

A **source hierarchy** for picking the right samples to learn from (real posts and essays over templates and competitors).

A checklist of **what to extract** — sentence rhythm, compression, punctuation habits, capitalization, question frequency, claim sharpness, and CTA placement.

A fixed `VOICE PROFILE` **output format** small enough to keep in context and reuse everywhere.

Two **worked examples** (a B2B practitioner founder and a warm consumer/lifestyle brand) showing exactly how specific a good profile should be.

A universal **"hard bans"** list of AI-tell phrases to delete on sight ("Excited to share", "game-changer", forced lowercase, bait questions, and more).

The result: content for X, LinkedIn, Instagram, email, and launches that all sounds like the same author — without regenerating tone from scratch each time.

How to use it

1. **Collect samples.** Gather 5-20 representative pieces of the target voice — recent posts, essays, or high-performing emails. Skip templates, generic platform examples, and competitors' content. 2. **Build the profile.** Ask Claude: *"Use the brand-voice skill to build a voice profile from these samples,"* and paste the samples in. Claude returns a structured `VOICE PROFILE`. 3. **Save the profile.** Store it in a project file, a saved note, or paste it directly into your own copy of the skill so it becomes permanent and never has to be re-derived. 4. **Apply it everywhere.** For any new content, reference the saved profile: *"Write a launch announcement using the saved voice profile."* Every draft inherits the locked tone, rhythm, and bans. 5. **Re-derive only when the real voice changes** (new positioning or audience). Otherwise treat the profile as fixed.

Tip: keep public and private/internal voices as separate profiles if the author switches registers. Pair brand-voice with a content-prep step and a cross-posting step for a full pipeline — and always run brand-voice first.

How to install it

This is a standard Claude skill. To install:

1. Unzip the package into your Claude skills directory so the files live at: `~/.claude/skills/brand-voice/` (The folder should contain `SKILL.md` alongside this `description.md` and the `README.md`.) 2. That's it — Claude auto-loads skills from `~/.claude/skills/` on the next session. No build step or restart of anything other than your Claude session is required. 3. Use it by asking naturally (e.g. "build a voice profile from these posts") or by invoking it explicitly with the Skill tool: `brand-voice`.

To confirm it loaded, start a new session and ask Claude to "use the brand-voice skill" — it should follow the extraction process and output the `VOICE PROFILE` format described above.

---

Branded Carousel Generator

What it does

Turns a small JSON spec into polished, on-brand social media graphics — single posts, multi-slide carousels, and announcements — as 1080×1350 JPGs (the canvas size is configurable). It renders in the "Intelligence Brief" visual style: a dark gradient canvas, a serif headline as the hero, an accent color for stats and chips, and a **self-drawn SVG node-network background** generated procedurally in code. No image-generation model is called, so every render is free, instant, deterministic (reproducible from a `seed`), and never produces garbled AI artifacts. Six slide types cover the common formats: `cover` (hook), `stat` (one big number), `point` (explainer), `list` (bullets), `quote` (pull-quote), and `closing` (takeaway + CTA). Every visual token — brand name, tagline, website, default handle, four colors, two fonts, and the canvas dimensions — lives in a single `brand_config.json` you edit once, so the same engine renders for any brand. The skill ships with three worked example specs and a quick-start README.

How to use it

1. Install the runtime once: `pip install pillow playwright && python3 -m playwright install chromium`. 2. Open `brand_config.json` and set your `brand_name`, `tagline`, `website`, `default_handle`, the four brand colors, and the two fonts (also point `font_css_url` at the matching Google Fonts URL so they load). 3. Write a spec JSON describing the slides, then run the renderer:

   echo '{SPEC}' | python3 scripts/render_post.py - --out ./out
   # or from a file, optionally selecting a different brand profile:
   python3 scripts/render_post.py spec.json --out ./out --brand brand_config.json

The script writes the JPGs to the `--out` folder and prints a JSON array of their paths. Carousel slides are numbered in order (`_01`, `_02`, …) — upload them in that order to Instagram, LinkedIn, or any platform. Start from the three ready-to-run files in `examples/` (`single_post.json`, `carousel.json`, `announcement.json`) and the `README.md` quick start.

How to install it

This is a Claude skill. Unzip the package into your Claude skills directory so the folder lives at `~/.claude/skills/branded-carousel-generator/` (it must contain `SKILL.md`, `brand_config.json`, the `scripts/` folder, the `examples/` folder, and this file). Claude auto-loads skills from that directory on the next session — no further configuration is needed. You can then invoke it via the Skill tool (or it triggers automatically on requests like "make a post" or "create a carousel"). The Python runtime dependencies (`pillow`, `playwright`, and the Chromium browser) must be installed once as shown in the "How to use it" section above.

---

Content Engine

What it does

Content Engine is a Claude skill that turns real source material — blog posts, demos, transcripts, notes, campaign results — into platform-native content for X, LinkedIn, Instagram, TikTok, YouTube, and newsletters, without flattening the author's voice.

It encodes a repeatable methodology, not templates:

**Source-first** — starts from your actual material, never from generic templates.

**Atomic claims** — extracts 3–7 sharp, specific claims and ranks them by novelty,

not by their order in the source.

**One platform, one idea** — assigns the strongest claim to your primary platform

and adapts the rest, so nothing is duplicated verbatim.

**Platform rules** — concrete do/don't guidance per platform (compress on X, use

white space on LinkedIn, payoff-in-3-seconds on short video, one claim per carousel slide on Instagram, etc.).

**Funnel-aware language** — picks the language register and (for multilingual

markets) the actual language by funnel stage: TOFU, MOFU, BOFU.

**Agency / multi-product playbook** — one product per post, personal vs brand

voice per channel, mention the product at the end as a natural conclusion.

**Quality gate** — a checklist every output must pass before delivery: same author

voice, no padding, no duplicated copy, no invented CTAs.

The result is content that sounds like a person, fits each platform natively, and avoids the usual AI tells ("game-changer", forced closing questions, fake casualness).

How to use it

1. Make sure the skill is installed (see "How to install it"). 2. Give Claude your source material and the platforms you want. Example:

> Turn this launch post into an X thread, a LinkedIn post, and an Instagram > carousel. Keep my voice — plain and direct. Source: [paste material]

3. Optionally set parameters for repeatable output: primary platform, the voice for each channel (personal vs brand), the funnel stage, and the language per stage. 4. Claude extracts the atomic claims, assigns them to platforms, writes native variants, and runs the quality gate before returning the content.

See `README.md` for a 60-second quick start and three worked examples (blog post → 3 platforms, demo transcript → short-video script, and an agency multilingual setup). See `SKILL.md` for the full methodology, all platform rules, and the quality-gate checklist.

How to install it

This is a Claude skill. Install it into your Claude skills directory:

1. Unzip the package into `~/.claude/skills/content-engine/` so that `~/.claude/skills/content-engine/SKILL.md` exists.

   mkdir -p ~/.claude/skills/content-engine
   unzip content-engine.zip -d ~/.claude/skills/content-engine/

2. The skill auto-loads — Claude detects it on the next session. You can also invoke it explicitly with the Skill tool by name (`content-engine`), or simply describe a content task ("turn this into an X thread and a LinkedIn post") and Claude will apply it.

No dependencies, API keys, or configuration are required — the skill is pure methodology in Markdown.

---

GCC Meta Ads Media Buying

What it does

This is a Claude skill that turns Claude into an expert media buyer for the GCC (Gulf) markets — Kuwait, Saudi Arabia, UAE, Qatar, Bahrain, and Oman — running Meta (Facebook/Instagram) ads.

It packages regional intelligence that normally takes years of spend to learn:

**Live GCC benchmarks** — CPM, CPC by industry, CPL and ROAS targets, and CTR/CPC pause thresholds per country.

**Ad-format performance rankings** — when to use UGC vs carousels vs Reels vs stories vs static, with the real reach/conversion/CPA deltas behind each.

**Instagram/Meta algorithm facts (2025-2026)** — what the algorithm actually rewards (DM shares, saves, watch time, original content, 4:5 ratio), recent API/metric changes, and Advantage+ vs manual guidance.

**GCC scheduling intelligence** — peak engagement windows in Kuwait time, best/worst days, and a full **Ramadan dayparting playbook** (the single biggest GCC advertising window).

**A decision engine** — explicit rules for when to PAUSE immediately, when to pause/scale only with human approval, when to refresh creative, and when to launch a new test.

**Creative specs, hook formulas (Arabic + English), CTA rules, campaign-naming standards, cross-GCC budget splits, and a Meta Graph API quick reference.**

The result: Claude can audit a running campaign, plan a region-wide launch, pick the right format for a funnel stage, scale winners safely, and write GCC-native ad copy — all grounded in regional data rather than generic Western ad advice.

How to use it

Once installed, the skill auto-activates whenever you ask Claude about Meta ads, campaign management, media buying, ad creative, audience targeting, budget optimization, or campaign analysis for GCC markets. You can also invoke it explicitly with the Skill tool: `Skill(skill="gcc-meta-ads-media-buying")`.

One-time setup: open `SKILL.md` → **How to Wire Your Ad Accounts** and replace the placeholders (`act_YOUR_AD_ACCOUNT`, `YOUR_BM_ID`, `YOUR_PIXEL_ID`, your `META_SYSTEM_TOKEN` env var, and your WhatsApp/landing URLs) with your own values. Keep tokens in an environment variable or secret manager — never hardcode them.

Then just ask in plain language, for example:

"My Kuwait lead-gen campaign has spent $180, ROAS 1.7, CTR 0.4% after 6,000 impressions — what do I do?"

"Build a Ramadan campaign plan for a skincare brand, $3,000, Saudi + UAE + Kuwait."

"Cold traffic in Kuwait, never advertised — which creative format?"

"Campaign at 5.2x ROAS for 4 days — can I 3x the budget?"

"Give me the Graph API call for last-7-days campaign insights on act_123."

See `README.md` for full worked examples and the exact rules the skill applies to each.

How to install it

This is a Claude skill. Unzip it into your Claude skills directory and it auto-loads:

unzip gcc-meta-ads-media-buying.zip -d ~/.claude/skills/

This creates `~/.claude/skills/gcc-meta-ads-media-buying/` containing `SKILL.md` (the skill), `README.md`, and this `description.md`. Claude Code automatically discovers any skill under `~/.claude/skills/` — no further configuration is required to make it loadable. To use it, either let it trigger automatically on a matching request or call it directly via the Skill tool: `Skill(skill="gcc-meta-ads-media-buying")`.

---

Instagram Graph API Playbook

A production-hardened Claude skill that turns the messy, error-prone Instagram Graph API into a step-by-step playbook — built from real shipping experience, with the exact failures and fixes the official docs never mention.

What it does

It gives Claude (and you) a complete, battle-tested reference for building Instagram integrations on top of the Meta/Facebook Graph API. Whenever you connect an Instagram account, build an Instagram feature, or hit a cryptic Graph API error, Claude loads this knowledge and answers with the correct endpoints, scopes, payloads, and fixes instead of guessing.

It covers, end to end:

**Connecting accounts** — both the OAuth flow (~60-day user tokens) and never-expiring System User tokens, including the exact `/me/accounts` step needed to get a real Page Access Token.

**Webhooks** — the two separate subscriptions (app-level once, Page-level per account), signature verification, and the verification handshake.

**Publishing** — the two-step container → publish process, public-URL requirement, and image/video constraints.

**Comments** — fetching and replying.

**DMs via webhooks** — the routing, the `entry.id = IG User ID` trap, echo detection, the only send endpoint that actually works (`/{page_id}/messages`), and the 24-hour window rule.

**Insights & feed sync** — pulling follower growth, engagement, and media into your own store.

**Dashboard/UI patterns** — account selection, a single API helper, and the HTML `onclick` encoding bug that silently breaks DM threads.

**A debugging checklist** mapping every common Graph API error code (`#9007`, `#352`, `#3`, "Object with ID 'me' does not exist", expired-token messages) to its real cause and fix.

It includes 8 copy-paste worked examples (cURL and Python) so you can go from zero to a published post and a live DM auto-reply quickly.

How to use it

1. Install the skill (see below). Claude auto-loads it when your request involves Instagram, the Meta/Facebook Graph API, OAuth for Pages, publishing, comments, DMs, insights, or webhooks. 2. Ask naturally, e.g. "connect this Instagram account with a system user token", "my IG DM replies aren't sending", "publish this image to Instagram", or "set up Instagram comment webhooks". 3. Claude responds using the playbook — correct scopes, endpoints, payloads, and the relevant gotcha. For hands-on work, open `EXAMPLES.md` and copy the snippet you need. 4. Replace every placeholder with your own values before running anything:

`YOUR_META_APP_ID`, `YOUR_META_APP_SECRET`, `YOUR_WEBHOOK_VERIFY_TOKEN`, `YOUR_DOMAIN`, `YOUR_PAGE_ID`, `YOUR_IG_USER_ID`, `@your_handle`.

Keep the App Secret and all tokens in environment variables or a secret manager — never in source control.

Prerequisites: a Meta App (App ID + Secret), an Instagram **Business or Creator** account linked to a Facebook Page, and a public HTTPS domain for the webhook callback.

How to install it

This is a Claude skill — installing it just means placing the folder where Claude looks for skills.

1. Unzip the package so its contents live at:

   ~/.claude/skills/instagram-graph-api-playbook/

The folder should contain `SKILL.md`, `EXAMPLES.md`, `README.md`, and `description.md`. 2. That's it — the skill auto-loads. Claude reads the `name` and `description` from `SKILL.md` and activates the skill automatically when a request matches (Instagram / Meta Graph API / OAuth / publishing / DMs / webhooks / insights). 3. To invoke it explicitly, use the Skill tool with the name `instagram-graph-api-playbook`, or just describe an Instagram Graph API task and Claude will pull it in.

No build step, dependencies, or API keys are required to install the skill itself. Your own Meta App credentials are only needed when you actually run the integration.

---

Meta OAuth Preflight

What it does

Meta OAuth Preflight is a Claude skill that turns the painful, trial-and-error process of wiring up a Meta / Facebook / Instagram OAuth login into a deterministic checklist. It encodes the hard-won knowledge of what actually breaks Meta OAuth integrations and gives Claude an exact diagnosis path for the four failure modes that derail almost every implementation:

**Bad `redirect_uri`** — "URL blocked" / "domain not included in the app's domains"

**"Unauthorized" callbacks** — the callback path isn't whitelisted as a public route

**Silent redirects that go nowhere** — the proxy drops the `Location` header on the OAuth 302

**`config_id` vs `scope`** — using `scope=` instead of a Login-for-Business `config_id`, which

silently returns a token missing the permissions you need

It also covers a 6-point pre-flight checklist (redirect URI, web-tier public paths, backend public paths, `config_id` usage, proxy header forwarding, and App Domains), a quick failure-mode diagnosis table, three worked examples (a happy-path Instagram connect, an "Unauthorized" debug, and a "redirect goes nowhere" debug), a fix for `ERR_CONNECTION_REFUSED` during heavy testing, and a clean pattern for labeling/routing connected accounts without environment variables.

How to use it

Once installed, the skill loads automatically and Claude consults it whenever you work on a Meta OAuth flow. Start a request like:

"Add an Instagram OAuth connect flow to my app."

"My Meta OAuth callback returns Unauthorized — help me debug it."

"After Facebook consent the redirect goes nowhere, what's wrong?"

"Why does my OAuth token come back missing permissions?"

You can also invoke it explicitly via the Skill tool by name (`meta-oauth-preflight`).

Before applying the steps, substitute the documented placeholders for your own values: `YOUR_DASHBOARD_DOMAIN`, `YOUR_API_DOMAIN`, `YOUR_META_APP_ID`, `YOUR_META_APP_SECRET`, `YOUR_CONFIG_ID`, `YOUR_ROOT_DOMAIN`, and your own OAuth route paths. The skill is framework-agnostic — the grep commands and patterns adapt to whatever web server, backend, and proxy you run. Keep your app secret in an environment variable or secret manager; the skill never asks you to hardcode it.

How to install it

This is a standard Claude skill distributed as a folder.

1. Unzip the package so its contents live at `~/.claude/skills/meta-oauth-preflight/` (the folder should contain `README.md` and `description.md`). 2. That's it — Claude Code auto-loads skills from `~/.claude/skills/` on startup. No build step, no configuration. 3. To use it, just describe a Meta OAuth task in chat, or invoke it by name (`meta-oauth-preflight`) with the Skill tool.

To verify installation, run `ls ~/.claude/skills/meta-oauth-preflight/` and confirm `README.md` is present. If skills were already loaded, restart your Claude Code session so the new skill is picked up.

---

WhatsApp Carousel Template Builder

What it does

This is a Claude skill that gives Claude the complete, battle-tested knowledge to build, submit, and track **WhatsApp Carousel message templates** on the Meta WhatsApp Business Platform — the multi-card format of 2–10 horizontally swipeable cards, each with an image, a short body, and a URL button.

It encodes the things people get wrong:

The critical distinction between a **carousel template** (pre-approved, works for cold

outreach with no open conversation window) and an **interactive carousel** (runtime only, works inside the 24-hour window) — so Claude always picks the right one.

Meta's exact rules and limits: 2–10 cards, ≤160-char card bodies, ≤20-char button

labels, ≤1024-char intro body, homogeneous cards (same button type and structure), and image specs (JPEG/PNG, ≤5MB, 1.91:1 or 1:1).

The two-step build flow: upload each image to get a `media_handle`, then submit the

assembled carousel — in the same session, because handles expire.

The approval lifecycle (`pending` → `approved`/`rejected`) and how to poll/sync it.

A generic DB storage pattern, a localization note (incl. RTL / Arabic), a full worked

3-card example, and a failure-mode troubleshooting table.

The result: fewer Meta rejections, correct copy lengths the first time, and a clean upload-then-submit flow you can run by hand or wire into your own backend.

How to use it

Once installed, the skill loads automatically when your request matches it. Just ask Claude in natural language, for example:

"Create a WhatsApp carousel template with 3 product cards and URL buttons."

"Should I use a carousel template or an interactive carousel for this campaign?"

"Meta rejected my carousel — what's wrong?"

"Write the upload + create API calls for a 4-card carousel."

Claude will plan the cards within Meta's limits, walk through the upload-then-submit steps, and tell you what to check for approval. You can also invoke it explicitly with the Skill tool using the name `whatsapp-carousel-template`.

The skill is backend-agnostic: it uses placeholders (`YOUR_DOMAIN`, `YOUR_API_KEY`, `YOUR_TENANT_ID`) that you replace with your own API gateway / WhatsApp integration values.

How to install it

This is a Claude skill, so installation just means placing the folder where Claude looks for skills:

1. Unzip the package into your skills directory so the path is `~/.claude/skills/whatsapp-carousel-template/` and that folder contains `SKILL.md`. 2. That's it — Claude auto-loads skills from `~/.claude/skills/` on the next session. 3. To use it, either ask a matching question (it activates by description) or invoke it explicitly via the Skill tool with the name `whatsapp-carousel-template`.

No build step, no dependencies, no API keys are bundled — you supply your own backend endpoints and credentials when you use it.

---

WhatsApp Cloud API Skill

What it does

Turns Claude into a WhatsApp Business Platform (Meta Cloud API) expert. It knows the rules that make WhatsApp integrations succeed — and, more importantly, the rules whose violation makes them fail silently. The skill covers:

**Message templates** — naming rules, component structure (header/body/footer/buttons), the three

categories (MARKETING / UTILITY / AUTHENTICATION), variable rules, and the media-header gotcha that causes most template rejections.

**Media messages** — sending images, videos, and documents (upload-then-send and send-by-URL), with

exact size limits and payload shapes.

**Product catalog messages** — single-product and multi-product list messages, with the catalog/SKU

requirements.

**The 24-hour customer service window** — the rule that decides when you can send free-form messages

versus when you must use an approved template, with a decision tree.

**The Meta error catalog** — a lookup table mapping the codes you actually hit in production

(132000, 132012, 132018, 131009, 131047, 131042, and more) to their real root cause and the fix, plus a deep-dive on the recurring 132012 (media-header template sent with body-only components).

**Three worked examples** — send an approved template, send a media message, and debug a 132012 end

to end with reproduce → inspect → fix curls.

The payoff: Claude writes correct WhatsApp payloads the first time and debugs failures by error code instead of guessing.

How to use it

Once installed, the skill activates automatically whenever you discuss WhatsApp Cloud API work — creating templates, sending media or catalog messages, or debugging a Meta error code. You can also invoke it explicitly with the Skill tool (`whatsapp-cloud-api`).

Everything is genericized with placeholders (`YOUR_PHONE_ID`, `YOUR_ACCESS_TOKEN`, `YOUR_WABA_ID`, `YOUR_CATALOG_ID`, `RECIPIENT_E164`, `GRAPH_VERSION`). Replace them with your own Meta values before running any command, and keep tokens in environment variables rather than in source.

Typical prompts:

"Create a UTILITY template that confirms an order and has a tracking-URL button."

"My VIDEO-header template fails with 132012 on every send — fix the payload."

"Send product SKU-12345 from my catalog to this customer."

"Why does my message return 131047, and how do I send it correctly?"

Claude pulls the exact payload, validation rule, or error-code fix from the skill and applies it to your case. See `README.md` for the full quick-start and a map of the skill's sections.

How to install it

This is a Claude skill, so installation is just placing the folder where Claude auto-loads skills:

unzip whatsapp-cloud-api.zip -d ~/.claude/skills/
# results in: ~/.claude/skills/whatsapp-cloud-api/skill.md

Restart Claude Code (or your Claude client) so it picks up the new skill. It then loads automatically when relevant, and you can invoke it directly via the Skill tool using the name `whatsapp-cloud-api`. No dependencies, no build step — the skill is plain Markdown knowledge.

---

WhatsApp Coexistence Guide

What it does

This is a Claude skill that gives Claude expert, battle-tested knowledge of **WhatsApp coexistence mode** — running one phone number on both the WhatsApp Business App (the owner's mobile app) and the WhatsApp Cloud API at the same time. It is a compact bonus/add-on reference for anyone building on the WhatsApp Cloud API.

When loaded, it lets Claude:

Explain exactly what coexistence is and its hard Meta limits (20 msg/sec cap, 1:1 only, ~6 months one-time history sync).

Walk through onboarding a number into coexistence (manual/admin flow, app-owner path, and Embedded Signup path).

Identify the coexistence-only webhook fields (`history`, `smb_app_state_sync`, `smb_message_echoes`) and how each behaves.

Debug the common failures: history that never imports, business-sent replies that never appear, media placeholders, and offboarding.

It includes the gotchas that normally cost a day of debugging — most notably that the `smb_message_echoes` webhook value uses the `message_echoes` key (not `messages`), the strict 24h history window, and the requirement that chat backup be enabled before onboarding. Two worked debugging examples are included.

All vendor-specific identifiers are placeholders (`YOUR_META_APP_ID`, `YOUR_COEXISTENCE_CONFIG_ID`, `{phone_number_id}`) — drop in your own values.

How to use it

1. After installing, the skill auto-loads and Claude will draw on it whenever your request involves WhatsApp coexistence — for example: "onboard this number in coexistence mode", "old chats didn't sync", "the owner's phone replies aren't showing in our inbox", or "how do I offboard a coexistence number". 2. You can also invoke it explicitly with the Skill tool by its name, `whatsapp-coexistence-guide`. 3. Replace the placeholders (`YOUR_META_APP_ID`, `YOUR_COEXISTENCE_CONFIG_ID`, `{phone_number_id}`, and your own data-model flags such as the bot-active flag and `waba_id` column) with your platform's real values when applying the guidance. 4. Use the two worked examples as step-by-step debugging checklists when a sync or echo problem appears.

See `README.md` for a quick-start summary and the placeholder table.

How to install it

This is a Claude skill. To install:

1. Unzip the package into your Claude skills directory so the files live at `~/.claude/skills/whatsapp-coexistence-guide/` (the folder must contain `SKILL.md`). 2. That's it — Claude auto-loads skills from `~/.claude/skills/` on the next session. No build step or restart configuration is required. 3. To confirm, start a new session and either ask a WhatsApp coexistence question or invoke the skill by name (`whatsapp-coexistence-guide`) via the Skill tool.

---

WhatsApp Flows Builder

A Claude skill that turns Claude into an expert at building **WhatsApp Flows** — Meta's interactive in-chat forms (radio menus, dropdowns, text/date inputs, multi-screen wizards) for any WhatsApp Business number.

What it does

It gives Claude a complete, production-tested playbook for the full WhatsApp Flow lifecycle, so it can build flows correctly the first time instead of rediscovering Meta's quirks by trial and error. Specifically, the skill teaches Claude to:

**Design the right architecture** — when to answer with a plain text reply vs a flow, how to size menus to Meta's 9-option radio limit, and when to split into a Language Selection flow plus sub-flows.

**Handle bilingual audiences correctly** — a hard rule against mixing two languages on one screen, plus the "Language Selection → fully-monolingual flows" isolation pattern (with copy-paste language helper code) that prevents the most common UX failure.

**Author valid Meta Flow JSON (v7.1)** — every component (RadioButtonsGroup, Dropdown, TextInput, TextArea, DatePicker, text displays, navigate/complete Footers), the `terminal`/`complete` rules, and naming conventions Meta enforces.

**Publish and route** — insert as draft, publish to Meta, wire the language chain, and set the per-number routing flag (`response_mode`) that is the single most common reason a flow "doesn't work."

**Handle submissions** — a full submission-handler pattern with account guarding, flow-name matching, fallbacks, async-safe notifications, a mandatory "What's Next" follow-up, and PII redaction.

**Avoid the known traps** — a curated table of the mistakes everyone hits (immutable published flows, blocked event loops, brittle name matching, missing fallbacks, Unicode escaping, and more) with the exact fix for each.

It ships with five ready-to-adapt example files: a single-menu flow, a bilingual language-selection flow, a multi-screen booking wizard, a "What's Next" flow, and a complete submission handler in Python.

How to use it

Once installed, the skill activates automatically whenever you ask Claude to build, set up, design, or wire WhatsApp Flows — for example: "Build a WhatsApp Flow with a main menu and a call-back form," "Add an Arabic + English booking flow to my WhatsApp number," or "Why does my published flow's edit not take effect?"

You can also invoke it explicitly with the Skill tool (`whatsapp-flows-builder`).

Claude will follow the step-by-step process: design → author the JSON (starting from the examples) → publish → set routing → write the submission handler → verify. Provide your `phone_number_id`, `waba_id`, and how your backend stores flows, and Claude will map the generic data model (`flows`, `flow_submissions`, `numbers`) onto your stack. Replace the placeholders (`YOUR_PHONE_ID`, `YOUR_WABA_ID`, `YOUR_TENANT_ID`, `YOUR_ACCESS_TOKEN`, `YOUR_API_BASE`, `YOUR_API_KEY`) with your real values, and never commit real access tokens.

How to install it

This is a Claude skill. To install it:

1. Unzip the package into your Claude skills directory so the files live at `~/.claude/skills/whatsapp-flows-builder/` (the folder should contain `SKILL.md`, `README.md`, `description.md`, and the `examples/` directory). 2. That's it — Claude auto-loads skills from `~/.claude/skills/` on the next session, and the skill activates on relevant requests. 3. To run it on demand, invoke it via the Skill tool with the name `whatsapp-flows-builder`.

No dependencies, no build step, no API keys required to install. The skill is documentation-only; it instructs Claude and provides example files you adapt to your own backend.

---

Delivered as a ZIP of Claude skill folders. Unzip into your Claude skills directory; each skill auto-loads on the next session.