step 1: a marketing agent that outmarkets other agents

- learn: claude code, connecting it to your meta and google ads accounts, running it on a schedule, setting spend limits, keeping a log of everything it does.

- practice: build an agent that checks the account every hour, pauses ads above 3x target cpa after 50 conversions, raises budget 20% on three-day winners, writes three new versions of the best ad, and posts every action to slack with the reason. then give it something the competition's agent doesn't have: your review data, your competitor scrape, your real blended cac.

- why: your competitors' accounts are already run by agents, bidding in the same auction as yours. two agents with the same rules and the same meta data tie. the one that wins has better inputs, and building those inputs is the rest of this list.

step 2: programmatic seo

- learn: claude code, github, vercel for hosting, a spreadsheet as your data source, google search console.

- practice: give claude code a spreadsheet with 500 rows (cities, products, comparisons) and have it build one page per row with real data and copy you've checked. publish, then watch search console for 60 days and fix the pages google drops.

- why: google indexes thin pages slowly and removes them later. the work is in the data and the checking. the pages themselves take an afternoon.

step 3: ai video ads at scale

- learn: ai video tools (veo, seedance, kling), ai voices (elevenlabs), auto captions, a script that runs them in batches.

- practice: take one product photo and a 30-second script, and produce 100 ugc-style video ads with different hooks, voices and openings, ready to upload in 9:16 and 4:5.

- why: a studio shoot costs $20k and gives you ten videos. the same budget in api calls gives you a thousand, and the account that tests more creatives usually wins on meta.

step 4: rebuilding competitor winners

- learn: meta ad library, a scraper claude code writes for you, image and video generation, describing an ad format in a prompt.

- practice: scrape every ad from 30 competitors, keep the ones running for over 60 days, and have ai rebuild each one for your product with your own footage and claims. upload them paused.

- why: running time is the only public performance signal. an ad live for two months is paying for itself, and its structure is yours to learn from.

step 5: getting cited by chatgpt

- learn: a script that asks chatgpt, claude and perplexity questions and saves the answers, llms.txt, schema markup.

- practice: ask the three of them 100 real buyer questions every monday and log which brands and urls get cited. then rewrite your ten most important pages to match what the cited ones do.

- why: buyers ask ai before they search. the cited pages share specific traits (a direct answer in the first paragraph, original numbers, a clear author), and you can only copy them once you measure.

step 6: customer research from 5,000 reviews

- learn: scraping reviews from amazon, trustpilot, reddit and the app store, grouping them by topic with ai, summarizing each group.

- practice: pull 5,000 reviews of your product and your competitors, sort them into the ten complaints and ten reasons to buy, and write 50 ad hooks using the customers' exact phrasing.

- why: copywriters guess at why people buy. the reviews already say it, in the words that will stop the scroll, and most teams have never read more than 50 of them.

step 7: landing pages that match the ad

- learn: a/b testing, how many visitors a test needs before you can trust it, posthog to measure, ai-written page variants.

- practice: build a landing page that rewrites its headline and first section to match the ad hook it came from, then run a test with a sample size you calculated in advance.

- why: the ad promises one thing and the page says another, and that gap is where most paid traffic leaves. fixing it is cheaper than any increase in spend.

step 8: conversion tracking

- learn: google tag manager, ga4, server-side tracking (stape), meta conversions api, making sure each order counts once.

- practice: send the purchase event from the browser and the server with the same event id, and confirm in events manager that each order counts once and match quality is above 7.

- why: everything in steps 1 to 7 is optimized on these events. most accounts send duplicates or miss a quarter of orders, and then the algorithm learns from wrong data.

step 9: email and sms that trigger on behavior

- learn: klaviyo, sending product events into it (viewed, added to cart, bought, went quiet), holdout groups.

- practice: build five flows that fire on what a customer did, with a 10% holdout that gets nothing, so you can see what the flows add in revenue.

- why: selling again to someone who already bought costs a fraction of finding a new customer. most stores have one abandoned cart email and nothing else.

step 10: incrementality

- learn: geo holdout tests, marketing mix modeling (meridian, robyn), the difference between what a platform claims and what it actually added.

- practice: turn meta off in five matched regions for four weeks and compare the sales drop to what meta's attribution said it was driving.

- why: platform attribution usually overstates by two to five times. the cfo will ask for the real number, and whoever can produce it keeps the budget.

step 11: automated reporting

- learn: looker studio or metabase, a slack bot, having ai write the summary from the numbers.

- practice: build a monday report that compares last week to the week before, explains what changed, and suggests the next test, posted to slack before anyone logs in.

- why: about half a marketing team's hours go to pulling numbers into slides. automating it is the fastest way to get noticed inside a company.

link to the claude skills for every step in the next post.