Source: raw/CLAUDE_CODE_MARKETING_FULL_COURSE_6_HOURS.md (https://www.youtube.com/watch?v=yulWjh3rq28), YouTube auto-captions fetched 2026-11-14, about 82,000 words. Creator / platform / duration: Nick Saraev (YouTube channel @nicksaraev, confirmed from channel metadata 2026-11-14), who runs the AI automation agency LeftClick, the Maker School community and the dialer startup Clarvo · YouTube · 6:02:49, uploaded 2026-08-08; he calls it “5 hours of a probably much longer course”, recorded over at least two days.

A zero-to-one course on running a marketing function from the Claude desktop app’s Code tab. Every build follows the same ladder: work it out as a back-and-forth prompt, save it as a skill, schedule it as a local loop, then move it to a cloud routine that runs without the laptop. The builds cover the “reach” and “acquire” halves of his RACE framework: ad creative (procedural, AI image, AI video), personalized copy (newsletter and cold email), speed to lead, a client dashboard and invoice or proposal follow-ups, then maintenance and “advanced tips”. Auto-caption fixes applied: “Cloud Code” / “cloud code” → Claude Code, “cloud routines” → Claude routines, “Higsfield” → Higgsfield, “C dance” / “Cance” → Seedance, “Ampify” / “Appify” → Apify, “Kuo” / “Qo” → Quo, “Clarabo” / “Clervo” → Clarvo, “Netlefi” → Netlify.

Key Takeaways

  • The automation ladder is the course’s spine. Prompts and skills are triggered by you; loops are a timer on your computer (“run while your laptop is on”); routines run in Anthropic’s cloud on a schedule, API call or webhook. His rule: the moment you say the same thing more than once, turn it into a skill.
  • Bring a process, don’t ask AI to invent one. He multiplies step success rates (0.8 × 0.8 × 0.8 = 51.2%) to argue that the human should design the process and judge the outputs, and AI should only execute the middle.
  • Fix the bottleneck first. A factory with steps of 100/day and 10/day outputs 10/day; doubling the fast step changes nothing. Apply each build only if that stage is your constraint.
  • Volume plus human selection beats one-shot quality. Generate dozens to thousands of ad variants, then a person picks winners. He estimates compositing templates come out “okay” about 80% of the time versus about 25% for direct image or video generation, so budget roughly four generations per usable asset.
  • Fuzzy variables are his personalization unit. A human writes the whole email; AI only fills short, descriptively named slots (for example shortPlausibleReasonWhyTheySignedUp) from each row’s data. Fewer AI-written words means a lower chance the reader suspects AI.
  • Verify the end state manually before automating. “Start at the end”: prove the output is good in a chat, then systematize. Automating a process that produces bad output is pointless.
  • Credentials go in environment variables, not chat. API keys live in the local or cloud environment settings; Claude cannot read the value back, which he frames as prompt-injection protection. Routines need the key added to the cloud environment separately.
  • Maintenance is mostly auth. He says login and authentication cause about 70% of maintenance problems; get root credentials up front, add a self-healing instruction and route errors to a Slack channel.
  • Automate the logistics, keep the relationship. Automate data entry, first-draft copy, reporting and scheduling; keep final assets, bad news from reports and anything the customer “feels” human.

Setup: The Claude App Tour

  • Account and plan. Sign up at claude.com; Claude Code needs a paid plan (he pays 20 plan”). Download the desktop app and use the Code tab, not Home.
  • Artifacts. Self-contained web pages Claude builds; shareable with anyone via link, which he uses to host client dashboards and internal tools instead of a separate website.
  • Customize panel. Skills (Anthropic ships examples such as morning and skill-creator), connectors (Gmail, Google Drive, Slack, even Spotify), plugins (he shows Claude Mem, Supabase and a clangd LSP plugin, plus Anthropic’s finance, legal and code-modernization plugins) and memory (facts about you).
  • Routines. Under “More”; he describes them as “templated skills that are kicked off on schedule by API or webhook”.
  • Environments. Local, cloud (Anthropic’s computer), remote control (another computer you own) and SSH. Each has an environment-variable panel behind a gear icon. Cloud environments standardize setup across a team.
  • Permission modes. Manual, accept edits, plan, auto, bypass permissions. He recommends auto for most work and uses bypass for low-risk marketing tasks.
  • Slash commands he highlights. /btw (side question without interrupting the thread), /usage (5-hour and weekly limits, session cost), /loop (repeat a prompt or skill on an interval; he hit a one-minute floor). Escape stops a runaway turn.
  • Models and effort. He lists Fable 5 (requires usage credits on his plan), Opus 5, Sonnet 5 and Haiku 4.5 at recording time, and defaults to Sonnet 5 at medium or high effort for most of the course. He reports Sonnet 5’s context window as 967,000 tokens and prefers to stay under about 500k, where he says performance holds up.
  • Voice input. He prompts mostly by dictation (Cmd+D in the app), saying people speak three to four times faster than they type.
  • CLI. The same product runs in a terminal (claude --verbose in Ghostty), which is his personal preference; the course uses the desktop app.

Strategy Frame: RACE and Six Levers

  • Business pipeline: marketing → sales → fulfillment → admin.
  • RACE: reach, acquire, close, expand. Marketing is reach plus acquire; close and expand are sales and are left for future courses.
  • Reach levers: creative (images, video, audio), copy (newsletter personalization) and outreach (cold outbound).
  • Acquire levers: speed to lead, booking percentage (shorter opt-in forms, with Claude researching the prospect to replace dropped qualification fields; he suggests cutting 10 questions to 3 or 4) and follow-up.
  • Claimed result: his speed-to-lead company took a home-services client from about 9M a month in revenue, he says, mainly by responding to leads faster.

Module 1: Procedural Ad Creative (Compositing)

Goal: replicate a proven static ad format at near-zero marginal cost, without an image model.

  1. Collect high-performing formats into a folder (ad formats). With no proven ads of his own to show, he screenshots Stripe ads from the Meta Ad Library as the demo format.
  2. Voice-dump the offer into Claude along with the folder: Maker School (first AI client in 90 days or money back, about $21,000 in bundled discounts, he answers nearly every community post), plus niches (people leaving a 9-to-5, agency owners adding AI services, marketers, ex-corporate professionals).
  3. Claude decomposes the format (gradient header, bold short headline, small wordmark, single CTA) and renders it with HTML, CSS, SVG filters and tools like ImageMagick. He notes Claude has no native image generation.
  4. Ask for a tuner web page with sliders (font, spacing, gradient angle, grain or noise, wordmark font, CTA style). Tune by eye, then export the settings as JSON and paste them back.
  5. Generate 50 variants with different headlines and CTAs; add a select-and-download step for winners.
  6. Skill: consolidate into a maker school ads skill (SKILL.md plus scripts). A fresh chat with no context can run it, and he reuses it for Clarvo by telling it to research clarvo.io first.
  7. Loop: schedule it daily at 5:59 a.m. (Claude reads its built-in schedule skill and sets up cron) so a creative specialist reviews a fresh batch at 6:00.
  8. Routine: move it to the cloud: create a private GitHub repo, connect Google Drive as a connector, write each run to a dated subfolder. The Drive connector could not change sharing, so he set “anyone with the link” by hand. The routine shows up as “Maker School daily ad batch”.

Cost logic, as he puts it: image models at around 200 per batch, so the procedural route is the accessible starting point.

Module 2: AI Image Ads (GPT Image 2)

  • Test the model manually first. He uploads a product photo plus a template ad into ChatGPT (he needed a paid plan to upload more than one image) to confirm GPT Image 2 can do the job before wiring anything.
  • API key into the local environment. Create a key on the OpenAI platform, add OPENAI_API_KEY=... in the local environment panel, and tell Claude it exists; it cannot see the value.
  • Have Claude read the API docs and run a live image-edit test with the product photo and the template folder. When it reached for GPT Image 1, he stopped it immediately (“correct it now as opposed to later”).
  • Constrain the freedom. The first outputs drifted far from the template. He asked Claude to decompose the template into bands (logo band at 0 to 20% of height, negative space, product band, footer) and “levers to pull”, targeting a template you can hot-swap any product into with about 80% confidence the output is okay. He rejected mixing a procedural overlay with AI-generated pixels.
  • Variation pools per template (warm or cool, indoor or outdoor) and at least five variants per template, delivered as an HTML picker with checkboxes.
  • Skill, loop, routine as before; the cloud routine needs the OpenAI key added to the cloud environment’s default settings. He tells Claude to copy the structure of the existing Maker School routine.

Module 3: AI UGC Video Ads (Higgsfield)

  • Why Higgsfield: he describes it as a model aggregator (image, video and text models behind one account) with an MCP server and CLI that Claude Code drives well. UGC-style testimonials and product reviews are the formats he says work best.
  • Manual run first:
    • Generate a new influencer from a Pinterest reference with GPT Image 2 inside Higgsfield (three options cost him 21 credits; he uses 2K for video input frames).
    • Generate a hero frame of that influencer holding the product (a “Midnight Clay” mask he generated earlier) in a fitting setting.
    • Have Claude write UGC scripts, then test video models (Kling, Kling Turbo, Seedance 2.0 and one the captions call “Gemini Omni Flash” ^[ambiguous]). He budgets 20 for this test round.
    • Upload the product as a reusable element so it stays consistent.
  • Script length rule from testing: about 27 to 35 words fits 10 seconds. The skill ended with “under 22 words → 8 seconds, otherwise 10 seconds”; too-short scripts make the avatar repeat lines.
  • Connect via CLI: paste Higgsfield’s MCP-and-CLI install prompt into Claude Code, log in once; he prefers CLI auth over hand-pasting API keys whenever a CLI exists.
  • Skill pipeline: product images + influencer images → resize → hero frames → 10 script candidates → approval gate for hero frames and scripts before spending video credits → 3 video candidates per pairing. Later version: cross every influencer with every product, no human oversight until delivery, parallelize.
  • Limits hit: Higgsfield allowed eight concurrent jobs; the skill was updated to cap at three concurrent per script and retry failures one at a time. One misread spec would have generated nine videos per person; the corrected run was about 360 credits or less.
  • Routine: add Higgsfield as a custom connector (paste its MCP URL under Connectors, OAuth login), then the cloud routine “UGC video ads daily batch” lists new assets in a Drive folder, builds the influencer × product cross, writes scripts, sets duration by word count and uploads three candidates per pairing.
  • QA ideas he suggests but does not build: split each clip into one-second frames and have Claude flag malformed frames; add grain or background audio to look less AI. His math: 10 influencers × 10 settings × 10 scripts = 1,000 options; after automated QA, a person watches 250 to 500 ten-second clips (40 to 80 minutes) and picks about 20 to test.
  • Observations he reports: male avatars came out worse, which he attributes to less training data; products sometimes vanish mid-clip.

Module 4: Personalized Copy with Fuzzy Variables

Newsletter (Kit)

  • Context: a Kit list of about 38,100 subscribers built in roughly six months, fed by Instagram ManyChat comment-for-resource flows and LinkedIn; he says Maker School did $280,000 last month.
  • Hard vs fuzzy variables: hard variables (first name, company, city) are copied verbatim; fuzzy variables are AI-written from the row, for example “especially because you mentioned you struggled with lead gen in the past”. He also removed an en dash from the template because it reads as AI.
  • Template slots: shortPlausibleReasonWhyTheySignedUp, shortCustomReasonWhyItsUseful, paraphrasedChallenge (camelCase, long and descriptive because the name is the instruction to the model).
  • Prompt rules he shows: read every row, no sampling; write values per row, not from a lookup; vary sentence structure row to row; do not modify the source sheet, create a new one via Drive upload; validate before upload. After a first pass he cut the slots to about 10, 10 and 5 words and pasted the exact email sentence so the paraphrase fits grammatically.
  • Wire into Kit: add custom fields, import, then fix merge syntax (Kit uses lowercase subscriber. field names) and preview as individual subscribers.
  • Skill via the Kit API: Kit’s MCP did not cover what he needed, so he added KIT_API_KEY to the environment. Claude’s design: tag new subscribers maker school welcome pending, generate the three fields, write them to custom fields, point the draft welcome broadcast at that tag, send, then remove the tag to prevent double sends. The routine runs this daily with the key in the cloud environment.

Cold Email (Apify + Instantly)

  • Same pattern, different data source: scraped lead rows (from LinkedIn Sales Navigator or tools like Vayne, AirScale and Apify) instead of signup data, sent through Instantly instead of Kit.
  • Reply rates he cites: templated outreach about 1 to 2%; light personalization about 5%; his best campaign over 20% using conference attendee lists; conservative campaigns at 2 to 4% still made “hundreds of thousands”, he says.
  • Template style: casual, often lowercase, deliberately imperfect, because readers associate perfect grammar and em dashes with AI spam. Slots include myThingInCommon, theirThingInCommon, a paraphrased company description and the prospect’s own terminology for their customers. Claude flagged the template’s revenue claims as a deceptive-claims risk; he agrees real case studies are required.
  • Lead source: Apify’s Leads Finder style scrapers, which he prices at about 1.80 per 1,000 leads; one test cost 18 cents for 100 emails. Connect Apify by pasting its MCP configurator URL as a custom connector.
  • ICP self-check encoded in the skill: scrape 100, sample 20, require at least 15 of 20 to match the ICP, otherwise adjust filters and rescrape. His run went 9, 9, 15, then 19 of 20 without intervention.
  • Output: a trimmed CSV (names, email, company, size plus the custom fields) imported into an Instantly campaign and previewed per lead.
  • Bottleneck check: he built a 5:59 a.m. routine (“Daily Clarvo lead gen”) only as a demo; he does not need a fresh list every day, so on-demand is enough.

Module 5: Speed to Lead (Email + SMS)

  • Why: paid leads go cold fast. He frames a 20,000 as a 2x ROAS that faster, more personal response can lift; the aim is cutting a typical 10-minute wait to about 30 seconds.
  • Demo form: Claude builds an HTML artifact for a fictional AC installer (“Summit Air”) wired to Formspree so submissions arrive by email; he made the free-text “anything we should know” field mandatory to feed personalization.
  • Polling version: connect Gmail as a connector, have Claude check the mailbox every minute for new submissions not already handled, then reply.
  • Copy: email subject “re: {first name} air conditioning”, one paraphrase of the request (10 to 15 words max, “the shorter it is the more human it seems”), “we’ll call you in the next 5 minutes”. SMS must fit 160 characters, so the paraphrase is kept to about 20 to 30 characters.
  • Humanizing: he warns that replying too fast looks fake; some operators add a small typo or a “just driving into the garage” line.
  • SMS provider: Quo (formerly OpenPhone) via its Claude connector; Twilio works the same but needs A2P registration, which he says takes 2 to 14 days and can be rejected.
  • Routine triggered by API, not schedule: he created a cloud routine “speed to lead SMS and email” with Gmail and Quo connectors and the “call via API” trigger, then gave Claude the token so each form submission fires the routine via POST. He calls this more efficient than polling.
  • Not built: call merging (a third number rings the rep and the lead at once), disposition tracking and CRM follow-ups, which he leaves to a sales course.

Module 6: Client Dashboard

  • Treat dashboards as web design projects, not data dumps; a one-shot “visualize this” produces a poor layout.
  • Data: a folder of fake CSVs standing in for Meta Ads, GA4, sales activity logs, call tracking and more (tens of thousands of rows). Production version: connectors or MCPs feed an ingestion pipeline on a daily, weekly or monthly routine.
  • Architecture pass on the strongest model. He switched to Fable 5 on high effort, bought 13 USD ($18 CAD), he says.
  • Design pass in parallel. Back on Opus 5 high, he asked for five sub-agents to build five different HTML designs at once (editorial, terminal, Swiss, dense ops, warm print), each required to surface the same anomalies. His parallelization trade-off: faster and searches more of the solution space, but costs more and each branch runs unmonitored.
  • Deploy: add the Netlify MCP as a custom connector, publish the favorite variant and password-protect it. He suggests per-client gating by URL parameter and password, and says the whole build cost about $15 in tokens versus tools like AgencyAnalytics.
  • He mentions adding an AI question-answering assistant to the dashboard as an extension but does not show it.
  • He says he once spent 15,000 on tokens in a month for his own companies.

Module 7: Follow-ups (Invoices and Proposals)

  • CRM: a ClickUp list (“invoice collection CRM”) with amount, contact, sent date, days outstanding and due date, connected through ClickUp’s built-in Claude connector.
  • Flow: query CRM → read email history with the prospect → check trigger conditions → pick a template from a library → send. Trigger ideas: no reply 7 days after a proposal, an unanswered question, “follow up next month”, repeated opens.
  • Gmail sending gap: the Gmail connector exposed draft tools but no send tool, so Claude built a Gmail API path with his own OAuth client; he later added a read scope so it could check sent history.
  • Template pool: 10 one-line soft nudges (“Hey {name}, just checking in on the invoice”), no em dashes, no invoice numbers, signed “Thanks, Nick”, never the same template twice in a row.
  • Cadence: days outstanding of 1, 2, 3, 7, 14, 21, 28, 56 and 84.
  • Opt-out guard: if the prospect asks to stop, set the ClickUp chase stage to closed, add a note and send nothing. Claude tested it with a planted “we are disputing this through our lawyer” reply.
  • Packaging: “convert it into a simple bulleted SOP so that a future Claude instance that does not have the context of our conversation will still be able to execute this reliably”, then a 5:59 a.m. loop, then a cloud routine with the ClickUp connector. SMS nudges through Quo can be added by pulling phone numbers from ClickUp.
  • His revenue math: lifting call-show rate from 30% to 60% and close rate from 20% to 30% compounds to a 3x revenue lift; he says solid follow-up alone can add 20 to 30% of revenue.

Maintenance and Advanced Tips

  • Get logins and root credentials up front from clients; he attributes about 70% of maintenance issues to auth breaking after service updates. Storing usernames and passwords as environment variables enables a “debug flow” where the agent logs in through its browser and regenerates a key.
  • Self-healing instruction (paraphrased from his worksheet): if the same error happens more than three times, assume something materially changed in the external system, investigate with full autonomy, fix it, then update the skill, loop or routine and append a change log with the problem and solution. He warns that too much self-healing latitude once led a system to rewrite itself over a spurious rate limit.
  • Error logging: unlike Make.com or n8n, Claude-built automations have no built-in error history, so add a Slack (or WhatsApp, Discord) connector and a line telling every routine to post errors to an #errors channel, including what fix it tried and whether it worked. He demonstrates a forced error from the ad routine.
  • Effectiveness over efficiency. His example: a private equity firm wanted a voice agent to replace one hour a week of owner calls, the activity that makes them money; he argued against it.
  • What to automate: data entry, first-draft copy and creative concepts, reporting, logistical scheduling, invoice nudges.
  • What not to automate: the final creative asset, bad news from reports (the dashboard “signals” should be delivered in a meeting), anything where the customer must feel valued. His filter: “does the customer actually feel this process?” If yes, automate up to a human QA step.

Try It

  1. Pick the stage that is actually your bottleneck in RACE before building anything.
  2. For one repeated marketing task, do it once as a chat with Claude, judge the output yourself, then say “turn this into a skill” and run the skill in a fresh chat to confirm it works without context.
  3. Rebuild your best static ad as an HTML or SVG template with a slider tuner, export the settings as JSON, and batch 50 variants for human selection.
  4. Add two or three fuzzy variables (about 10 words each) to your welcome email; keep the rest human-written and preview several subscribers before sending.
  5. Encode your own QA rule into a lead-scraping skill (for example 15 of 20 sampled leads must match the ICP or rescrape).
  6. Put API keys in the environment panel, test with a harmless read-only call, then mirror them into the cloud environment before creating a routine.
  7. Paste a self-healing clause and an “errors go to Slack” clause into every routine prompt.

Implementation

Tool/Service: Claude desktop app (Code tab) with skills, /loop, cloud routines, connectors and artifacts; GitHub (routine repos); Google Drive; GPT Image 2 (OpenAI API); Higgsfield (MCP, CLI, custom connector); Kit; Apify; Instantly; Formspree; Gmail connector and Gmail API; Quo or Twilio; ClickUp connector; Netlify MCP; Slack connector.

Setup:

  • Connectors: Settings → Connectors → browse built-ins (Gmail, Google Drive, Slack, ClickUp, Quo) or “add custom connector” with a vendor’s MCP URL (Higgsfield, Apify, Netlify); each opens an OAuth login.
  • Secrets: environment panel (gear icon next to Local or Cloud), NAME=value lines; Claude cannot echo them.
  • Routines: More → Routines → new cloud routine; pick connectors, the environment and a trigger (schedule, API token for POST, webhook); runs can be started manually and inspected as transcripts. Claude typically creates a private GitHub repo holding the scripts.

Cost (as he reports): Claude plan 2 per ad; Higgsfield influencer images 21 credits for three, initial video testing 20, a crossed batch about 360 credits; Apify leads about 1.80 per 1,000; Fable 5 dashboard scaffold about 15 in tokens.

Integration notes: the Google Drive connector could not change sharing permissions; Kit’s MCP lacked the needed endpoints; the Gmail connector could draft but not send; Higgsfield capped concurrent jobs at eight; routines run slower than local sessions and need their own copies of keys.

Open Questions

  • Captions garble the creator’s surname (“Nick Sar”, “Nick Surive”, “Nick Sarif”); the channel metadata confirms Nick Saraev.
  • Revenue claims are unverified: his marketing business “did over 280,000 last month, a home-services client from 9M a month, a cold campaign over 20% reply rate, “10,000%” ROI on his subscription.
  • Model names and limits (Fable 5, Opus 5, Sonnet 5, Haiku 4.5, a 967,000-token Sonnet 5 context window, Fable requiring usage credits on a Pro-tier plan) reflect the August 2026 upload (2026-08-08), before Opus 5.5 and Fable 5.2 shipped; check current docs.
  • “Gemini Omni Flash” as a Higgsfield video model may be a caption error ^[ambiguous]; Seedance version numbers also vary in the captions (2.0, 2.5).
  • The 80% vs 25% “okay output” rates for compositing vs direct generation are his estimates, not measurements.
  • The dashboard AI assistant, call merging and frame-level video QA are described but not built.
  • The self-healing clause is paraphrased from his on-screen worksheet; he declines to give an exact phrase.