I Built a Claude Skill That Runs My Facebook Ads — Here's the Code

.claude/skills/fb-ads/
  SKILL.md          ← instructions Claude reads
  index.ts          ← the actual tool implementation
  types.ts          ← shared types

# Facebook Ads Manager Skill

Use this skill when the user says "check my ads", "run ads report",
"pause underperformers", or "write new ad copy". Never run this
without explicit user instruction — it touches live ad spend.

## What it can do
- Pull performance data for all active ad sets (last 7 or 30 days)
- Flag ad sets with ROAS < 1.5 or CTR < 0.8% as underperformers
- Rewrite ad copy for flagged creatives in Ale's voice
- Create new ad sets with revised copy (PAUSED by default — you approve before activating)

## What it will NOT do
- Change budgets on live ad sets without explicit confirmation
- Activate new ad sets automatically
- Delete anything

// .claude/skills/fb-ads/index.ts
import Anthropic from "@anthropic-ai/sdk";

const BASE = "https://graph.facebook.com/v20.0";
const TOKEN = process.env.META_ACCESS_TOKEN!;
const ACCOUNT = process.env.META_AD_ACCOUNT_ID!;

interface AdSetPerformance {
  id: string;
  name: string;
  status: string;
  spend: number;
  impressions: number;
  clicks: number;
  conversions: number;
  roas: number;
  ctr: number;
  cpc: number;
}

async function getAdSetPerformance(days = 7): Promise<AdSetPerformance[]> {
  const fields = [
    "id", "name", "status",
    "insights.date_preset(last_" + days + "d){spend,impressions,clicks,actions,action_values}"
  ].join(",");

  const url = `${BASE}/${ACCOUNT}/adsets?fields=${encodeURIComponent(fields)}&access_token=${TOKEN}&limit=100`;
  const res = await fetch(url);
  const data = await res.json();

  return (data.data ?? []).map((adset: any) => {
    const ins = adset.insights?.data?.[0] ?? {};
    const spend = parseFloat(ins.spend ?? "0");
    const impressions = parseInt(ins.impressions ?? "0");
    const clicks = parseInt(ins.clicks ?? "0");
    const purchaseValue = (ins.action_values ?? [])
      .filter((a: any) => a.action_type === "purchase")
      .reduce((s: number, a: any) => s + parseFloat(a.value), 0);
    const purchases = (ins.actions ?? [])
      .filter((a: any) => a.action_type === "purchase")
      .reduce((s: number, a: any) => s + parseInt(a.value), 0);

    return {
      id: adset.id,
      name: adset.name,
      status: adset.status,
      spend,
      impressions,
      clicks,
      conversions: purchases,
      roas: spend > 0 ? purchaseValue / spend : 0,
      ctr: impressions > 0 ? (clicks / impressions) * 100 : 0,
      cpc: clicks > 0 ? spend / clicks : 0,
    };
  });
}

async function getAdCreatives(adsetId: string): Promise<{ id: string; body: string; title: string }[]> {
  const url = `${BASE}/${adsetId}/ads?fields=creative{body,title}&access_token=${TOKEN}`;
  const res = await fetch(url);
  const data = await res.json();
  return (data.data ?? []).map((ad: any) => ({
    id: ad.id,
    body: ad.creative?.body ?? "",
    title: ad.creative?.title ?? "",
  }));
}

async function rewriteCopy(original: { body: string; title: string }, context: string): Promise<{ body: string; title: string }> {
  const client = new Anthropic();
  const msg = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 512,
    messages: [{
      role: "user",
      content: `You are rewriting a Facebook ad in Alejandro Rioja's voice: direct, operator-focused, no hype, results-first. The ad is underperforming. Context: ${context}

Original title: ${original.title}
Original body: ${original.body}

Rewrite it. Keep it under 90 words for the body. Make the headline a specific outcome or number. Return JSON: {"title": "...", "body": "..."}`
    }]
  });
  const text = (msg.content[0] as any).text.replace(/```json\n?/, "").replace(/```/, "").trim();
  return JSON.parse(text);
}

export async function runAdsReport(days = 7) {
  const adsets = await getAdSetPerformance(days);
  const active = adsets.filter(a => a.status === "ACTIVE");
  const underperformers = active.filter(a => a.roas < 1.5 || a.ctr < 0.8);
  const winners = active.filter(a => a.roas >= 1.5 && a.ctr >= 0.8);

  return { adsets: active, underperformers, winners, days };
}

export async function rewriteUnderperformers(report: Awaited<ReturnType<typeof runAdsReport>>) {
  const rewrites = [];
  for (const adset of report.underperformers) {
    const creatives = await getAdCreatives(adset.id);
    for (const creative of creatives) {
      const context = `ROAS ${adset.roas.toFixed(2)}, CTR ${adset.ctr.toFixed(2)}%, spend $${adset.spend.toFixed(0)} over ${report.days} days`;
      const newCopy = await rewriteCopy(creative, context);
      rewrites.push({ adsetId: adset.id, adsetName: adset.name, original: creative, rewritten: newCopy });
    }
  }
  return rewrites;
}

> check my ads from the last 7 days