Claude Code marketing skills: what they are and which to install

Claude Code marketing skills are instruction files that live in ~/.claude/skills and teach your agent when — and exactly how — to drive marketing tools. There's no plugin store and no framework: a skill is a folder with a SKILL.md inside, and Claude Code reads it the way a new hire reads a runbook. Install the right one and the same agent that ships your features can connect Search Console, GA4, Meta Ads and Google Ads, query them with read-only SQL, and publish live dashboards. This post explains the mechanism, what marketing skills for Claude Code actually add, and walks through one end to end — the TableBI skill — from npm i to a pinned dashboard URL.

How Claude Code marketing skills work under the hood

A skill is deliberately boring technology. It's a directory under ~/.claude/skills, and the contract is a single markdown file, SKILL.md: frontmatter with a name and a description of when the skill applies, followed by a body of instructions — which commands exist, what their flags mean, which failure modes to expect. At the start of a session the agent scans only the descriptions, which is cheap. When your request matches one ("how's paid social doing?"), it pulls the full file into context and follows it.

Two consequences are worth internalizing before you install anything:

• Skills are knowledge, not integrations. A skill grants no new powers by itself — it teaches the agent to use tools that already exist on your machine. A skill without a good CLI underneath is a pamphlet; a good CLI without a skill is a tool your agent doesn't know it owns.
• The description is the trigger. A well-written skill reads like an intent map — "when the user asks about campaign performance, spend, ROAS, dashboards…" — so you can speak in your own words and the agent reaches for the right tool without being told which one.

This is also why a skill plus a CLI needs no MCP server. MCP exposes tools over a protocol you have to configure and keep running; a skill just teaches the agent to run the same commands you would type yourself. For marketing work, where the underlying operations are "connect a source, run a query, publish a report," CLI-shaped tools are a natural fit.

What a marketing skill adds to a bare agent

Out of the box, Claude Code is a strong analyst with amnesia about your channels. It knows CTR isn't CVR and that ROAS shifts when attribution windows move — but it cannot see Search Console, GA4, or a single ad account. Everything it "knows" about your marketing arrived by paste. A marketing skill closes three gaps at once:

1. Connecting sources. The agent learns the exact commands that wire up GSC, GA4, Meta Ads and Google Ads via OAuth, and how to bring CSV-only channels into the same schema.
2. Querying with agreed definitions. Instead of re-deriving ROAS slightly differently in every session, the agent queries a table where the definitions are fixed and macros compute them the same way every time.
3. Keeping outputs alive. The agent learns that an analysis doesn't have to die in terminal scrollback — it can be pinned to a URL that keeps refreshing as data syncs.

Without those three, "agent-driven marketing analytics" degenerates into a paste ritual: export a CSV, drop it in chat, re-explain the column meanings, get an answer that's stale by tomorrow. The skill mechanism is how you make the fix permanent instead of per-session.

The TableBI skill: one install, three verbs

TableBI is the data backend for your Claude Code, and its skill is a marketing skill in exactly the sense above. It teaches the agent three verbs — Pipe (connect sources once), Ask (read-only SQL over your data), Pin (publish a live dashboard) — and the commands behind each. Install takes a minute:

# install the CLI, sign in, then plant the skill
npm i -g @tablebi/cli
tablebi login
tablebi install

tablebi install drops the skill into ~/.claude/skills. From that moment the agent recognizes the whole vocabulary. Data lands in two altitudes: a unified facts table where spend is spend and clicks are clicks regardless of platform, and per-platform raw tables (search_console_raw, ga4_raw, meta_ads_raw, google_ads_raw) that preserve exactly what each platform reported. And each new session starts with one rehydration call that reloads definitions, connected sources, data freshness and the command cheatsheet:

tablebi context --json

What you can say once it's installed

The point of a skill is that you stop issuing commands and start stating intent. Three real exchanges, with what the agent runs underneath:

"Connect my Search Console." The agent knows the connector commands and that OAuth pops a browser:

tablebi connect gsc --site sc-domain:example.com
# same pattern for the rest of the stack
tablebi connect ga4
tablebi connect meta_ads
tablebi connect google_ads
# CSV-only channels normalize into the same definitions
tablebi connect csv --file tiktok-export.csv --platform tiktok_ads

"Which campaign is wasting budget?" The agent translates intent into SQL over the unified table — here, campaigns that spent money in the last 28 days without a single conversion:

tablebi ask "SELECT platform, campaign, SUM(cost) AS spend,
             SUM(conversions) AS conversions
             FROM facts WHERE date >= (SELECT MAX(date) FROM facts) - 28
             GROUP BY platform, campaign
             HAVING SUM(conversions) = 0
             ORDER BY spend DESC"

Note the date window: it anchors to MAX(date) in the data rather than the wall clock, so the answer stays honest even when a source lags a couple of days. The reply also carries a trust block — per-source freshness and caveats — so the agent reports "Meta data runs through Tuesday" instead of misreading a sync gap as a collapsed campaign.

"Pin a weekly dashboard." The agent freezes the analysis into a live, shareable page:

tablebi pin --title "Weekly marketing overview" \
  --widget "Daily spend (28d)::line=SELECT date, SUM(cost) AS spend FROM facts WHERE date >= (SELECT MAX(date) FROM facts) - 28 GROUP BY date ORDER BY date" \
  --widget "Spend by platform=SELECT platform, SUM(cost) AS spend FROM facts WHERE date >= (SELECT MAX(date) FROM facts) - 28 GROUP BY platform ORDER BY spend DESC"
✓ published → https://dk.tablebi.com/d/dsh_…  (public, read-only, self-refreshing)

The ::line suffix renders a widget as a line chart; without it you get a table. The URL is public, read-only, and refreshes itself as sources sync — here's a real one, pinned from live Search Console data exactly this way.

Bare agent vs. agent with a data backend

The difference a single skill makes is easiest to see side by side:

• Data access: pasted exports that are stale on arrival, vs. OAuth-connected sources that keep syncing.
• Definitions: metrics re-derived from memory each session, vs. macros — roas, ctr, cpa, cvr — evaluated by the SQL engine identically every time.
• Trust: no idea how fresh the numbers are, vs. a trust block on every query with freshness, caveats and lineage.
• Deliverables: screenshots and scrollback, vs. a pinned URL that's still correct next week.
• Token spend: context burned on munging CSVs, vs. reasoning over small, already-correct result sets.

We walk the full workflow — including why this beats a BI seat for agent-driven work — in Claude Code for marketing.

So which marketing skills should you install?

The honest answer: the ecosystem is young, and most "marketing skill" value today comes from one move — giving your agent trustworthy access to the numbers. Content generation and crawl analysis are things Claude Code already does bare; what it cannot do bare is see spend, clicks and conversions. So install the data-backend skill first, because every other marketing task (reporting, budget triage, SEO monitoring) sits downstream of it. If your work leans organic, the same skill covers the Search Console workflow — we've written that up separately in Claude Code for SEO — and the quickstart gets you from zero to a first query in about five minutes.

FAQ

npm i -g @tablebi/cli && tablebi install