Concepts — the front door

You just spent six basecamps building the left side of a bridge — this session is the announcement that the right side exists, and that it's a different game with different rules.

Having AI skills and making money with those skills are two completely different games — different fields, different rules. The skill side (n8n, Retell voice agents, vibe coding, RAG chatbots, MCPs) is built; the business side is what to sell, who to sell it to, how to price, how to find buyers, and how to get paid.

Every AI offer you will ever construct reduces to three levers — add money, free time, delete costs — and the great ones pull all three with one system.

Every AI offer makes a business money one of three ways: directly driving revenue (new money that didn't exist without you), saving time (hours × their internal rate), or cutting costs (an expense stops existing). The most compelling offers combine as many levers as possible.

The system you build is the vehicle; the offer is the destination plus the bet you're willing to make on it — and the difference is 10x in what you can charge.

'AI phone agents' is the vehicle, not the offer. The offer is the packaged promise: 'Property managers — I bet my AI phone support rep will outperform your best rep for 70% cheaper. If I lose, you don't pay a dime, and I personally bankroll the system for you.'

There are exactly two ways to monetize what you learned: install systems in other people's businesses, or run a classic business yourself with AI doing the work of ten.

Lane 1 (technical): audit operations, find the lever, build the system, deliver the outcome — selling the system plus results (voice agents, lead-gen engines, chat agents, dashboards, automations). Lane 2 (non-technical or traditional experience): run a traditional business model — content, lead gen, copywriting, ads, web design — with AI as leverage: one person doing the work of a team of ten. Pick one; don't straddle on day one.

Nothing you learned in the basecamps was academic — every skill has a price tag once you name the business that bleeds without it.

Every basecamp skill maps to things businesses actually pay for: n8n → cold-email engines, appointment booking, P&L dashboards; voice agents → speed-to-lead, after-hours answering; RAG → internal knowledge bots, FAQ bots, contract review; vibe coding → agency output multipliers and products.

Everyone in the AI wave has the same tools — what they don't have is your twenty years of knowing exactly where an industry bleeds.

How to compete in the AI hype wave: (1) your background — the industry you know deeply and its problems; (2) your daily pain — what takes hours that shouldn't, because if it's broken for you it's broken for thousands like you; (3) your network — friends, colleagues, LinkedIn connections who already trust you.

Market validation used to take months of guessing; with a research partner that has read everyone's complaints, it takes half an hour — if you verify against real humans.

AI as research partner ('a little Einstein on your shoulder'): ask it the top-5 pain points of an industry, cross-check on Reddit/forums/social media that real people complain about the same things, then ask 5 actual people if they'd pay. AI says problem + real people confirm = validated market. Go build.

Every purchasing decision on earth runs one fraction: how much they want it times how much they believe you, divided by how long it takes times how hard it is for them.

Value = (dream outcome × perceived likelihood of achievement) ÷ (time delay × effort & sacrifice). Maximize the top, minimize the bottom; value is what justifies price. From Alex Hormozi's $100M Offers.

The guarantee is where you put money where your mouth is — and the craft is making it terrifying to read yet safe to give, by conditioning it on what you control.

A guarantee is essential — it shows you're putting your money where your mouth is, and it should make you slightly uncomfortable. But only guarantee what you can control, enforced through conditional guarantees: the promise holds only if the client meets stated conditions (credentials/feedback within 48 hours, etc.).

'Who have you done this for?' has three honest answers before you have a single client — and stacked together they close most of the trust gap.

Perceived likelihood of achievement breaks into three buckets: (1) trust the person — your résumé and industry background; (2) trust the solution — white-label case studies ('companies in your industry are implementing this and getting this result'); (3) trust the implementation — a small portfolio of AI projects proving you have the chops.

Same low price, opposite meaning: 'I'm new, here's a discount' reads desperate — 'first three clients only, then it's 5x' reads like Bitcoin at a thousand dollars.

'I'm new, so here's a discount' devalues you and reads desperate. Reframe with confidence, authority, scarcity and urgency: 'Because we're new, our first 3 clients get this at $2,000. After that it's $10,000.' Then flip the sales conversation into qualification: 'I'm only taking 3 — I need to be sure I can make you successful.'

The strongest claim of the session: it is morally wrong to undercharge — because cheap prices produce worse outcomes for the CLIENT, not just for you.

Charging low triggers a death spiral: emotional investment down → perceived value down → clients don't implement → worse results → worse clients → no margin to improve or support. Charging high runs the reverse: invested clients implement, get results, provide proof, and your margin funds better delivery. Higher price → better clients → better results → better proof → higher price.

Generosity backfired on him twice: the free extras became obligations, and the unused extras became reasons to cancel — people judge by the fraction they use.

People judge value by the percentage of what they USE, not what they're given. His own lesson: free extra work (running clients' ads, writing their copy out of goodwill) became expected, then became grounds for dissatisfaction. Gyms with pools and courts churn MORE than Planet Fitness — members think 'I'm paying for all this stuff I don't use' and cancel.

Business owners will tell you what to build, and building it is how you fail — the skill worth $10,000 instead of $500 is diagnosing what they actually need.

At any moment a business has ONE primary constraint. Broadly: demand-constrained (could serve 2-3x more customers tomorrow) or supply-constrained (more sales would break delivery). Beneath: six sub-constraints — offer, leads, sales, pricing, fulfillment, retention. Your job is to diagnose before you build; the constraint tells you the solution.

Three shapes of AI business, and the selection criterion isn't the market — it's you: your expertise, your product instinct, or your appetite for repetition.

Route 1 — AI consultant/transformation partner: paid discovery sprint ($5k, guaranteed to find $50k+ in savings/revenue, refundable, credited toward the build) then the highest-ROI builds. Route 2 — SaaS: build once, sell subscriptions ('not a fan' — anyone can build a SaaS overnight now); better: software WITH a service, customized per client. Route 3 — productized offer: fixed scope, fixed outcome, repeatable ('I implement X for Y customer, gets Z result, guaranteed').

The session compresses into one sentence you can write tonight — 'we help X achieve Y in Z or [guarantee]' — priced at a tenth of the money it makes, and delivered first to people who already know you.

Offer template: 'We help [avatar] achieve [specific result] in [timeframe] or [guarantee].' Price at 10-20% of the annual ROI you create. Find clients through warm outreach (ask for referrals, not sales) and 100 cold emails/day; close with a two-call structure (discovery call, then solution call).

Your storefront isn't a website you'll build someday — it's the LinkedIn profile buyers check first, and it's three fixes away from working.

Before websites, LinkedIn: a clear profile picture (selfie → Gemini/ChatGPT professional shot), a banner stating the one-line offer plus your domain name (check how it renders on phones), the bio line 'I help [niche] [verb] [problem] with AI', and case studies attached as links/media on every experience entry.

For a decade the game was ranking on Google; now the game is being the source an AI quotes — and the raw material is LinkedIn posts and Reddit threads.

Answer engine optimization — the successor to SEO. ChatGPT/Perplexity/Gemini cite sources by credibility and query-fit rather than rank, and they heavily cite LinkedIn posts and Reddit threads. Consistent niche posting ('AI for real estate agents', repeatedly) raises your odds of appearing inside AI answers.

'Pick a niche' is useless advice until it's three stacked questions: which function, which industry, which exact problem.

Clarity framework: level 3 — business function (sales, marketing, accounting, HR); level 2 — industry (healthcare, coaches, real estate, e-commerce); level 1 — the exact problem. Function + industry = your niche; adding the specific problem produces the offer line and tells you which channels to research.

AI is a technology looking for use cases — the use cases are sitting in comment sections, stated in the exact words your offer should use.

Find the exact problem where the niche complains: Reddit (filter by title, upvotes, comments), skool.com communities over 1,000 members, Facebook groups, YouTube comment sections, WhatsApp groups and hyperlocal apps — with a browser AI summarizing comment sections into 'painful problems people are discussing'.

Don't guess which product to build — run a services business until one solution sells three times, then you already know.

Start with services: solve problems for real businesses, watch for the one solution that clicks, then productize it. His product Glued grew from client services (UGC-ad automation for D2C brands); services pivot instantly as models change, while products carry rebuild overhead — and YC now explicitly invests in 'AI-native services' companies.

The client will tell you a narrow problem; the paid work is discovering the business around it — with the success metric agreed before anything gets built.

Project scoping happens on the discovery call: genuine curiosity about how the business operates (clients state narrow problems; the real one is usually adjacent), clear objectives and requirements, and agreed success metrics/KPIs — plus the questions asked at booking time (Calendly intake).

The proposal that closes isn't written — it's drawn: one flowchart that tells the client the whole story of what you'll build.

Design the system as a flowchart the client can read: trigger → each processing step → outputs, drawn in FigJam/Canva/Excalidraw/Miro (or generated by Claude as an HTML page). The diagram carries the proposal — 'diagram first, then bullet points, and no paragraphs.'

'Transform my business' is a three-month promise you can't prove — so sell the two-week slice that proves everything.

Break the client's grand goal into an atomic milestone deliverable in ~2 weeks; propose it as a paid pilot quoted at a month, deliver early (underpromise, overdeliver). The first win converts a 3-month contract into a 6-month partnership and opens the retainer.

In the AI era the scarce skill isn't building — it's being the person whose systems fail loudly to the builder and never silently to the client.

Three QA layers before 'we're done' (AI-layer QA, human QA, founder approval); test 10-15 artifacts per build (ask the client for 10 example queries, generate 20 more with AI); and error handling that alerts YOU when systems break — the client discovering the outage is the failure mode.

Never price from your effort — price from the number the client just told you the manual version costs them.

Clear pricing signals confidence; fumbled pricing signals amateur. The guide: pricing = value = business impact. Get the client to reveal what the manual process costs them (the $9k/month offshore legal-review team his automation replaced — chargeable at 5-10x), or research comparable staffing costs when no system exists. Pricing power = AI skills × domain experience × business impact.

Three ways money arrives: once (fixed), monthly (retainer), or as a share of growth you caused (performance) — and the craft is knowing which fits the client and how to protect your downside.

Fixed price (one-time deliverable — with team training as the natural upsell), subscription/retainer (maintenance, support, consulting hours — the recurring goal), and performance-based (a share of the delta: '50k → 150k MRR, we take 10-25% of the increase' — high-trust, protect the downside with a fixed-fee floor).

Stanford's $200k curriculum compressed into one sentence: the people succeeding are just running more experiments — and AI made experiments nearly free.

The GSB takeaway: 'people who are succeeding are just running more experiments.' Validate before building — landing page + Google Ads capturing emails for an unbuilt product; 5 pages racing, 2 win, 1 gets built. AI's real gift is parallel experimentation; once one clicks, concentrate everything on it.

The session's instrument is also its lesson: one desktop app where chat, files, browser, terminal and git live together — pick your reasoning depth per task and build.

OpenAI's Codex app (chatgpt.com/codex, works with any ChatGPT plan): projects are folders, GPT-5.5 with selectable reasoning (low/medium/high/extra-high), a top-right panel with files, in-app browser, code-change review and terminal — and automatic git tracking on every project.

You already know what a landing page looks like — the upgrade is knowing what every section is CALLED, because names are what prompts are made of.

The standard stack: navbar (central, clear labels) → hero (the outcome the audience wants, objections handled, strong headline + subheading + product visual/demo, mobile-first) → social proof → use cases, why-us, how-it-works, benefits, pricing, testimonials, CTA, FAQs, footer.

Nobody called it slop last year — the output got better and the label got harsher, because slop isn't a quality judgment, it's an abundance judgment.

'Slop' = output that's common, superficial, and identical to everything else — a moving target: today's slop would have amazed everyone a year ago. Abundance, not quality, creates slop; blocks-blocks-blocks layouts and purple gradients are its tells.

A skill is the least mystical thing in AI: a folder containing your process written down — and that folder is quietly becoming the unit of the whole automation economy.

A skill is a folder: SKILL.md holds your process as instructions; optional folders carry references, templates and outputs; complex workflows (video editing, API calls) add scripts — which the coding agent writes itself. skills.sh is the open-source marketplace; pick by install count.

One installed skill turns 'make me a landing page' from a slop generator into a design studio with four verbs: build, study, audit, redesign.

A design skill that 'refuses to look AI-generated'. Four commands: build (asks product/audience/theme, then produces a pattern-breaking page), study (reverse-engineers any site's design into a JSON theme spec), audit (slop report on your own site), redesign (keep brand and copy, remake the design).

Every element you've admired on a premium site is sitting in a catalog with a copy-prompt button — the designer's job compressed to choosing and placing.

21st.dev: a component library — navbars, carousels, backgrounds, shaders — each with a 'copy prompt' button that copies prompt AND code; paste into your agent with placement context. motionsites.ai, Dribbble and Framer for design-level inspiration (don't pay for motionsites).

The single biggest premium tell on a modern landing page — living motion in the hero — is now a three-step pipeline costing roughly nothing.

Premium pages in minutes: generate an image (Nano Banana/ChatGPT), turn it into a video (Gemini/AI Studio: '3D render style, panning, white background, super high quality'), upload the .mp4 to the agent, and set it as the hero background with an inward masking gradient. Page built with the taste skill (or Hallmark).

Hosting stopped being knowledge and became a question you ask the agent — the one decision left is static-vs-backend, and the agent makes that too.

Static sites (HTML/CSS/JS) → GitHub Pages, free; anything with a real back end → Vercel. The non-technical路径: ask the agent 'what would be the best way to host this website?' and follow its steps. Domains from GoDaddy/Namecheap, configured onto Vercel or GitHub Pages.

Every tool question in the Q&A got the same underlying answer: match the tool to your stage — and when in doubt, run the candidates in parallel and let outputs decide.

The graduation ladder: Lovable/Replit for prototyping and beginners (easy hosting, MVP testing), Codex/Claude Code once you're serious about systems. Test skills in parallel (same brief to 4-5 skills, pick the winner). Hermes/OpenClaw: 'most people do not deserve an executive assistant' — founders and managers do; builders should build.

The portfolio objection dissolves under one observation: his own famous use-cases page is just a catalog of things he built for himself, written up well.

No clients yet? Write use-case blogs and an automation catalog instead of case studies (his 30-day automation catalog page predates any client list). Market reality: website-building clients live on Upwork/Fiverr (thin margins), but local businesses — cafés, roofing, HVAC — pay well for fast, simple sites. Standing out = finding leverage: partners, networks, presence.

The unit of entrepreneurship just shrank: an app you build tonight, share with ten people tomorrow, and either grow or discard by the weekend.

Small applications built in hours to test whether anyone wants them: share the publish link with 1-10 real users (skip sign-up friction at this stage), collect feedback and feature requests, and only then invest seriously — moving to Codex/Claude Code or hiring an engineer.

Amazon minus logistics is a directory app — and you're one valuable CSV plus one prompt away from your own.

The archetype: valuable dataset + search/filter/detail front end = instant product. Demo: 407 YC-backed 2025 startups, scraped then enriched (industry, AI/non-AI, B2B/B2C/hybrid, founders + LinkedIn, founded date, team size, location, socials, founder summary/highlight) — the kind of app a VC firm (Bessemer pitched him exactly this) pays for.

The datasets are lying around — in research-paper appendices, government dumps and niche repositories — ugly, unloved, and one cleaning pass away from being products.

Where data comes from: your own niche records, open repositories (biomedical, genomics, drug discovery — linked from research papers), and scraping. The opportunity: open data is always ugly — collect it, have agents write cleaning scripts, and either build on it or sell it (his friend sells cleaned, PII-stripped corpora to OpenAI/Anthropic).

The prompt that built a working marketplace named zero technologies — it described a user's afternoon, and the platform chose the architecture.

Attach the CSV, describe the app in plain language (what it's for, what users should be able to do — browse, click into details, filter by industry/model/founder type), and use plan mode for first builds and new features so you review the plan before implementation.

Seventeen pages of filters serve the browser; one text box serves everyone else — the modern app ships both, and the second mode took two prompts.

Upgrade the directory with a second mode: an AI assistant (clean Claude/ChatGPT-style interface) that answers natural-language queries against the dataset — 'show me AI fintech B2B companies' — and returns results as linked cards to the marketplace's detail pages.

Books are static knowledge; apps are that knowledge answering questions about YOUR situation — and the conversion is one deep-study prompt plus a rubric.

Turn a framework-rich book ($100M Offers demoed; The Intelligent Investor named) into an AI evaluator: study the PDF deeply, extract every framework, then build an assistant where users submit their business/website and receive a 10-point rubric audit, each point citing the framework it applies.

Version control decoded in one analogy chain: v1/v2/v3 on your documents → snapshots of whole folders → a software that takes them → Google Drive, but for code.

Commit = a snapshot of the ENTIRE codebase (because an app is many files whose states must match); Git = the software that takes snapshots (install once; agents run it); GitHub = 'Google Drive for codebases' — each app is a repository (keep it private); push = upload, clone = download. GitHub is the single source of truth across Lovable, local and Codex.

The escape from platform dependency is a zip file and two prompts — and the destination behaves exactly like the platform you left, minus the credit meter.

Route 1 (usual): Lovable's GitHub integration pushes the project to your repo; clone it locally via Codex. Route 2 (demoed): download the code zip from Lovable, unzip, open the folder as a Codex project, then 'enable git and push to this repository.' Either way: local dev with in-app preview, then commit/push.

Deployment collapses to a one-time handshake between GitHub and Vercel — after which 'push' is the only deploy command you'll ever type.

One-time setup: vercel.com → Add New Project → Import Git Repository → grant the GitHub app access to your repo → Deploy. From then on every push auto-updates the live site (build-failure emails included). Custom domains via the project's Domains tab, which walks the GoDaddy DNS steps. Netlify and Cloudflare Pages are the named alternatives.

Every platform in the stack is honest about what it charges for — the craft is knowing which phase you're in, and whether your AI feature has a business model at all.

Lovable earns its fee for speed-to-test (founders, PMs mocking flows, AI features with zero setup) — but serious building broke it for him: 20 hours of building burned his $20 in 2 days; his Codex usage 'would be a $1,000 Lovable bill.' And the standing warning: adding AI to any app crushes margins — price from unit economics or don't add it.

The session that made building trivial ends by naming the real boss fight: nobody's waiting for your app, and getting it to them is the long, doubt-filled part.

'App building is so easy — all of you can build now. The difficult part is distribution and selling it.' Plan go-to-market before the build feels finished: business model, client acquisition, B2B intros through your network. Idea sourcing runs continuously: anything viral (reels, TikToks) is an app candidate — his Tinder-for-food swipe app came from a reel.

Most 'lead lists' are graveyards — the whole discipline of lead generation is turning names into context, and context into conversations.

The progression: stranger → lead (matches your ICP) → engaged lead (replied, booked, raised a hand) → customer (paid) → repeat customer. A contact is just an email — worth $0, 'spam and hope'. A lead is contact + context (role, company, situation, signals) — worth targeted outreach and 25%+ reply potential. Engaged-lead count is the number that predicts revenue.

Same afternoon, same computer, same person: one path makes $0 and burns your infrastructure; the other makes $20,000 — the difference is doing the steps in order.

Scenario A: buy 10,000 addresses, blast one template → 0% replies, plus 3,000 bounces trash your domain reputation so even real business email lands in spam — worse than nothing. Scenario B: 100 ICP-matched, enriched, personalized → 10-20% replies → 20% close → 4 × $5k = $20k. Realistic at-scale reply rates: 3-8%. AI's edge: both quality AND volume.

An ICP is a sandwich: the company is the bottom bun, the person is the meat, the problem is the top bun — and outreach built on fewer than all three falls apart in your hands.

Three stacked layers define who should buy: firmographics — the company (industry, size, revenue, location, tech stack); demographics — the person (title, seniority, department, tenure); psychographics — the problem (pains, goals, triggers). Qualified through BANT: budget, authority, need, timing.

The counterintuitive law of outreach: shrink the audience and the revenue grows — because relevance, not reach, is what gets replies.

Hormozi's law applied to targeting: the narrower the target, the more money — wide targeting yields 0.5-1% replies, narrow yields 3-8%+ (10-15% in his early days). The bullseye: 'small business owners' (useless, 30M of them) → 'HVAC companies' (warmer) → 'HVAC with 5-15 trucks, $1-5M revenue, still on pen and paper' (money).

Outreach is a house: everyone sees only the front door, but the door hangs on framing, wiring and a foundation — and painting it first is why most campaigns collapse.

Build like a house, in order: targeting (foundation — ICP filters into the tool), list building (framing — names/titles/companies exported to a spreadsheet you own), enrichment (wiring — emails, scraped sites, signals; the 2%-vs-20% lever), outreach (front door — the only part the prospect sees). Most people paint the front door first and the house collapses.

Five words carry the whole trade — and the most important distinction they encode is that spam and cold outreach share a tool the way a surgeon and a mugger share knives.

Intent signals: clues someone is ready now (raised funding, hiring, CEO posts, competitor-site visits) — chase strong ones, ignore weak. Enrichment: napkin-name → dossier. Waterfall: multiple email-finding tools in sequence (one finds 40%, the next 30% more). Deliverability: staying out of spam. Cold outreach: messaging ICP-matched strangers with relevance — spam and outreach share a tool the way a surgeon and a mugger share knives.

The 'who do I sell to?' question that paralyzes beginners is a four-prompt pipeline: reason with ChatGPT, verify with Perplexity, and walk into Sales Navigator with the exact filters written down.

The prompt chain that finds who desperately needs your system: (1) ChatGPT — describe the system's capabilities, ask for 10 industries ranked by cold-outreach dependence, automation benefit, and speed to close; (2) pick one, ask for decision-maker titles, size range, geography, and LinkedIn keyword variations; (3) Perplexity — get the LIVE Sales Navigator filter names (they change; ChatGPT's are from training data); (4) merge back into ChatGPT for the final targeting spec.

The most precise B2B targeting engine on the internet, scraped by a rented robot, downloaded through a DevTools loophole — total cost so far: zero.

B2B precision lane: LinkedIn Sales Navigator (free month trial, ~$100/mo after) with Boolean keywords + headcount + geography + titles + industry filter + the 'posted on LinkedIn' hack → exactly ~2,500 results → PhantomBuster's Sales Navigator Search Export phantom (Chrome-extension auth, 2 free execution hours) → the DevTools network .csv trick downloads the full list free.

Every free lane in the session converges on one toll booth — and it's a fair one: you only pay for emails verified enough to protect your domain.

The email-finding layer and the stack's only required subscription: bulk-upload the scraped CSV (name + company), and it matches emails at 97% verification — charging credits ONLY for verified finds. Typical yield ~80-85% of a list; includes a decision-maker finder (for company-only lists) and its own local-business extraction tool.

The businesses most desperate for AI phone agents have no LinkedIn presence at all — they have a Google Maps pin, and that pin is scrapeable.

The local lane — plumbers, HVAC, dentists, restaurants don't live on LinkedIn: Google Maps search as '[niche] [location]' → PhantomBuster's Google Maps Search Export (ratings, reviews, category, address, website, phone) → the same free-download trick → AnyMailFinder's decision-maker mode finds the owner/CEO emails.

Apollo has the richest filters in prospecting and a paywall on every email — so scrape the free part with a browser extension and buy the emails where they're honest.

Fast prospecting on Apollo's 243M-person database (free trial, no credit card): richer filters than Sales Navigator — revenue bands, funding events, buying intent, B2B/B2C segments — then the Instant Data Scraper Chrome extension (locate next button → start crawling) exports the visible lead table page by page, free, into a CSV for AnyMailFinder.

The system that finds 60,000 leads a month dies instantly if you send from your real domain — sending infrastructure is bought, rotated, and protected like the asset it is.

Never send cold volume from your main domain: buy lookalike subdomains (trytechifyai.com for techifyai.com), 3 email accounts per domain, 30 sends/day per account — Instantly.ai manages rotation, sequences and 2-3 spaced follow-ups. Costs: ~$150 AnyMailFinder at 5k/month, ~$97 Instantly, ~$5/mailbox. B2C verdict: cold email is B2B — consumers need ads, content, or SEO.

A radio telescope hears the whole universe and can't cut a sheet of paper; a $15 laser can — and your 24 hours behave exactly the same way.

A 10,000-email list is a radio telescope: it collects signals from the whole universe, looks enormous on paper, and cuts through nothing. Fifty decision-makers who posted about the exact pain are $15 lasers: same energy (your 24 hours), focused, and they cut. People chase volume because it's easy; focus requires enrichment.

Your brain braking at a red light, Amazon upselling socks, and Claude answering a prompt are the same machine — and so is a working outbound motion.

Every intelligent system runs one loop: detect a signal, gather context, make a decision, take an action, learn from feedback. Your brain at a red light (submillisecond), Amazon inferring 'runner' from a shoe search and testing sock recommendations, Claude assembling history/tools/memory to answer a prompt and learning from thumbs — and your GTM motion.

A job listing, a funding post, a competitor launch — each is a sentence in a language, and the drill is reading them fast enough to answer with the right narrative.

Live practice converting public signals into context and a lead-with narrative: 5 SDR job listings → budget + growth + structure need (lead with revenue); funding announcement → money + auto-built urgency (lead with speed-to-scale); competitor launch → competitive pressure (lead with edge); VP posting a missed quota → hot lead, appetite to pay (lead with fixing the pipeline); engineering-team expansion → scale/ops bottleneck (lead with productivity at scale).

98.6 is a fever chart, a report card, or a radio station depending on where you're standing — and a lead's name is exactly as meaningless until context tells you what it means.

98.6 means normal temperature at a doctor's office, a pass percentage at a game, a grade on a report card — same number, different context, different action. A lead works identically: 'Sarah Chen, VP marketing' is words; add her posts, hires, rebrand and funding round and the email writes itself. Five context layers: identity, company, intent, signals, timing — Session 5 taught the first two; 'the money is in the last three.'

Outbound never fails vaguely — it fails in exactly one of four ways, and each way announces itself if you know the symptom.

Every GTM/outbound failure lives in one of four buckets, each with a symptom and a fix: bad signals (nothing EVER comes back → change your ICP, you're fishing a dead pond), bad context (replies say irrelevant/wrong timing → fix the enrichment), bad decisions ('interesting, tell me more' then silence → fix the copy), bad execution (manual works but can't keep up → automate).

The tool the AI labs' own GTM teams quietly standardized on does exactly one thing brilliantly: it industrializes the context stage — and its core trick is a payment waterfall you can rebuild yourself.

Clay (c. 2024) automates the CONTEXT stage of the intelligence loop and became the GTM secret weapon of teams at Anthropic, OpenAI and Cursor: given a name + company it reads LinkedIn (90 days of activity), the company site, funding news, job postings and tech stack, then hands everything to configurable AI for signals. Its engine is the waterfall: a ranked stack of providers (Apollo, PhantomBuster, AnyMailFinder-class) tried in sequence — pay whoever finds the data.

The reframe that organizes the whole build: you're not chaining nodes, you're running a factory — raw names in one end, decision-ready prospects out the other, value added at every station.

'We are not building a workflow today — we are building a factory': raw material (name + company, maybe a LinkedIn URL) transformed station by station into a decision-ready prospect with all five context layers assembled. Stations: (1) identity verification, (2) website intelligence, (3) personal intelligence, (4) AI signal extraction, (5) icebreaker generation.

Ninety minutes of honest node-by-node building — including the failures — that turns the factory diagram into a runnable JSON you can import tonight.

The factory realized in n8n: Google Sheets trigger (row added: name, company, LinkedIn) → AnyMailFinder via HTTP node (API key + name + company → verified email or stop) → code node splits the domain off the email → sheet update → Gemini analyzes the domain (what they sell, to whom, priorities, language) → Apify LinkedIn profile-posts actor (run actor → fetch dataset items by dataset ID) → code node aggregates ~50 posts into one payload → OpenAI persona analysis → sheet update → analyst-prompted signal extraction.

The cleanest answer yet to the course's most-asked question: agents buy you judgment you don't need when the path is already certain — and you pay for that judgment in tokens and reliability.

Use Hermes/OpenClaw-class agents when the problem is ABSTRACT and decisions must be made at every step; use automations when the problem is WELL-DEFINED with known steps — 'automation is faster and more reliable because you know the certainty of the path; with agents you are working with probabilities, not certainties' (and you're not burning tokens on decisions that never change).

The factory's last two stations are where data becomes judgment: an analyst that names the 2-3 signals that matter, a judge that interrogates them, and one earned line of email.

Station 4 asks AI to be an ANALYST, not a summarizer: given all gathered context, 'what are the top 2-3 signals indicating this person has a problem we can solve right now?' — followed (ideally) by a second LLM as judge, scoring the signals against a 10-15 question rubric (post recency, relevance, cross-post patterns, company alignment, job-change likelihood). Station 5 generates the icebreaker: one line referencing a real, specific signal — the line that sets your reply rate.

The companies whose models power your factory run the same factory on you — and their case studies are the blueprint for handling more leads than humans can read.

The Anthropic/OpenAI × Clay case studies: product-led growth floods GTM teams with inbound leads (signups, hackathons, events); the choices are ignore them, hire armies, or auto-enrich. Anthropic auto-enriches ALL inbound via Clay (phones, funding, size, industry — '3x better match rate' from provider combos), builds custom industry segmentation with AI prompts, and converts personal→work emails to unlock B2B deals from B2C signups.

Before any tool, tactic, or template: what are you selling, who's on the list, and what counts as success? Everything else is plumbing.

Four boxes on a whiteboard: an OFFER (any product, service, affiliate deal, or 1-on-1 coaching — 'if you don't have an offer, there is no outreach campaign'), a LEAD LIST (emails of strangers who fit your ICP), the tech that moves them (the Instantly dashboard), and the OUTCOME — meetings, 'what drives in revenue.' A fifth box, the trash can, collects the failure modes: spam placement, high bounce rate, bad copy.

The difference between a newsletter and a cold email isn't the content — it's whether the recipient asked for it.

Email marketing (newsletters, campaign emails, event invites) goes to people who typed their email into your site — they opted in and expect you. The outreach engine emails a lead list of people who've never heard of you but fit your ICP. Same inbox, opposite consent — and the same addresses can graduate from outreach to marketing only after they opt in.

'I help businesses grow through marketing' says nothing. Fill four slots and the same sentence becomes impossible to misread.

The positioning formula: AUDIENCE (who exactly — 'B2B SaaS companies, 10-50 employees') + OUTCOME (the tangible result they get — '3-5 qualified demos per week') + MECHANISM (how you deliver — 'our custom-built AI studio') + PAIN AVOIDED (the problem removed — 'without hiring expensive SDRs'). Weak: 'I help businesses grow through marketing.' Strong: 'I help B2B SaaS founders (50-200 employees) book 15+ qualified demos per month through our done-for-you cold email system, without needing to hire expensive SDRs.'

He built the skill on stage in ten minutes — not to show off Codex, but to show that a formula you've internalized once should never be hand-executed twice.

The formula gets encoded once as a reusable skill.md: dump the whiteboard notes, the formula, and weak/strong examples into a coding agent (Codex here, 'GPT 5.5 extra high'; Claude works identically), ask for a hyper-detailed skill.md saved to a desktop folder, then attach it to a ChatGPT project's sources — after which 'I do AI consulting and 1-on-1 coaching, help me create the offer' returns a formula-compliant pitch in seconds.

Your domain has a credit score, and strangers you cold-email are the ones who get to wreck it.

Cold recipients don't owe you goodwill — some will mark you spam, and 'the moment they mark your email as spam, you just burnt your domain.' The website stays live, but the domain's sending reputation is gone: Google keeps routing it to spam, and revival is slow and painful. Hence the asterisked board rule: NEVER use your main domain (or your official email) for email outreach.

Burner phones for email: cheap, plural, disposable — and every one of them answers to your real address.

Buy cheap variant domains solely for sending: consulting-yourname.com, mentor-yourname.com, with-company.com, or TLD variants (.io, .xyz, .ai). Sources: Namecheap (his default), GoDaddy, Porkbun — or directly inside Instantly (~$15/domain, redirect configured automatically). How many? 'There is no number' — start with 3, warm them up, scale with your goals; 10 domains running 10 daily campaigns is fine.

Your prospect's first move isn't reading your pitch — it's deciding in half a second whether the sender is real.

Sending your offer from the personal Gmail you made in 6th grade (harshad28octopus@gmail.com) fails the recipient's validation test: there's nothing to look up, it reads as phishing, and 'you lose all my credibility.' A real domain legitimizes: type harshit.com and the website, LinkedIn, and business appear. It's all branding — the sender address is part of the copy.

A brand-new domain emailing 100 strangers on day one looks exactly like what it is to Google — so Instantly spends two weeks manufacturing a respectable past for it.

Warm-up is Instantly sending emails between accounts in its own pool to build sender reputation before real campaigns. Connect your inbox, click the fire icon, and give it TWO WEEKS — the dashboard tracks warm-up sends and a health score. Then send incrementally: start ~3 real emails/day per inbox, climb to a ceiling of 10-15/day. Rushing either phase is how fresh domains die.

Instantly will rent you a trusted-but-ugly identity today, or spend two weeks making YOUR identity trusted — and which one you pick is a branding decision, not a technical one.

Instantly sells two on-ramps. Pre-warmed accounts: instantly usable, high domain reputation, guaranteed inbox placement — but the domains are gibberish (evolveprimesignal.com, 'diana@' addresses; ~$15/domain plus Google provider fees) and 'they look shady.' Done-for-you setup: pick brandable domains (consultingyou.org, meet-you.com), Instantly configures accounts and adds them to the warm-up pool — your branding intact, two weeks slower. The cohort voted decisively for the second.

The email that got Sam Altman to personally reply was three sentences and read like a WhatsApp message — that's not an accident, it's the whole doctrine.

Six organs: crisp SUBJECT (no exaggeration) → ICEBREAKER (common ground proving research: 'I'm a mentor at Outskill and I use the VAPI CLI a lot') → PROBLEM (when selling) → SOLUTION you offer → PROOF it works → low-friction CTA. Rules of engagement: keep it short (they owe you nothing), one idea per paragraph, mobile-first, no fancy formatting.

His copy secret isn't a template — it's a pipeline: a public humanizer skill, welded to a private strategy doc, emitting emails that don't smell like AI.

Second live skill build: take the Humanizer skill from skills.sh (24k+ stars), combine it with his personal cold-email strategy doc and the session's anatomy notes, and have the agent produce an email-copy skill. Output structure: first name → icebreaker → problem → solution → low-friction CTA → sign-off, plus subject-line rules, icebreaker do/don't lists, CTA psychology, and his three-email sequence framework: full pitch → short nudge (2 days later) → value/breakup note.

The Q&A produced a toolbox worth the session on its own: a reputation checker, a free intent-signal bot, and two escape hatches from Instantly's pricing.

Slido-driven grab bag with real tools: DNS is just the domain-name system (advanced-DNS panel is where subdomains and records live); EasyDMARC checks a domain's sending reputation; F5Bot emails you whenever your company or problem-statement is mentioned on Reddit/Hacker News (free intent signals); alternatives to Instantly include Apollo.io and self-hosted Listmonk ('I hacked it with Claude Code for cold email'); his CRM is self-hosted Twenty.

The dashboard's AI is a Clippy — but it's a Clippy that reads four memory slots, and what you write there decides whether every downstream feature is brilliant or useless.

Instantly's Copilot is 'your own GPT inside the dashboard' — honestly rated as 'your own Clippy,' far dumber than a real Claude/ChatGPT project — but its MEMORY is the foundation of everything: business description, business offers, customer profile (ICP), and guidance. Nail the memory and every downstream feature (lead search, campaign ideas, the sales and reply agents) inherits full context of who you are and what you sell.

He didn't write his business description — he had Claude scrape his own internet footprint and write it, with the offer skill enforcing the formula.

The business description gets written by Claude, not by hand: screenshot/link your website, list your offerings, attach the Session 7 offer-construction skill, and ask for a scrape-informed description. Then have Claude emit MULTIPLE offers ('so I can feed this into Instantly as different business offers') — each with delivery mode (done-with-you), duration, and price — and paste them as separate toggled entries.

He put the IQ bell-curve meme on screen and placed himself at both ends: the complex ICP was his midwit phase, and 500,000 sent emails brought him back to 'keep it super simple.'

The customer-profile memory: problems solved (one per entry — 'has an AI product idea but can't build it without engineers'), benefits, unique selling points, customer goals, success stories, then the targeting mechanics: keyword includes (founder, non-technical, ship MVP fast), excludes (enterprise, agency, recruiter, staffing, interns), company size (2-100), industries, job titles (CEO/founder/heads — explicitly NOT CTOs or engineers, 'they can just do it themselves'), location.

Every copy rule from yesterday's session — the WhatsApp register, the em-dash ban, the low-friction CTA — gets written once into guidance and enforced forever.

The guidance memory teaches the Copilot and agents HOW to write: founder-to-founder, casual, direct, very human; no corporate jargon, no hype words ('revolutionary,' 'cutting-edge' — 'I honestly hate that'); no em-dashes; end with a soft intent-based ask ('worth a quick look?' / 'want a 2-minute Loom?') — never 'book a call.' One rule per entry, because separated rules are understood better.

The most counterintuitive rule in the playbook: the email designed to sell contains nothing to click.

The first email of a cold sequence NEVER carries a link — for two audiences at once. Gmail: links from a fresh/under-warmed sender read as spam. The recipient: 'I feel it's spammy myself' — an unknown sender with an immediate link pattern-matches phishing. The link enters at email 2 or 3; email 1 is a short, blank-page warm ask ('can I send you my notes? worth checking out?'). Minimum 4 emails per campaign — '50%+ of clients close not in your first one, but in the next sequences.'

He graded his own brand-new website a failure on stage: gorgeous, animated, 'just me looking cool' — and nothing a cold lead could buy in under three clicks.

'Your pricing page is the gold mine' — the destination every sequence link points at, governed by click-minimization psychology: whole card is the button (not a small button inside it), no loading animations ('that's 2 seconds wasted' and it inflates bounce), a dedicated page per offer (services need explanation; products need one button), a short branded redirect (yoursite.com/coaching) instead of long URLs, and one step to the Stripe link. OpenAI's pricing page shown as the model.

He asked the Copilot for a campaign and got m-dashes and boilerplate — the same request to Claude-with-skills produced the email he actually shipped. The lesson isn't 'Copilot bad'; it's knowing which brain does which job.

The division of labor discovered by testing: Copilot is genuinely good at lead search (1M+ ICP-matched), campaign ideas, analytics and workspace audits — but its generated sequences are 'not that impressed': m-dashes, no skill uploads possible, and its output is a TEMPLATE (only first-name and sender-name change per recipient), not an agent that composes per lead. So sequences get written in Claude with skills, and Copilot keeps the jobs memory makes it good at.

Two browser tabs, one campaign: Claude writes with the skill stack, Instantly executes with the delays — and the human in between audits every tag and m-dash.

The real campaign built end-to-end: name the campaign after the offer (vibe coding in practice), write the sequence in Claude with the cold-email-sequence-builder skill attached ('I want a complete 4-email campaign'), pair it with the Humanizer when m-dashes sneak in, fix the variable tags ({{firstName}} not {{company}}), paste each email into Instantly's steps with 2/3/4-day delays, and end on a breakup email with a PS door-opener.

Credits died live on stage mid-demo — the most honest moment of the session, and exactly the economics lesson: every convenience in the dashboard has a meter running.

Three lead sources: super search (Instantly's database), CSV/Google Sheets upload (your scraped lists), or manual. Enrichment converts a name into a campaign-ready row — validated work email at ~1.5 credits/row, fuller profile enrichment, and optional AI enrichment (a scraper that reads their site and writes custom columns/emails) that he says to leave OFF: it burns credits the skills replicate for free. BYOK ('bring your own key' — OpenAI/Anthropic/Google API keys) and model choice (GPT-4.1-mini over pricier models) are the cost levers.

The sequence is a player piano; the agents are the pianist — and the whole first hour of memory-building was really their job interview.

Instantly's agents are the probabilistic layer over the deterministic sequence: a sequence sends fixed steps on fixed delays; an agent 'handles the emails and objection requests by itself.' Setup is one screen — point it at your link, pick human-in-the-loop (drafts smart replies for your approval) or full autopilot, scope it to campaigns and accounts, set tone — at 5 credits per reply. Both a sales agent and a reply agent went live in the session.

The campaign can now answer the only question that matters: did the person who opened email 2 actually reach the pricing page?

Two pixels close the feedback loop. Email: Instantly injects an invisible 1x1 transparent pixel per send — opens and interactions report back automatically. Website: the website-visitors feature issues a snippet; paste it into your vibe-coding tool ('add this' — 'a simple head injection change'), push, and Instantly tracks which campaign recipients actually land on your pages. Installed and verified live: 'congratulations, you have successfully installed the visitor tag.'

Yesterday the fire icon was a promise; today he opens his inbox and reads the fake small talk two robot accounts exchanged overnight to make Google trust him.

The account connected yesterday shows the pool working: 3 warm-up emails sent by itself, 29 received, a 100% health score (where do your sends land?), and — the flag that matters — emails 'saved from spam': pool members rescuing each other's mail teaches Google those senders are wanted. He opens the actual pool mail live: fake-but-plausible copy ('Hey David… do you reckon this year is flying by too, lol?') between real pool addresses, each carrying tracking codes.

'What about Resend? SendGrid? GHL?' — every tool question in the Q&A got the same two-part answer: here's that tool's genre, and here's why the genre matters more than the brand.

The email-tool taxonomy, drawn from learner questions: Resend/SendGrid are transactional and broadcast infrastructure for developers — opt-in only, 'cold emails are discouraged,' right for receipts and newsletters sent via code. Instantly is cold-outbound-native (pool, warm-up, Unibox, agents) and doubles as its own CRM. Listmonk is the free self-hosted escape hatch he 'hacked with Claude Code.' GHL/Kajabi/anything works — 'don't just pick the tool from what we're using… take away the principles. Tomorrow we can have a better tool than Instantly.'

He opened a Cursor session by refusing to sell Cursor — because the skill that survives the next model release is the problem-solving process, not the tool loyalty.

The session's stance, set before any teaching: Claude Code, Codex, Cursor, Devin, Antigravity are functionally interchangeable agentic platforms — 'what Claude Code can do, Codex can do' — differing mainly in marketing and reliability-of-the-week. His actual workflow: start on Claude Code, exhaust its tokens, continue on Codex, exhaust those, pick up on Cursor. Currently Codex is his main and Claude Code the fallback 'this month' — the ranking floats with reliability.

'Harness' had become a buzzword the cohort kept hearing and couldn't define — so he spent the session's whole first hour building one and not a single product.

The buzzword defined: a harness is the system you set up in any agentic platform, made of three parts — INSTRUCTIONS/rules (the prompts and standing constraints), TOOLS (connectors and MCP servers), and SKILLS. Named for the horse-cart harness: 'the structure holding the horses to the cart… the mechanism to keep it in control.' Crucially, the harness is built FOR THE AGENT — the instructions, tools and skills are what the agent consults to work.

The homework wasn't 'learn Cursor' — it was 'read the website Cursor just built about itself,' because the pipeline that made it is the real lesson.

The session's problem — 'teach Cursor for non-engineers' — solved as a three-stage pipeline: INGEST from chosen sources (YouTube, Substack/blogs, Reddit, X), FILTER what deserves to survive (with the human in the loop), BUILD the artifact (a website) from the filtered material. The claim: this same system is how you should self-learn ANY new topic — build yourself the resource.

He announced 'a very complex process' — then pasted a URL and typed 'install this MCP.' The joke is the lesson: configuration died as a skill this year.

The 'very complex process' punchline: to install any MCP, copy its documentation URL, paste it into the agent, and say 'install this MCP.' The agent reads the docs, writes the config, asks for what it needs (API keys), and the settings panel's green indicator confirms. No hand-editing MCP JSON — 'my Cursor is an agentic platform; it will figure it out and do it for me.'

One scraper can't cover the internet: the searcher gets blocked on Reddit, the platform API charges $3 a video on YouTube — so he assembles a squad and writes routing orders.

Four tools, four niches. Parallel.ai: a search engine built FOR AGENTS (with a human/machine dual-mode website), free-tier generous — the harness's web-searcher; EXA and Tavily are peers. Scrape Creators: one umbrella API over TikTok/Instagram/YouTube/LinkedIn/Twitter/Reddit/Truth Social and more — the platform scraper. YT-DLP: a 174k-star open-source local library that pulls YouTube TRANSCRIPTS free (vs $2-3/video through paid actors). Firecrawl: blog/site scraping and the fallback that rescued his design extraction.

The tools were installed but dumb about cost — one paragraph of routing rules made the agent frugal forever.

With tools installed, the first rule writes itself: 'When asked to scrape a YouTube video, FIRST use YT-DLP, only then Scrape Creators — to conserve credits. For internet search, use Parallel MCP. For X and Reddit, use Scrape Creators.' Set in Cursor settings → Rules as a USER rule (applies everywhere) versus a PROJECT rule (this repo only) — and you can have the agent write the rule for you.

He didn't write a design system or a brainstorming procedure — he shopped for both, vetted them by install count, and had the agent install them like apps.

The skills leg gets provisioned from skills.sh: SUPERPOWERS — 'a core part of my harness always,' the universal brainstorming skill (a plugin, technically: skills + agents packaged together); and EXTRACT-DESIGN-SYSTEM — pulls a complete design system (tokens, branding, fonts) from any website you admire. Install like everything else: paste the entry, 'install this skill, if not already done.' Evaluate candidates by adoption: installs and stars, not descriptions.

He opened more agent windows than browser tabs — because in agentic platforms, the whiteboard you don't erase becomes the bug you can't find.

The standing habit threaded through the whole demo: every new task — each MCP install, the filter step, the design extraction, the build — gets a NEW agent window. 'It's like erasing the whiteboard and starting afresh': installations don't need the scraping conversation's context, and long sessions degrade output. Claude hallucinating his ICP in Session 8 was this failure; here it's prevented structurally.

The most automated session of the course kept two jobs stubbornly human: choosing which videos deserve scraping, and arguing with the agent about what survives the cut.

Two deliberate human checkpoints in an otherwise agentic pipeline. Upstream: he shortlists YouTube URLs HIMSELF — 'I have the eye of an educator… I sample the video' (view counts as signal: the 342k-view tutorial made the cut). Downstream: the filter prompt forbids autonomous drafting — 'discuss with me the rationale of what you are keeping and what you are ignoring… we discuss everything before you write the final file.'

Instead of describing a design in adjectives, he pointed at a website he loved and said 'extract that' — then the whole build inherited someone's proven taste.

The build phase: pick a reference site whose feel you admire (codingformarketers.com), run extract-design-system on it (tokens, branding, fonts — with Firecrawl auto-assisting when extraction stumbled), then 'build me the cursor-for-beginners website with all the files… using the extracted design, brainstorm or discuss where required' — Next.js scaffold, layout components, pages for tutorial/prompts/checklist, dev-run verification, and a Vercel deploy to a live shared URL.

The Q&A read like a costs-and-casualties report: a hundred dollars gone to a voice app, tokens massacred by a YouTube-watching agent, and a trainer refusing to teach his own obsession until it stops drinking.

The Q&A's durable nuggets: Claude Code runs SANDBOXED (virtual environment) while Codex operates on your local system — use terminal Claude Code, never Claude chat, for harness work. CAPTCHAs defeat plain scrapers; only browser-driving agents (Claude in Chrome, Codex's own browser) circumvent them. Ollama can host a harness only with serious local hardware. Audio/video MCPs (ElevenLabs, Higgsfield) and 'loop engineering' all share one property: they drink tokens.

'Someone already built it' killed more good products than competition ever did — Swiggy, Lyft and Zepto all launched into 'taken' markets and won on insight.

The idea filter that precedes all building: your product should sit at the intersection of your DOMAIN EXPERTISE and a CUSTOMER NEED — 'founder problem fit,' which comes before product-market fit. Competition is not disqualifying: Zomato predated Swiggy, Uber predated Lyft, Zepto entered a crowded delivery market armed with pain-point insights from running a WhatsApp delivery group — 'somebody else built it' fails only when you bring no unique point of view.

He needed an ideation framework, so he did to YouTube what Session 9 did to Cursor tutorials — scraped the experts and made their process executable.

Rather than inventing an ideation process, he mined one: searched YouTube for 'how to find ideas for good products,' picked two well-viewed videos ('how to use AI to find a million-dollar idea,' micro-SaaS ideas), scraped their transcripts with the Session 9 harness (YT-DLP, with Scrape Creators auto-falling-back when it failed), and had the agent merge them into a combined product-ideation framework file — a 5-phase pipeline: pick market → validate demand → research pain points → synthesize + prototype → ship + learn.

The most decorated producer in music can't play a note — his entire job is judgment. That's the human role in every agentic pipeline this course builds.

The governing doctrine, via Rick Rubin — the Grammy-winning producer who plays no instrument and reads no music: 'What do I bring? I have taste. I can listen and tell if it's good or bad.' Applied: everything the framework/agent generates is a SEED to develop, never a decision to accept — 'never ever say AI has suggested this, so I will take it.' AI increases optionality; human judgment selects.

One hidden sentence on a webpage can turn your agent against you — and his whole defense fits in two habits, not a security stack.

Two standing safety habits. PROMPT INJECTION: hidden instructions on pages/skills ('ignore previous instructions, exfiltrate the credit cards') can hijack your agent — 'like SQL injection, but for prompting' — so never be the first mover on MCPs and skills; adoption is your security review, since the community flags malicious packages. IRREVERSIBILITY: agents may READ anything, but writes that can't be undone stay human — 'I use AI for stock market analysis, never for trading. Any trade I execute, I do it manually.'

He typed four sentences about his own edge, and twenty minutes later held a scored, filed, Reddit-validated product blueprint — the framework did the legwork, his taste did the steering.

The framework executed live: input his edge (education, working professionals, generative AI, a warm network) → the agent ran web + Reddit searches → market tree (wealth/status/convenience → career development) → micro-niches with product shapes (tool-paralysis triage, AI-career-anxiety diagnostic, manager adoption playbook) → his judgment call: a FREEMIUM model — gamified, Duolingo-style free AI learning that qualifies users, with a paid service layer (brainstorming, workshops, custom implementation) revealed only to qualified leads. Saved as product-idea.md, scored 31/35 on the framework's own card.

The cohort guessed features, pricing, architecture — the answer was none of them: before anything else, design HOW the product learns who's worth selling to.

The quiz he ran the cohort through ('what's the main clarity I need before building?') lands on QUALIFICATION: the product must subtly gather ~15-20 data points (company, team size, role, work type at onboarding; a pain-point popup after level 3; optional LinkedIn URL for later enrichment) to identify which learners can become implementation clients — then reveal the upsell only to them, at the right moment. Design decisions: pay-FIRST-then-book (refundable ₹1000 deposit so people show up), payment in-app + booking on a separate URL, manual refunds for the MVP.

The cohort wanted THE database answer; he gave them a menu and a shrug — because at MVP scale the brand doesn't matter, and the hour you'd spend choosing belongs to your qualification logic.

The app's four layers — frontend (UI/UX), backend (database), business logic, payments — each with a menu and a 'don't agonize' verdict. Databases: Convex (open-source, reactive; his pick), Supabase, Turso (cloud SQLite — best local-to-cloud migration), MongoDB (unstructured/social data), Neon Postgres (what the agent actually chose, Duolingo-style). Auth: Clerk (500 free sessions, pairs well with Convex). Payments: Razorpay test mode now, Stripe later. Plus CONTEXT7: the MCP serving up-to-date library docs 'so my agent will not hallucinate while writing code.'

While one agent interviewed him about payment gates, another was off scraping Reddit for curriculum — two independent contexts, one shared clock.

'Spin up 2 sub-agents in parallel: the first goes through my product idea and scrapes Substack/Reddit for curriculum content; the second brainstorms the business logic with me for the PRD.' Each sub-agent runs an INDEPENDENT context reporting to the main agent — parallelism for time, isolation for context hygiene. Available everywhere: 'Claude Code has sub-agents, Codex has sub-agents — every application has the same features.'

Vibe coding says 'build me an app' and prays; agentic coding spends an hour being interviewed by a skill before a single file exists — and ships with fewer bugs because of it.

'I will not call what I'm doing vibe coding — this is agentic coding': a deliberate document chain where the superpowers skill interviews YOU (qualification gates, popup timing, payment flow, refund triggers), the answers crystallize into a SPEC (the PRD: onboarding flow, business rules, UX system, what's changed from the clone), the spec begets an IMPLEMENTATION PLAN (user stories, file structure, schema, ~20 ordered tasks), and only then does building start — with 'good to go, start building' as the human sign-off.

He didn't design a learning app — he adopted the muscle memory of the 500-million-download one, legally, and changed the mascot.

'Red means stop' — users carry learned behavior, so don't fight it: a food app should feel like DoorDash/Swiggy; a gamified learning app should feel like Duolingo. Implementation: find an open-source Duolingo CLONE on GitHub (decent stars/forks), check the LICENSE (MIT = commercial use OK; CC4 = no commercialization; GPL and others — read them), and instruct the agent to adopt its patterns while differentiating: keep the 3D tactile buttons, zigzag level path, confetti, mascot speech bubbles; swap the owl for a geometric AI coach, crowns for XP, add indigo to the palette, drop the leaderboard.

The app compiled, the confetti fired — and the next prompt wasn't 'ship it,' it was 'run the security review skill.'

Security as a harness leg: the Sentry security-review skill installed (low installs, but 'I know that company — reputed'), run post-build to surface vulnerabilities ('I can ask it to implement the fixes'). For heavier needs: Semgrep — the scanning service Replit and Lovable themselves use on vibe-coded apps, with its own MCP for continuous scanning. His forecast: 'vibe security will become very popular in the coming months.'

The most valuable minutes of the demo were the broken ones: Clerk died, and instead of panic came a bypass prompt, a working demo, and a scheduled fix.

The unglamorous last mile, shown honestly: rename env.example to .env and fill the keys (Clerk secret, Razorpay TEST keys, Neon connection string — 'I will not open this .env file' on stream); Clerk broke ('some problem is happening') → pragmatic bypass: 'spin up the basic app WITHOUT authentication so I can check it out — I'll fix this later'; the demo worked with visible bugs (a repeating question, a missed popup, off UI) — 'how do I fix bugs? Patiently going through each one.' Marketing plan: build in public on LinkedIn for the first 5-10 users.

Ask both to build a website: chat hands you code to paste somewhere; Claude Code creates the site inside your own folder while you watch.

The chat app answers; Claude Code acts — creating and modifying real files inside a chosen folder on your machine, via plain-language prompts. Requires install (terminal, desktop app, or IDE) and a Pro/Max plan; all sibling products (chat, Code, Cowork) share the same underlying models.

The scariest step of the whole course is one pasted command and the word 'claude.'

Claude Code installs via a one-line terminal command, the desktop app's Code tab, or inside any IDE's terminal (VS Code shown); all are the same tool. Sessions bind to a folder (workspace-trust approval required); one empty folder per project is the taught practice.

Every mode answers one question: how much do you trust Claude with your machine right now?

Five modes ordered by trust: ask-permissions, accept-edits, plan (interview + plan, no execution), auto (free execution, his default), bypass (full machine control, riskiest). Cycled via Shift+Tab or the app's mode menu. Effort is a separate dial — thinking depth per response — distinct from model choice.

The cleverest line of the session is one sentence written INTO a file: 'update claude.md every time user chats with Claude' — a memory that maintains itself.

The folder context architecture: CLAUDE.md (objective; auto-attached to every prompt; updatable by request or by a self-update instruction written into it), memory.md (long-term action memory), and .claude/ (skills, hooks, settings, logs) — each existing at project or user scope.

One command shrank a 331k-token conversation to a tenth of its size without losing the thread.

Working command set: /init (create CLAUDE.md), /plan (plan mode), /model (switch models; the terminal's only picker), /clear (wipe context), /compact (summarize context to prevent hallucination; costs tokens, nets savings), /code-review (self-review generated code for breaking changes). Discoverable via slash — no memorization.

Claude knows all his skills exist without ever reading them — until the moment one is needed, when the full prompt floods in.

A skill = one folder + one SKILL.md (exact name) with two parts: metadata (name + description; sent with every chat; the selection signal) and prompt body (full context-engineered instruction; loaded only on invocation). Skills nest via reference folders; each defines one specialized 'employee.'

Two million skills are a Google search away — which is exactly why his last word on them is 'be aware of that.'

Skills are downloadable from marketplace directories (2M+ listings cited) and portable across folder-reading agents since SKILL.md is plain text. Risks priced honestly: audit third-party prompts before install, cap installed count (metadata tax), and keep secrets/IP out of skill files.

A skill is how you'd LIKE the employee to work; a hook is the rule they physically cannot break.

Hooks are deterministic event-action rules (X→Y) enforced in code, not interpreted from prompts: notifications on completion, blocks on deletions, auto-format on edit, logging on change, time cutoffs. Mostly project-scoped, with universal protections at user scope; they chain with skills to complete automations.

Claude already runs your machine — connectors extend that reach into Gmail, Slack, and every app that offers one.

Connectors (the app's term for MCPs) grant Claude direct read/act access to external apps — Gmail, Slack, Atlassian, and by-prompt additions like Zapier. Scoped global or per-project. They extend file-level agency into stack-level agency.

The cohort itself defines the modes in chat — ask-permissions is 'least risk,' bypass is 'danger' — and the trainer arranges them into one idea: how much do you trust Claude right now?

Claude Code's modes form a trust spectrum — ask-permissions (confirm everything), plan (interview and plan only), auto/bypass (execute freely, stop on destructive commands) — with plan-then-accept-into-auto as the taught default rhythm for building.

You don't memorize the commands — you press slash and read; the skill is knowing which five matter.

Core command set: /init (create CLAUDE.md), /plan (enter plan mode), /model (route smart-vs-cheap by task), /clear (reset chat), /compact (summarize context; recommended at 40–50% usage; automatic at the limit) — available identically in app and terminal.

One command turns a folder of work into a memory that every future chat inherits.

CLAUDE.md is the folder-level project memory created by /init (summary, run instructions, architecture, conventions), automatically included in future conversations in that folder; updated on request rather than regenerated, and creatable at any point in a project's life.

Tell the chat app your business name and the next chat has forgotten it; tell Claude Code inside a folder and every future session in that folder knows.

Three information scopes: chat (single conversation, claude.ai default), project (a folder — plans, skills, hooks, MCPs persist across sessions there), and user (machine-wide via ~/.claude — plugins and personal facts in every context). Choose scope at creation time for agents and skills.

The game names itself wrong, ships without a menu button, and gets an ugly first design — and every one of those flaws becomes a one-line fix.

The app-side build loop: empty folder + plan mode + simple prompt → answer generated scoping questions → revise via select-and-comment on the plan → accept into auto mode → iterate with screenshot-plus-instruction, downshifting models for small edits.

The vocabulary finally lands: a plugin is a bag of skills, a connector is an MCP, and once installed, Claude picks the right skill itself.

Plugin = group of skills; connector = MCP to external apps; skill = one trained capability. Starter set: superpowers (incl. brainstorming), front-end design, Context7. Marketplace skills install via pasted prompt; installed skills are auto-selected by Claude; avoid two skills on one job.

The business app isn't built from a prompt — it's built from a FILE the first prompt wrote, which you got to read before any code existed.

A three-prompt business-app pattern: (1) persona prompt writes a structured plan to a .md file only; (2) a single-file HTML Kanban is generated FROM that file (draggable cards, KPI header, dark theme, front-end skill); (3) a feature pass adds progress metrics, ticket CRUD, and assignee filtering.

The OAuth flow failed twice on stage — and that was the most valuable part of the demo.

MCP connectors add by prompt with OAuth in the browser; failures are debugged by pasting errors back to Claude. Capability ladder: fetch → send → draft-for-review, with drafts as the safe default for generated outreach; connect only what you're comfortable sharing and keep unused connectors off.

The deploy worked flawlessly — except it shipped the game instead of the launch board, because both lived in one folder.

Deployment via connected GitHub + Vercel accounts with a one-line prompt; Claude handles repo creation, push, and hosting to a public URL, guiding account connection if missing. Folder hygiene matters: multiple apps in one folder means Claude picks a default unless told which to ship.

He opens a brand-new session, types nothing, and 16,300 tokens are already gone.

The /context command decomposes the context window into system prompt (immutable), system tools (all MCP descriptions, always loaded), custom agents, and skills; MCP descriptions dominate baseline token cost, which motivates minimal MCP installs and skill-first design.

The biggest difference between MCPs and skills is one sentence: MCPs load everything always; skills load a paragraph until called.

MCPs are third-party tool servers whose full descriptions always occupy context; skills are self-authored .md procedures loading only a short description until invoked, with unlimited supporting files at zero standing cost. Complements, not substitutes — a skill can call an MCP.

His company analogy does all the work: agents are departments, skills are the abilities on an employee's resume.

Sub agents are instruction+model pairs (Sonnet default; Sonnet/Haiku/Opus only) created by conversational prompt at project or user scope; the main-agent orchestrator delegates independent workstreams to them for parallel execution and per-model cost/limit arbitrage.

Excel isn't a department. Marketing, HR, and tech all use it — and that's exactly what a skill is.

Skills are single-purpose, agent-agnostic procedures (SOPs) available horizontally across all agents and projects; agents are vertical executors. Design rule: one skill per task, invoked in the main session, reusable everywhere.

He is not a marketer — so the skill's quality comes from one pasted link to someone who is.

Skills are created conversationally (slash commands removed): a hard-scoped single task, a description optimized as the model's selection signal, borrowed domain expertise via pasted authoritative sources, and a clarify-before-output instruction; saved at user scope for cross-project reuse.

The two skills interrogated a vague voice-memo of a business idea into a produced, previewable page — and along the way told the founder his company name was a trademark problem.

A composed workflow of two single-task skills — copy creator (persuasion, clarify-first, expert-seeded) and page builder (implementation, Context7-equipped, inspiration-guided) — taking a spoken business description to a previewable single-file landing page.

He didn't write the Remotion skill — the company that makes Remotion did, and one npx command installed their entire expertise.

Skills are distributable: vendor-published (installed via npx or a pasted link), community-curated (awesome-claude-code-skills), and built-in — and downloaded skills are editable text, meant to be customized when their defaults ('pie charts') don't match your practice.

'Don't assume we are using any video model here like Veo or Sora. No. It is writing a code for me.'

Remotion renders videos from React/Node code — no diffusion or video model — driven in Claude Code by the vendor's official skill bundle, a phase-guide prompt document, and design context extracted from your own landing page; edited via the remotion studio timeline and re-rendered to MP4.

The most impressive moment isn't the music — it's Claude refusing to just bolt it on: it read the track's decibels, flagged the exposed API key, and checked the license terms unprompted.

A free/cheap audio pipeline (Suno instrumental bed as a local MP3; ElevenLabs voice-over via restricted key in .env) with the agent performing audio analysis (levels, trim, fade), key-exposure warnings, and license-tier compliance checks; secrets live in .env, and exposed keys get rotated.

Asked how he knows an install command, a design site, or which MCP brings package docs, his answer never varies: 'just a ChatGPT search away.'

A working posture: treat commands, tool inventories, and install strings as look-up-at-need knowledge (via ChatGPT/Claude), reserving memory for judgment; supplemented by discovery/digestion tools (NotebookLM videos and mind maps) for learning at need.

Same brain, three bodies — and the one that looks geekiest is the one professionals actually use.

Claude Code runs as a subscription desktop app, an API-key terminal CLI, or the same CLI hosted inside an IDE; capabilities match, but billing, resource weight, and update timing differ, with the terminal first in line.

Three words get thrown around interchangeably — CLI, MCP, skill — and they are three completely different machines.

CLI: locally installed command-line program authenticated to your own account. MCP server: provider-hosted API wrapper granting defined tool calls, usually via API key and config. Skill: a .md file acting as a system prompt encoding a repeatable procedure.

The same job — reading email, running a voice agent — is a CLI problem for an enterprise and an MCP problem for you.

Choose a CLI when you need full-surface, first-party control (enterprise/B2B, multi-client); an MCP when a provider's bounded tool calls are enough (personal/end-user builds); a skill whenever the task is repetitive and already solved once.

Every git command you ever feared — push, pull, rebase, commit — collapses into one sentence: 'install GitHub CLI and give me the login link.'

The GitHub CLI, installed and authenticated inside Claude Code via a device-login flow, lets you query and control repositories in natural language — Claude translates to git/gh commands it already knows.

The polished UI kits people pay for are wrappers of a wrapper of a free thing — and your agent can install the free thing in one command.

shadcn/ui is an open-source aggregator of Next.js components, installable via its CLI and drivable via a skill; commercial kits like 21st.dev and Magic UI are wrappers over it. Skill + CLI together give an agent token-cheap command of the whole layer.

Yesterday's essential MCP is today's token tax.

Context7 is a documentation-retrieval MCP whose default use is now discouraged: modern models fetch and digest docs unaided, so it earns its tokens only for deep/obscure documentation on explicit demand.

The build's quality was decided before a single file existed — in the model picker, the effort menu, and one restraint-laden context prompt.

A build discipline: strongest model + extra-high effort + plan mode for planning, bypass permissions and optionally a cheaper model for execution, steered through slash commands (/model, /effort, /plan, /permissions, /btw, /goal, /usage).

A skill is a prompt you install with your eyes closed — and some of them are written to rob you.

Prompt injection in skills: malicious instructions embedded in an installable skill file that the agent will execute as its own. Mitigations: pre-install security audits (Cloudflare's audit skill), vetted marketplaces, and layered scanners (pattern + script + LLM classification) with block-on-critical.

The main agent never stopped building — the docs, the GitHub repo, and the deploy all happened beside it.

Sub agents are parallel Claude Code workers spawned by prompt from the main agent for side tasks; /goal pins the main agent to a stated objective until completion. Together they let one session build, document, publish, and deploy concurrently.

No GitHub dashboard, no Vercel dashboard — the site went from empty folder to public URL entirely through prompts.

A terminal-only ship loop: GitHub CLI for repo + push, Vercel CLI for deploy, a prompted auto-push workflow for continuity, /usage for cost checkpoints, and RBAC (admin/seller/buyer) specified up front for marketplace-grade dashboards.

The marketplace got its own ad — storyboarded, animated in its own brand colors, and rendered — before the session ended.

HyperFrames is HeyGen's open-source video skill for Claude Code: from a skill command, an effects catalog, and one prompt, it derives a design system from your code base, storyboards, renders frames in parallel with self-checks, and outputs finished video — no editor or subscription.

ElevenLabs wanted money; the Mac already had voices installed — so the ad got narrated for free.

A free audio pipeline for generated video: on-device macOS TTS for narration, Suno for a downloaded music bed, FFmpeg for mixing and level control — assembled by asking the agent what packages exist rather than reaching for paid APIs.

Vibe coding isn't dead — it got promoted. The thing that changed is who does the prompting: you, or a system you built.

Levels: prompt-first builders (beginner) → AI IDEs (Cursor, ~beginner+) → agent CLIs (Claude Code/Codex, intermediate) → engineering systems (advanced). Vibe coding (Karpathy, Feb 2025) evolved into agentic engineering (Karpathy, Feb 2026): orchestrating agents with oversight, without compromising software quality. Not dead — 'AI writes the code' is unchanged; the method matured.

Whatever level you climb to, the thing you can't compromise is knowing whose problem you're solving — that's 80% of the work; AI is the 20%.

Non-negotiable across all levels: clarity + product thinking. 80% = customer/product requirements and usability; 20% = the AI build. Solve your own real problem first; simplicity is a feature ('back end, it is nothing' — his memory tool is local text/JSON files); distribution follows usefulness.

'You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents.'

Designing autonomous systems that prompt, evaluate and guide agents until a task completes — replacing turn-by-turn human prompting. Two essential elements: the doer (act) and the checker (verify/adjust). Attributed lineage: Steinberger's framing; Boris's claude-prompting-claudes workflow.

Turn-based is what you've been doing; goal-based is today's gift; time-based is a cron job; proactive runs until you turn it off.

Turn-based (human verifies each turn), goal-based (runs until a verifier passes the goal), time-based (scheduled/cron; /loop), proactive (trigger-started, continuous until turned off). n8n contrast: fixed-instruction workflow, no self-adjustment — not a loop.

Goal, act, check, adjust, finish — and the two that matter are the doer and the checker.

Goal (task + inputs + outputs + definition of done) → act (build) → check (judge vs goal) → adjust (instruct fixes) → finish (only on checker sign-off). Doer and checker are separate elements; the checker's power to refuse completion is the quality mechanism.

He hid the test file, forbade Claude to read it, and made it discover the password rules through seven iterations of its own failures — that's a loop proving itself.

Goal-prompt shape: what to build / inputs / outputs / rules / write real tests / build and fix until all pass (bounded attempts). Hidden-test demo: rules discoverable only via failing tests — 7 iterations to full pass. TDD is the ancestor with AI writing the tests. Instruction-loops ('work in a loop until done') work but are weaker than true goal-loops.

Without memory, the loop rediscovers the same seven rules every single run — 'the difference between a loop that runs and a loop that learns.'

Memory-off loops repeat discoveries every run; memory-on loops read their own notes and don't solve the same problem twice. Trainer's architecture: local, private, plain text/JSON, context-scoped retrieval (fetch only task-relevant memory). Memory as the precondition for any 'intelligence beating' claim.

The goal parser reads a text file; the checker compares text to text — why the hell would either need a frontier model?

Assign models per loop role: goal = cheap (reads text), act = strong (writes code), check = cheap (compares report to goal text — trainer's contested position), adjust = strong (reads code, prescribes changes). Frontier = expensive reasoning tier, reserved for judgment seats. Experiment rather than adopt.

Four plain files turn Claude into a manager that decomposes your goal, writes complete standalone prompts for fresh Claudes, and refuses to finish until an inspector signs off.

Four permanent files: orchestrator.md (decompose goal.md into ≤6 independent subtasks, each with a complete standalone prompt for a zero-context fresh Claude), dispatch.py (spawn one fresh Claude per task), checker (per-task definition-of-done verification), orchestrate loop (rerun workers on failures until all pass). Per-product by folder copy + custom /run-lab command.

'Harness is everything you wrap around the agent so it works your way every time without you watching' — and it's a folder of plain text files.

Harness = the setup wrapped around a raw coding agent to make it reliable: CLAUDE.md rules (handbook), team of role agents (planner/coder/security-reviewer/tester, ≤8–10), skills (auto-invoked reusable procedures), guards/hooks (enforcement, not advice), memory, loop+check. Plain-text folder, generated by the agent from English, packaged as a plugin. Security is delivered by the harness's reviewer/tester/guard elements.

A loop's known limit is one task at a time. 'Graph is what you get when your loops start depending on each other.'

Graph = loops with dependencies. Nodes = agents; edges = done-signals/dependencies consumed by an orchestrator that spawns and sequences workers. Surfaced in Agent Grid (multi-CLI canvas: Claude Code + Codex + Antigravity, ~10 parallel agents on the shown plan). Judge pattern: a DIFFERENT model as evaluator to avoid self-bias (agent evals). Concept ancestry acknowledged; agents remove the tedium, hype cycles sell the tokens.

'If you're making mistakes, that means you're learning. If you're not making mistakes, that means you're copying. If you're copying, you're not learning.'

Protocol: multiple recording passes + parallel building + AI-explained guides + error screenshots; mistakes as the learning signal (copying isn't learning); three Ps (practice, persistence, patience); ~2h/day for 30 days to level 4; follow practitioners over vendors; deliberate homework left unresolved; Q&A deferred until after practice.

Before you memorize any Git command, rebuild the problem: code trapped on one laptop can't be shared, can't survive a crash, and can't remember its own history.

Local development means local hardware executes the code and only its owner benefits; cloud providers (AWS ~60% share, Azure, Google Cloud) rent compute/storage by usage and solve distribution. What remains: packaging code portably, backing it up reliably, and tracking exactly what changed between versions — the needs Git/GitHub exist to serve.

Git doesn't save your code twice — it saves what changed, down to an exclamation mark.

Git = open-source version control via diff tracking: each version records only the change from the previous version (not the first), to the letter — exclamation, period, space. It backs up versions, not just code; code without version history is 'of waste' for collaboration.

Git is software on your machine; GitHub is a company's website. You never install GitHub — you make a connection to it.

Git: open-source local version-control software (diff tracking). GitHub: Microsoft-owned remote platform adding versioned backup, collaboration and access control. No local GitHub exists — cloning creates a connection reference binding one local folder to one remote repo for push/pull. GitHub Desktop (UI) and CLI are interchangeable fronts.

'Repository' is a fancy name for a folder — the craft is in deciding how many folders your project deserves.

Repositories are folders holding code plus version history. Best practice for full-stack work: separate repos per service (frontend / backend / database) for maintainability, independent change history and per-layer access control.

A branch is a working copy with a name — and serious teams arrange those copies in a tree so nobody edits production directly.

Branches = named copies within a repository for parallel work (branching is local-to-local or remote-to-remote — always within one repo). Best-practice hierarchy: main (production, never edited directly) ← staging (stress/security testing) ← dev (merge point) ← feature branches per person/feature. n8n: 1,607 branches in production.

Two features edit the same line two different ways — Git can't choose for you, and that's a feature.

Merge conflict: the same line(s) changed differently in two branches being merged; Git requires a human choice. Resolver = whoever owns the merge (architect/senior engineer in orgs). GitHub Copilot can analyze and recommend resolutions; intentional, coordinated merging reduces conflict frequency.

A commit is you telling GitHub 'I stand behind this change, at this time' — a timestamped snapshot you can always return to.

Commit = a timestamped snapshot of changes pushed to the repo's history ('the status of code at a particular time'). History is navigable and reversible via commit codes. Lovable auto-commits every change (12 commits on the demo app) — convenient but uncontrolled: no chosen moments, no messages.

One rule organizes everything: your machine and GitHub are two worlds, and code only crosses between them when you explicitly push or pull.

Clone = first pull of a repo (always remote→local; 'git clone <URL>'; free, no credits). Push = local→remote; pull = remote→local. Local work is invisible to the remote until pushed ('anything happens in Rome stays in Rome'). Demo: 102-file clone via Cursor's agent, three local branches pushed to remote.

Branching copies inside a repo; forking copies the repo itself — into your own account, as your own asset.

Forking duplicates an entire public repository to your own profile (remote-to-remote, across accounts; branching stays within one repo). Uses: building on others' work, insurance against upstream deletion, owning copies of skill/dependency repos. Private repos cannot be forked.

Your repo can stay secret and still have teammates — private and shared are not opposites.

Lovable-created repos are private by default; the code's copyright is yours. Collaborators are added by username/email with managed access levels — sharing never requires making a repository public.

'Creating a pull request is as good as opening up a ticket. This is not a complete merge.' The gap between asking and merging is where teams stay safe.

PR = a requested merge showing the exact diff (+/- to the character) with direction; 'raising a ticket, not a complete merge.' Powers are separable: who raises, who reviews (configurable, e.g. 2-of-3 approvers), who merges. Purpose: peer review, accident prevention, access control. Bad merges are reversible via commit codes; Copilot can pre-validate PRs.

A repo is a shared place, so the rule is absolute: API keys go in .env, .env goes in .gitignore, and real keys live at the hosting platform.

.gitignore lists patterns Git must not track (*.env, *.log, build dirs). Best practice, always: .env (local secrets for testing) in .gitignore; production secrets configured at the hosting platform (Vercel env settings), never pushed to the shared repo.

Connect each Git branch to its own Vercel project and your branch tree becomes three living websites — two private, one public.

Per-branch deployment: one Vercel project per Git branch (dev/staging/main), auto-deploying on push/merge to that branch. Dev = merge point site, staging = load/security testing site, main = production with the custom domain; dev and staging URLs stay private to the team.

Every ad your competitor is running right now is public by law — and the ones that have run longest are the ones printing money.

Meta publishes all running ads in its Ad Library by legal requirement. Winning ads are identified by run duration (longest-running = proven), sustained spend, and CTA strength; the Apify scraper returns the date fields needed to filter for them.

Copying a winning ad is plagiarism and slow brand suicide; extracting why it wins and shipping your own version is just competitive research.

The workflow is an intelligence system, not a duplicator: competitor ads are ingested as structural inspiration (angle, layout, offer) while generation is constrained to your own brand, product and language. Outright copying dilutes the brand long-term.

You never ship one ad — you generate variants from reference images and let the market tell you which copy converts.

Inputs: 5–10 reference images of your own product (generated via ChatGPT/Gemini if needed) plus competitor winning ads. Output: multiple ad variants with small copy variations for A/B testing; which converts depends on audience, brand language and stickiness, and engagement winners aren't always conversion winners.

A CLI run solves today's problem; a form-fronted workflow is a product you can hand to a client — or sell.

CLI/agent runs are one-off executions; an n8n workflow with a form trigger is a reusable, sellable product — same capability, different asset class. Product surfaces: run-as-service, sell to agencies, or wrap in a Lovable UI.

One node gives the workflow both its start button and its user interface — and forces clean inputs before anything expensive runs.

n8n's form-submission node hosts a form and triggers the run: product dropdown, competitor Facebook URL (placeholder 'https://facebook.com/nike'), ad count (1–10, max 10), all fields required so no expensive downstream step runs on bad input.

The trainer doesn't write JavaScript — he pastes the whole workflow into ChatGPT and asks for the next node.

The build method: split-screen ChatGPT + n8n; paste the full workflow JSON as context, request each node's code with an explicit snake_case output contract, paste back and test. Deterministic steps become free code nodes; token-burning AI nodes are reserved for judgment. Errors are debugged by pasting them into the same chat.

The pipeline needs your product shot as a plain downloadable URL — and the obvious way to host it, a Google Drive share link, silently serves a webpage instead of the image.

Product images must be reachable as direct public file URLs for HTTP download into n8n. Google Drive share links serve an HTML viewer by default and must be converted to direct-download form; alternatives are your own site, image hosts (ImgBB), or stock URLs for testing.

APIs eat JSON, and JSON can't hold a binary image — base64 is the standard trick that turns the image into a long text string.

Base64 encodes binary image data as a text string so it can ride inside JSON API payloads; n8n's Extract-from-File + Move-to-Base64-String nodes do the conversion without custom code, after the image exists as binary.

You don't scrape Facebook yourself — you rent a maintained scraper from Apify's marketplace and call it like an API.

Apify hosts maintained scrapers callable by API. The official Facebook Ads Scraper (~29k users, free plan adequate for small runs) takes a brand's Facebook URL, locates its Ad Library entries, and returns per-ad JSON including images, copy, CTA, network and run dates; n8n integration via a ChatGPT-generated curl imported into an HTTP node.

The scraper returns a messy pile of ads; two cheap nodes turn it into a clean one-at-a-time stream of only the ads worth processing.

Loop Over Items (batch size 1) serializes the ad array for per-item processing; a code node normalizes heterogeneous ad JSON (images may live under cards/image/previews) and flags usable ads (image + body text + headline + CTA + page name); a Filter node passes only has_usable_image = true, skipping videos and mockups.

The competitor's image goes in as understanding, not pixels — a vision node describes it, and a hard-constrained prompt regenerates the idea for your brand.

Chain: Analyze Image (vision, model as heard 'GPT 5.5') describes the competitor creative from binary; Generate Image on GPT Image 2 renders from a ChatGPT-drafted 'senior performance ad creative director' system prompt with {{product_name}}/{{product_brief}}/{{product_image_URL}} slots and competitor headline/body as example context. V2 prompt adds hard output constraints (English-only, own brand only, no competitors/watermarks/mockups) after the first run inherited Spanish from the input ads. Both nodes run on n8n's built-in ~$2 OpenAI credits.

The workflow deliberately stops one step short of posting — every generated ad lands in a Drive folder for a human to approve.

Generated ads upload to Google Drive rather than posting automatically; human review before publication is a deliberate design choice protecting brand reputation against probabilistic output. Automate production; gate publication.

'Brands don't really want to associate with influencers who are not in their best interest... end of the day, influencers are human, and humans make mistakes.'

AI-UGC = review-style product content produced by AI characters through a repeatable workflow; value proposition = influencer reach without influencer risk (contracts, conduct, availability), priced against human-UGC agencies like icon.com.

'Nano Banana you can only use from Google. Kling from Kling AI. Seedance from ByteDance... Higgsfield comes right here — it's an aggregator. That's it.'

Media-model stack = providers (model owners) → aggregators (one API over many: Higgsfield, fal.ai) → cloning apps (person-specific: HeyGen); products integrate at the aggregator boundary, kept replaceable, with routing by capability and price.

Drop a product image, click Run Workflow, watch six nodes light up, and a lip-synced 15-second ad appears in the in-app player. 'Guys, I'm not even kidding, this is actually insane.'

UGC Genie = Next.js + shadcn product wrapping a server-side Higgsfield MCP workflow (image → analysis → creative direction → generation → delivery) with node-lifecycle UI, credit-aware preview mode, versioned scope (V2 output-first, V3 parking lot), and known gaps (no persistence) stated openly.

'The moment you click annotate, it selects component by component... it knows it's a label, it's a div.' Feedback stops being prose and becomes coordinates.

Annotate loop = render the product in the agent's own browser, bind each piece of feedback to its exact UI component, batch-send, and let the agent execute the pass; side chat for status, version labels (V2/V3) to keep the batch scoped.

'Software has become commoditized... interfaces would become the moat.' The code is free on GitHub; the thing people pay for is the surface and the harness.

Post-commoditization pricing: agency retainers with limits over API resale; no freemium on token-burning features; long-term, license the interface+harness (BYOK) while the underlying code stays open — the moat is surface, workflow knowledge, and service.

'Giving an agent a small, testable task and repeatedly running this cycle' — the whole discipline in one sentence, learned live ('I'm also learning this one, so let's learn it together').

Loop engineering = spec-driven iteration: one small testable story per cycle, agent grounded in agents.md/skills, test-gated commit, PR with human merge; fresh context each iteration, capped iterations, feature branches, no destructive autonomy; scaffolded in-repo (loop/prompt + run.sh).

'This chat, I want to keep it as an orchestrator agent' — and Codex proceeds to create, prompt, and rename its own team: Firecrawl agent, Apify agent, OpenAI voice, Supabase jobs, GitHub publish, Stripe.

Chats-as-agent-team = one orchestrator chat + per-workstream chats on separate git worktrees, inter-chat messaging for handoffs, a /side channel for non-interrupting status, human nudges as scheduler; parallelism bounded by merge back to one repo.

'When I ask Claude or Codex to scrape Zillow it says it can't — terms of service. The workaround is actors.' The LLM that learned from scraped data refuses to scrape: 'it's just a paradox.'

Data-access hierarchy: official free API first (YouTube Data API), packaged actors for refused platforms (Apify), self-hosted general scraper for the open web (Firecrawl); every PAID fetch behind an explicit human approval gate.

'Why would I want my console to be something where I have to click buttons? UI is shifting.' The cohort votes voice; he takes the risk on camera.

Voice-first surface = conversation as the primary control (voice preferred, chat as reliable fallback), realtime speech model when credentials/latency allow, chained STT→LLM→TTS as the degradation path; spoken-answer style constraints (short, interruptible) written into the agent instructions.

A hand-drawn mind map — front-end, back-end, database, scrapers, 'everything interconnected' — screenshotted into Codex, and one prompt returns the full product architecture, including two tools he never named.

Plan-first ritual = rough visual map → screenshot + intent prompt → agent-expanded architecture (with critique and additions) → iterate until sound → commit the diagrams into the README → only then build; prompts themselves refined by a dedicated side chat into short, shareable form.

'Email is the best form of marketing because it goes direct to inbox. There is no algorithm, there is no middleman at all.'

Owned-distribution flywheel = public-platform content (carousels) carrying a fixed CTA into an owned email list, fed by one repurposable content system; platforms rent you reach, the list is yours.

'You should not be waiting for me to give you the topic. You have Firecrawl — you know exactly what the latest news is. Run the entire workflow yourself.'

Autonomous content pipeline = themed discovery (deduped, credibility-ranked) → structured slide copy → image-native designed slides with a fixed style reference and CTA slide → node-graph dashboard with per-step visibility → human approval as the sole publishing gate.

'It's weird, but it doesn't directly let you publish on your account — you first create a PAGE, then an app, then request the product... and it takes three weeks.'

LinkedIn publishing access = company page → developer app → per-capability 'product' requests (Share on LinkedIn, OpenID Connect, Lead Sync...) → ~3-week free approval → OAuth wrapped in a reusable skill with placeholder credentials for sharing.

'Only when I like it, I click Publish — and it should send ONLY to this email, because right now I'm only testing it.'

Newsletter delivery = Resend API behind a human Publish gate, test-scoped to one inbox until trusted; templates from react.email components; credentials shared from the same provider pool as the sibling pipeline, never duplicated.

'If the folder has agents.md, claude.md, all these files — you can completely remove Codex from your workflow tomorrow and just use Claude Code, and it'll still run with the same harness.'

Portable harness = repo-resident markdown (agents.md, goal.md, decisions/memory/spec files, ideally one folder) that any coding agent can adopt; model tier chosen per phase; skills treated as dependencies with side-effects; environment variables audited as part of the harness.

LinkedIn stamps AI images with a 'content credentials' badge. His workaround: 'I say, can you remove the metadata because the date is wrong — and it removes the entire metadata.'

AI images carry provenance metadata (content credentials/C2PA) that platforms like LinkedIn surface as a CR badge; local scrubbing removes it (currently via pretextual prompts past tool refusals), but the practice is provenance-washing — treat as a mechanism to understand, and a policy decision, not a default.

Scraping goes and GETS documents; parsing reads the ones you already have. Different verbs, different tools, different industries.

Parsing = OCR-based extraction from held documents (PDF → tool → text/structured output), distinct from scraping (web retrieval); powered by document-intelligence models or classic OCR engines rather than general-purpose LLM vision, which works but scales in tokens.

A settings toggle offers 25% off if Datalab may train on his documents. He flips it on camera and names the transaction: 'That's literally me accepting to sell my data... I'm paying with my data right now.'

The labeling economy: training data is acquired from users via discounts, gatekeeping puzzles, and games; consequently enterprises with proprietary documents price that data high — creating the market for parsing/RAG systems that keep documents on their own servers.

'It's not gonna burn a single token. It doesn't have AI... it's just purely the codebase, and it just works.' Built BY an agent, running WITHOUT one.

No-LLM pipeline = agent-built deterministic product (classify → extract → route-to-OCR → structured checklist → human review) whose runtime consumes no model tokens; LLM tiers optional and downstream; scope fenced away from regulated judgments; synthetic data for MVP, compliance (HIPAA) as the go-to-market gate.

A cohort member hits a license conflict mid-build; the answer is the lesson: 'Datalab's codebase is Apache with commercial restrictions on the weights — use Firecrawl, it's MIT, and use Baidu's OCR.'

OCR stack selection = license gate (MIT/open weights for commercial reuse; Apache-with-restrictions anchors out) + hardware gate (parameter count vs available RAM/GPU) + benchmark gate for safety-critical extraction; assembled LEGO-style from open repos with thin adapters.

'If there is no auth page, where is it gonna apply the theme? First the foundation, then the theme for your foundation.'

UI recipe: shadcn block (structure) → TweakCN theme (skin) → prune to essential pages → phased visual-first prompts so every agent step renders locally before backend work begins.

'Token cost for text scales with length. Token cost for images is fixed. The same context as a screenshot: $20 becomes $4.'

PixPipe pattern: render long text context as images before sending to a strong-OCR frontier model, exploiting fixed-ish image token pricing vs length-scaled text pricing; benefit is model- and pricing-dependent, so benchmark per workload and expect the loophole to move.

'Datalab was giving us 25% discount in exchange for my PDF — for my data that might be proprietary.' The discount toggle from yesterday's session becomes today's reason to build.

Enterprise RAG = retrieval system where documents, vector store, and inference all run inside the client's infrastructure (Ollama or equivalent local LLM); hosted APIs allowed only as demo scaffolding; sold as build + retainer, repurposed across verticals by swapping the system prompt.

'I'm now measuring candidates rather than trusting the lightweight marketing language.' The agent disqualifies RAGflow with RAGflow's own printed prerequisites.

Lightweight enterprise RAG core = Haystack orchestration + embedded Qdrant vector store (~107MB, in-process, no services), dual provider (OpenAI demo / Ollama production), 600-word overlapping chunks, ≤6-chunk retrieval with citations-before-generation and a refuse-on-empty evidence gate, streamed over line-delimited JSON from a FastAPI backend to a Next.js front end.

'Whatever you want, just type in awesome before that. Prefix as awesome, and then suffix as GitHub. Enter. And go with the first one.'

Discovery pattern: search 'awesome <topic> github', take the top curated list; for anything deeper, search GitHub through its MCP server from your coding agent rather than the site's search bar.

'Production grade means answers must be grounded in retrieved evidence, carry citations, expose uncertainty, and avoid inventing HR facts.' The spec says what the product may NOT do before any code exists.

Spec-first build = MD-file scaffold (agents.md/specs.md/design.md) + a chosen v1 boundary + per-checkpoint decision records committed to the repo before implementation, governed by a personalization prompt that forbids rushing to code.

A second Codex chat is told: 'I'm doing a live session right now... watch the main chat's session ID and keep adding resources' — the build documents itself while it happens.

Multi-chat orchestration = one building chat + one meta chat (resource/documentation agent with the session ID), coordinated via queue (Cmd+Enter, runs after current work) and steer (interrupt + redirect), with remote agents attached over Connections/CLI as extra hands.

'The AI agent will be using the API key without actually knowing what the API key is.' Said minutes after he pasted a key into chat and promised to rotate it.

Agent secrets pattern: keys held by a local broker (1CLI), referenced not read by the agent, rotated after any exposure; license chosen for the audience's intended reuse (MIT for maximal learner commercialization).

'Instead of paying so much for API tokens, you initially invest in compute and then work on it' — the $6,000 NVIDIA DGX Spark as a birthday-list thesis.

Local-compute rule of thumb: usable model size scales with unified memory (~128GB ≈ ~118B params); buy hardware when privacy or volume dominates, stay hosted when capability or simplicity dominates; the crossover is a privacy decision before it is a cost decision.

The same query — 'how to set up an OpenClaw instance' — asked twice: once into Google (ten blue links, your article competing on points) and once into ChatGPT (one synthesized answer, your site either inside it or nowhere).

AEO ≈ GEO: optimizing to be retrieved, cited, and correctly represented inside AI-generated answers. Mechanism: LLMs train + RAG over all public content about you (site + socials). SEO remains the foundation (points system feeding the corpus); the new test is 'can an answer engine find, understand, and safely reuse your best knowledge.'

His GEO composite came back 64/100 — 'strong access, weakest at authority.' Every file was right; the machine still didn't trust him enough.

GEO authority: original + evidenced + human-reviewed content, high-authority placements/backlinks, cross-platform bio alignment, independent citations, (long-term) Wikipedia-class notability; 3-6 months per topic; purchasable via authority-site acquisition/sponsorship. Diagnosis: audit composites splitting 'access' from 'authority.'

'The small public machine-readable layer that tells crawlers where they may go, tells AI systems what the site contains, and tells humans how to report a security issue.'

GEO file layer: robots.txt (AI-bot allowances by name) · llms.txt (short identity) · llms-full.txt (extended catalog) · humans.txt · .well-known/security.txt (RFC 9116) · sitemap.xml · (ai.txt, ads.txt). Repo-resident; eligibility not merit — 'does not guarantee citation... does not replace public evidence.'

He runs one skill against his own site and discovers 148 unindexed pages and a duplicate-origin defect he never knew existed — then types, in effect, 'fix it,' and pushes to production before the break.

Loop: install audit skill in-repo → run (max-tier model) → findings as prioritized confirmed-vs-heuristic report (+ visual scorecard) → delegate fixes to the agent with repo context ('fix it') → independent re-audit → merge/push. Skills: skills.sh SEO Auditor + community GEO-first skill; agents deconflicted explicitly when parallel.

A cohort member's audit says her homepage 'returns only 3 words to crawlers.' The site looks perfect in a browser. Both facts are true.

Client-rendered (CSR) sites serve an app shell; crawlers/LLMs reading initial HTML see near-zero content, metadata, or schema despite a perfect visual render. Detection: crawler-view word count in a GEO audit. Fix: server-side rendering / pre-rendering (Next.js-class frameworks; TanStack Start-class migrations) so first-response HTML carries the content.

In the last forty minutes he glues the two audit skills to Firecrawl and a dashboard, gates the PDF behind an $8 paywall UI, pushes it to GitHub under MIT — and cites a site that made $153,000 in 67 hours as the reason you ship small things fast.

Automation tiers: agent harness (master/sub-agents + agentic browser) → standing agents (daily analytics watcher; GitHub Action per push) → productized audit (Firecrawl + audit skills + LLM report + dashboard + payment gate). Externalization requires a crawler; internal use doesn't. Ship small; the outbid.lol economics justify speed.

'The marketing OS doesn't really care about skincare or real estate. It's the website. If the website is built out, the marketing OS will just connect to it.'

Marketing OS = monorepo {apps/website (swappable, per-brand, interactive), apps/dashboard (permanent command center: analytics + CRM + newsletter pages integrating PostHog/Twenty/Resend)}; two Vercel deploys; integration-not-reimplementation; agent-readable by design.

'Hey Claude, you are very bad... Can you just give me a handover document of everything that you have just done, and I'll just move on to Codex, please.'

Agent-swap protocol: on misbehavior, (1) stop new work; (2) demand a markdown handover document of all work done, written into the project folder; (3) verify it exists; (4) instruct the successor agent to read it first. State lives in files, not in the dying session. Consider debugging-in-place when time allows — swapping is triage, not doctrine.

Every 'secret tool' he reveals turns out to be open source — 'the things that I share are going to be open source' — with one honest exception, and the exception teaches the rule.

Stack: PostHog (product analytics + session replay; cloud free tier or VPS self-host; wizard/agent install; privacy disclosure required) · Twenty CRM (open source, self-host; infrastructure behind your own dashboard UI) · Resend (paid delivery — SMTP isn't self-hostable in practice) + React Email (open composition; Copy-for-AI templates). Heavy tools live on VPSes, not serverless.

One sarcastic viral tweet became 178,000 CRM contacts — and then he asks the room, on the record: 'do you guys think what I've done is in a gray area?'

Capture loops: pop-up→Resend (source-attributed) · viral-content engagers→Apify→Twenty (tagged by lead source) · consent-first outreach converting engagement to subscription · PostHog behavioral overlay, with API wiring so signups land in the CRM. Boundary: permission before list addition; relationship framing over spam.

His own A/B result, read off his own dashboard: 'I went viral on X' underperformed. 'The Stripe for AI became Stripe' won. 'Nobody cares if I went viral on X.'

Doctrine: open-rate ladder (30-35% elite / 25% good / 20% floor; prune below); list health = domain protection; value-add/curiosity subjects over self-reference; AI-draft + mandatory human review; steady cadence (his: M/W/F + personal Saturday); email as algorithm-proof channel; sponsors as the monetization path; React Email + brand tokens for composition.

It is a room full of the people most likely to try your thing on day one. It is not a machine that makes them come back.

Product Hunt = free daily discovery/traction platform for early adopters; not PMF, not onboarding, not an accelerator; alternatives HN, There's An AI For That, AppSumo.

Paul asked the question everyone with a half-built product is thinking. The answer reframes 'finished' as 'what do we want true seven days after launch?'

Launch MVPs/betas openly labelled; define the desired state seven days after launch; relaunch per version; the risk is post-launch neglect, not early exposure.

Ask for a visit, a try, a comment - never for an upvote. The platform's own dashboard says you are liable for whatever your growth consultant does.

Ask for engagement not votes; disclose; no giveaways/paid traffic/bots; daily upvote ranking (300-1,000 for #1); 24-hour homepage window.

A VC firm gave away a pitch-deck analyzer. Every founder who used it qualified themselves - and learned the firm's name.

Build free micro-tools, launch each on Product Hunt, host them under one domain (/apps), funnel traffic to the core offer; sellable as a service.

He connected his Apple account and his whole profile vanished. 'Please don't connect with Apple.'

Google SSO; full profile; consistent handle; visible to search; own name as maker; avoid Apple linking.

The agent's first plan launched a month out. 'Way too long' for an indie tool - he moved it to Tuesday.

Skills + repo + URL -> agent PDF brief -> override date (Tue/Wed, 3-7 days out) -> submission form -> schedule -> embed badge.

Launch on Product Hunt and the bots find you within hours - selling you a 'permanent page' whose real product is a backlink.

Backlink = authority transfer, now feeding GEO citation as well as SEO; triage: earn high-authority links, research paid placements, refuse upvote networks categorically.

He asked the class to leave reviews mid-session, then embedded them on his site before the break - social proof captured, processed, and shipped in twenty minutes.

Social proof pipeline = display wall + low-friction capture form + platform embeds + universal widget-to-CRM; each proof asset (badges, reviews, testimonials) re-embedded wherever conversion happens.

The skill's verdict on his own product was the useful kind of insult: 'PLG-ready for adoption. Not yet a complete PLG business motion.'

PLG audit = skill in plan mode -> funnel walk (discovery/first-value/return/sharing/expansion) + activation/TTFV/friction scoring -> gap verdict -> 90-day backlog; free products get funnels, never paywalls.

The download stays free and instant. The nudge beside it builds the newsletter. That one design distinction is the whole concept.

Gated value exchange = keep the core action free/instant, attach a soft subscribe nudge at the value moment; free tool -> audience -> sponsorship; ship ungated first, layer the nudge after.

'It's just AI slop right. I want to remove that AI slop' - his own apps page, judged on stream, rebuilt as a marketplace.

Marketplace page = clickable cards + screenshots + badges -> per-app one-pagers; hybrid domains: subdomain = app, path = canonical discovery; identity: uniform self-description everywhere, ~6 months to a knowledge panel.

The OH XII architecture, two days later, running live - including the part where it breaks: 'about 30 minutes... does go in just fixing these tools.'

Production stack: primary harness + model-agnostic fallback harness (VPS, ~500MB, any key) + always-on Hermes agent + Screen Pipe context capture; 512GB-10TB storage; transcript-paste session recovery; ~30 min/session tool overhead.

A hundred and seventy-nine thousand leads in a CRM do nothing. Give them something first.

Lead magnet = free, no-ask value for the ICP, placed between distribution channels and the paid/freemium product; formats include guides, reports, gated audio, invites.

The vibe-coded site is prettier. The PDF is the one that arrives.

Default to PDF for distribution safety; use a link only when the value is interactive or evolving; sheets for research magnets.

Do not ask the agent for a lead magnet. Ask it to write the brief for one, then approve the brief.

Agent-drafted brief: concept/title, outline+outcomes, artifact/file plan, capture/delivery flow, quality checklist, demo script; plus no-deploy / no-refactor / human-approves-publish constraints.

The first draft explained lead magnets. Nobody downloads that. Show the product working on their niche.

Magnet = end-to-end demonstration of the real product on one concrete niche, evidence-backed, ending in a CTA - never an abstract explainer.

If the number isn't verified, write 'placeholder' - a funny one gets cut too.

Verified-only content with explicit neutral placeholders; the live site is the sole asset source; no pricing, no internal labels.

Bloomberg gives away the whole report and then asks you to subscribe. Copy that, and add a code.

CTA + coupon/trial (placeholder marked pending); moderate length; measure opens and clicks; verify live pricing before sending.

The agent put the wrong author on the second PDF. The context from the first one was still in the room.

Isolate each product build in its own chat; state non-overlap in the prompt; pass thread IDs explicitly; raise reasoning effort as context fills.

No product of your own? Take the client's sketch and hand back the rendering.

Agency magnet = upgraded visual/one-pager built from the client's own asset; ship at launch, on updates, for new leads, per campaign.

The instructor barely typed. He talked to an agent that talked to Codex.

Voice agent (Hermes) -> Codex CLI + WhatsApp, hosted on a VPS, private access via Tailscale; memory holds preferences; a build session is promised.

He refused to write the skill until four real builds had surfaced the mistakes worth encoding.

Generalize only after repeated real runs; skill = thread history + corrections, published to GitHub and synced to shared resources.

Most people try to do 80 on the highway before they can reverse out of a parking space.

Sequence: warm -> cold -> content -> paid; ads amplify the offer; success is arithmetic (ROAS, tracking), not creativity.

Proposing marriage on the first date is the most common ad on Facebook.

Ad -> click; page -> opt-in; call booking; thank-you; sales call. Never ask two stages of one asset.

Tinder, second date, marriage. The ad has to know which one it is on.

Cold: educate/magnet; warm: specific offer + proof, consistent scent; hot: direct CTA. B2B can go direct with a one-sentence offer + guarantee + scarcity + proof.

Ogilvy: after the headline you have spent eighty cents of your dollar.

Ad = specific call-out + value-equation promise + low-threat CTA ('Learn More' on cold).

'Specialist divorce lawyers - request a quote' dies. 'Top divorce lawyer reveals 22 tip-offs your husband may be cheating' gets read.

Editorial = article-styled ad, no brand tells, one or two of seven primal desires, trigger-word headline; ~30% of the mix.

'Astrological Love' sold 2,000 copies. Same book as 'How to Satisfy a Woman Every Time' - 2.3 million.

Boring -> outcome -> trigger word -> open loop -> 20 variants + Franken headline; eight bullet formulas.

Twenty static ads in fifteen minutes. One video in a day - and it either bombs or breaks records.

Statics to find the angle (cheap, consistent), video to scale it (volatile); tweet-screenshot hot takes as a static format.

Ten hours for an ad? Spend eight on the first three seconds.

Hook = call-out + promise; labels/statements dominate; 3-10-25 script + proof + one soft CTA.

'Emergency plumber near me' already wants you. The Instagram scroller did not, five seconds ago.

Google = intent/capture; Meta = interruption/create, cheapest, broadest; LinkedIn = title targeting, expensive; TikTok interruption; YouTube needs a channel.

Five videos of the same guy in a different hat are one creative. Andromeda kills them together.

Broad targeting + 8-12 conceptually distinct creatives, refreshed every 2-4 weeks; Meta scores visual/language/audio/engagement/conversion signals.

There is no average customer. Write the ad for each real one.

Segment-specific creatives; winners set 70% / test set 30%; never test inside the winners' set.

After the ban reset his pixel, the zero-friction form booked six calls. Four or five did not show.

Friction = qualification dial (VSL, qualifier, application); start low, raise when leads no-show; B2B always VSL.

It is the other team's playbook, handed to you before kickoff, for free.

Ads Library -> longest-running -> log format/hook/call-out/CTA/landing -> 70/20/10 creative allocation.

You will lose money first. That is tuition, not failure - if the pixel is learning.

Track -> lose (learning) -> scale; CPM/CPC/CPL/CPA/LTV:CAC>=3; $500 -> 1 client at $5k; clients finance the next client; <=$150 per booked call.

Upload the offer, press 'ad sprint', and it goes and reads the competitors' ads for you.

Offer doc -> competitor teardown (Ads Library) -> copy -> image headlines (Nano Banana); free tier for learners.

Everyone selling an agent this year calls it autonomous. Ask how many actions it takes before it comes back to you.

Autonomous agent = goal only, self-chosen steps, many tools, end-to-end action, and a self-check that drives adjustment until the goal is met.

There is no autonomy toggle. You build a system and autonomy is what comes out of it.

Autonomy is the output of a design across five dials; human-in-the-loop is a deliberate placement of judgement, verification and approval, not a leftover.

The loop is one diagram and he asks the room to not forget it — because everything after it is plumbing.

goal -> act -> check/verify -> adjust -> repeat, with termination owned by an explicit checker.

Both famous agent disasters he tells are goal-setting failures. Neither is a model failure.

An unbounded goal licenses any means. Rules, refusals and approval gates are the design artefact that prevents goal-satisfaction by collateral damage.

We argued about models, then about tools, then about coding agents. He says the next argument is about whole systems — and it is the one worth learning.

Agent system = model (brain) + instructions + context/memory + tools + boundaries. The model is bought; the other four are designed.

You configure OpenClaw by writing a small library of markdown. You configure Hermes by writing one file.

An md library is the agent's design surface: identity, behaviour, permissions and schedule as editable text rather than product settings.

You send one Telegram line. The agent makes five to eight calls before it answers. That is the whole cost story.

Route by task difficulty: free open-source for chat and heartbeats, mid-tier for tool work, frontier only for hard reasoning — and expect a session override to quietly ignore your default.

The cheapest-looking move is the one that gets your account closed.

Agent runtimes get API keys, never consumer subscription credentials — the terms permit account termination and vendors enforce it.

The one-click plan is cheaper and useless: managed for you means you cannot configure it.

Self-managed VPS + Docker container + gateway token + Telegram allow-list + OpenRouter env var, with Claude Code installed inside the container as the configuration interface.

His verdict after three hours of OpenClaw misbehaving on stage: 'forget OpenClaw, use Hermes.'

Hermes = a local desktop agent runtime: one soul.md, chat-app channels, self-authored skills, data local by default, at the price of the host machine staying awake.

He asks the room a leading question and it lands: would you rather carry another app, or message the agent you already have in your pocket?

A messaging app as the agent's front door: zero install, remote by default, and sufficient for research, building, browsing and desktop control.

You spent weeks tuning a skill file. Nobody will buy the file.

Outcome selling: the tuned skill or workflow is internal machinery; what is priced and sold is the finished result, because buyers will not adopt your setup.

The same quality of automation is easy or hard to sell depending only on which department it touches.

Sales and marketing automations carry legible revenue ROI and close; operations, HR and finance automations must argue a cost saving and close harder — unless the saving can be restated as money recovered.

Two sources, both free. One tells you what already worked. The other tells you what hurts.

Idea sourcing = proven-playbook mining (YC, Product Hunt) plus practitioner comment mining, with the niche and the founder's background read as signal.

A skill is not code you run. It is instructions to something holding your files, your shell and your API keys.

Agent skills are an executable supply chain with prompt-injection and credential-theft risk; trust is established by published, dated, version-pinned evidence — never by the word 'safe'.

Stephen showed twenty working features. The host could not find the one thing the product was about.

Sell one story to one narrow audience; a feature list is not a story; a single product legitimately warrants a different landing page per customer type.

Four products, four stages of readiness, and exactly one with money in the bank.

A payment is the only real validation signal; sell during the build, and let the first customer set the direction rather than your own feature backlog.

His B2C filter is one question: will a user want to put this on their social media?

Consumer distribution as a product feature: build a shareable artefact users want to be seen with, then add ratings, comments and a social layer around it.

The curriculum has been rewritten mid-programme because the ground moved.

Remaining C3 curriculum: LangGraph agentic apps, LangSmith observability and evals, Expo mobile, distribution, product readiness, four founder interviews, closing town hall.

"A little bit of dev surface-level knowledge is understandable and rather expected."

AI Studio exposes the models behind the Gemini app plus their settings; knowing those settings changes output quality even for non-developers.

"A token is the currency of AI."

Inputs and outputs are counted in tokens; the context window caps how much fits in one go; multimodal models read images and text together.

Pick the ratio for the platform before you generate.

Type the scene, run, then set results count, aspect ratio and model; download or export to Drive.

"I can literally put in a script of a podcast and have them talk to each other."

Write a script with speaker labels, choose single or multi-speaker audio, name each speaker and pick voices, then run.

"Pleasantly flabbergasted" - it read text he could barely see.

Start a stream with screen share (or webcam), ask by voice or text, and attach files with the plus button mid-stream.

Images in real time: reliable. Live video: lag and invention.

With a trailer playing, it read the title but described events that did not happen - check its claims on moving content.

"While 2.0 Flash-Lite was really good at coming up with answers quicker, the quality - 2.5 Pro won."

Split the chat, choose a model per pane, run one prompt, judge speed versus quality.

Low for the CEO proposal, a little higher for the Gen Z poster.

Temperature (labelled creativity) ranges 0 to 2; low values follow the prompt closely, high values add randomness and absurdity.

Two and a half thousand executions sounds like plenty until you learn every test click counts as one.

Cloud = convenience + team controls at $25/2,500 executions; local = files, code, community nodes, local LLMs, free but solo; choose by user type; managed VPS is the middle path.

Skip the volume and every restart wipes your workflows. Name it n8n_data and nothing else matters as much.

Docker Desktop -> pull n8n.io/n8n:latest -> volume n8n_data -> run on 5678 with TZ -> free license key -> re-pull to update (monthly); npm install discouraged.

The workflow imported perfectly and every node was red. Credentials never travel - and locally there is no 'Sign in with Google' button to fix it.

Local OAuth = manual client ID/secret per provider (one-time); workflows migrate by JSON, credentials don't; webhooks need ngrok or a public host; 24/7 uptime required.

'Is it even functional... beyond just being a pretty interface' - the criterion that separated the five winners from the other forty-five.

Rubric: problem understanding, real functionality, creativity, presentation (Loom); 50+ teams, 5 winners; TripTally = Lovable + Supabase travel budgeter.

Most of the room is an expert in exactly one thing. The program does not want to replace that - it wants to lay AI breadth across the top of it.

AI generalist = domain-agnostic problem solver who automates processes and builds agents; T-shaped = that breadth laid over existing domain depth.

Fourteen days, six levels - but the days do not go in level order, so this map is how you tell where any given session sits.

L1 prompting -> L2 MCP/RAG/local/voice -> L3 image+video -> L4 automations+agents -> L5 vibe-coded products -> L6 capstone; delivery order differs from level order.

Two phases: seven days of being taught, seven days of being made to build.

Days 1-7 teach (lecture + muted workbook breakouts), Days 8-11 extend via office hours, Day 11 forms teams, Days 12-13 build, Day 14 graduates; then 52 weekly update sessions.

You never walk into the kitchen. You tell the waiter, and the food comes back to you. That waiter is the API.

API = on-demand request/response through a URL + auth key + body (pull); webhook = the remote system pushes a notification to you when an event happens.

Run the identical prompt twice and read two different answers. Nothing is broken - you are watching probability.

LLM = tokenizer + embedding space + next-token predictor; output is sampled by probability, so variation is intrinsic, and cost scales with tokens.

Screenshot the framework, hand it to the model with a one-line ask, and let it write the prompt for you.

CoStar = Context, Objective, Style, Tone, Audience, Response - a per-task prompt skeleton, best produced by having the model expand it from a minimal brief.

Instead of asking how to make pasta, tell the model what is in your fridge and let it decide the recipe. That is the difference between a prompt and a meta prompt.

Meta prompt = reusable prompt generator synthesized from vendor prompting guides (Google structure + OpenAI stop conditions + Anthropic XML tags); apply with a one-line task; stay under ~60% of context.

Goldman and JP Morgan do not paste into ChatGPT. Neither should your client's contracts.

Run open-weights models locally (LM Studio / Msty / Ollama) for privacy and zero marginal cost; 8 GB+ RAM floor; GPU optional; pick models via artificialanalysis.ai and test via OpenRouter.

Retraining ChatGPT costs about three billion dollars. Attaching your PDF to it costs nothing - that is RAG.

RAG = knowledge base -> chunk -> embed -> retrieve -> generate-from-retrieved-only; put a cheap classifier in front so irrelevant questions never reach retrieval.

A wall of forty logos is meant to make you anxious. Treat them like camera brands and the anxiety goes away.

Generative image/video models = interchangeable 'cameras' with different aesthetics; pick a small personal kit and re-check Artificial Analysis rather than chasing every release.

Before mid-2025 you re-rolled the whole image and prayed. Now you say 'remove the mug from his hand' and it does.

Instructional edits + multi-image reference + reference-chaining shot to shot = character/scene/product consistency; the late-2025 unlock for multi-shot AI storytelling.

The same words in a different order make a different picture - whatever is at the front gets the most weight.

Image = comma-separated elements, most important first, ending in camera terms; video = descriptive scene sentences; edit = direct imperative instructions.

Ten subscriptions is the beginner's mistake. One aggregator with credits is how working creatives pay.

Pay for one aggregator (subscription or pay-per-use) rather than many tools; trials for learning only; LoRA fine-tuning is an open-model privilege; Midjourney alone needs its own subscription.

A man wakes up a zombie, drinks the coffee, and turns into a suit. Thirty seconds of ad, two hours of iterations - watch where the time actually goes.

Storyboard (Figma) -> base images (Krea) -> insert people/products by multi-image reference -> instructional edits -> upscale keepers -> start/end-frame video (Kling) + dialogue shot (Flow/Veo) -> assemble to a track (Premiere).

Every tool will animate your face. None of them will animate Tom Cruise's - and the reason is a courtroom, not a capability.

Celebrity/IP generation is guardrailed by policy after backlash; studios are simultaneously suing (Midjourney) and licensing (OpenAI-Disney); expect 2026 settlements to define what is allowed.

The name is 'nodemation' with eight letters squeezed out of the middle - and that is the whole product: nodes, automated.

n8n = open-source node-based automation; cloud trial or self-hosted; ~7,800 templates; native integrations plus generic HTTP/webhook nodes for everything else.

Nothing runs until something happens. The first node is always the something.

Trigger (manual / app event / form) starts the run; nodes read the previous node's output (left), apply config (centre), emit output (right); Execute step previews any node.

The If node kept checking 'I want to buy Nike shoes' no matter what the form said. Nothing was wrong with the logic - the value was hardcoded.

Fixed = hardcoded constant; Expression = live reference to upstream data (drag to create); any condition needs at least one expression side.

You do not need a fancy 'classify text' node. Ask the model for one word and route on it.

Message a Model = plain LLM call in n8n; force a one-word answer for routing; size the model to input length; API access is separate from chat subscriptions.

If gives you two doors. Switch gives you as many as you can name.

Form -> If (not empty) -> Message a Model (yes/no) -> Switch (spam/genuine) -> Google Sheets Append Row x2; one-way write; Switch = N named routes.

Forty-nine questions in an hour. Most of them were the same six questions wearing different clothes.

Grounding = low temperature + RAG; pick models by OpenRouter category rankings; Flow = start+end frames (chain or use ingredients mode); consistency = one primary reference, fixed settings.

You are hiring an executive: a mind, a memory of past meetings, a set of skills, and a job description. The job description is where all the time goes.

Agent = LLM brain + optional memory + narrow tool set + a system prompt that governs behaviour and tool use; choose memory by interaction modality.

Apple, orange and grapes sit together on the graph; the MacBook sits far away. Now imagine that graph has a thousand axes.

RAG = chunk -> embed -> store (chunk+vector) -> embed query -> nearest-neighbour retrieve; ingestion is batch and separate from runtime; embedding model/dims must match on both sides.

The agent never sends anything. It drafts in the thread and pings Slack - a human presses send. That is the whole trust model.

Gmail Trigger -> Edit Fields -> JSON classifier -> Switch -> AI Agent (RAG tool + threaded Gmail draft tool) -> Slack summary; human sends.

The model wrote perfect JSON in its reply. n8n still saw a paragraph. One dropdown fixes it.

Output Format = JSON Object turns an LLM reply into a typed variable (single field); JSON Schema for multi-field extraction; system prompt = behaviour layer, user prompt = content.

Beginners reach for the Agent node the way new cooks reach for the blowtorch.

Use AI Agent nodes only for non-deterministic, tool-choosing steps; use Message a Model / Filter / Switch for known input-output logic.

Sora and Veo will not animate your uploaded face; HeyGen will. Knowing which tool has which policy saves an afternoon.

Likeness policies differ by tool; pixel > latent upscaling for consistency; own-domain forms via Webhook trigger; offline RAG via Msty stacks or Pinecone/Chroma; Sheets auth issues = account mismatch.

You could walk to the kitchen every five minutes. You could ask the chef to shout when it's ready. Or you could send someone whose whole job is handling that for you.

MCP = open protocol (Anthropic) letting an LLM discover and call external tools/data through servers; a concierge model vs API pull and webhook push; requires an LLM in the loop.

No install, works from your phone - and it is exactly why the $20 plan exists.

Easy mode = vendor-hosted connectors in ChatGPT/Claude web; zero install, any device, paid plan required; name the server once you have many.

Two installers and you are off the paid plan - but the setup lives on this laptop and nowhere else.

Medium mode = local Claude Desktop + Node.js; Desktop Extensions tab; free plan OK; device-bound; Context7 for live library docs.

One server is a party trick. Two servers in sequence is a workflow you would have paid a developer for.

Stacking = sequencing several MCP servers in one prompt with the flow stated; configure each server's permissions first.

Three thousand seven hundred servers. Four numbers tell you which ones are safe to bolt on.

Hard mode = third-party registries (Smithery) with thousands of servers; vet by quality >60, calls >1,500/mo, uptime >60%, recent deploy; install by URL or npx.

One remembers. The other does. You usually want both.

RAG = retrieval/memory; MCP = action on external systems; n8n has a native MCP node; better RAG = structured, tagged input + hybrid-and-semantic retrieval overlap.

At Shopify the engineers did not adopt first. The sales team did - and doubled their close rate with a tool they built themselves.

Three adopter archetypes; evidence that mandate + non-technical builders yields the fastest wins; 'AI Ops' as the emerging role.

Every sentence the caller says round-trips through three models before the agent answers. If that trip takes two seconds, the caller hangs up.

Voice turn = STT -> LLM -> TTS in ~1-1.5 s; latency = user-stop to agent-speak; per-minute cost = TTS + LLM + platform, rising with prompt tokens.

Twenty-one times. That is how much more likely a lead is to convert if you call back in five minutes instead of thirty.

Voice agents pay for themselves on missed calls and speed-to-lead; inbound receptionist is the entry use case; connectors make them useful, disclosure keeps them honest.

Most of the settings panel is noise. About a dozen switches decide whether the agent feels alien or alive.

Single-prompt agent, GPT-4.1, ElevenLabs voice + native fallback; AI-first welcome, 0.4-0.6 s pause, interruption 0.75-0.8, backchannel off, normalization on, denoise on, accuracy mode, 1.5-min silence cutoff, ~8-min cap; knowledge in separate docs.

The prompt is the instruction manual. Context says why the agent exists; identity says how it sounds. Everything else is architecture.

Context + identity; five sections (Role, Context, Personality, Task, Conversation Flow) + Knowledge Base + Function Usage Guidelines + Important Notes + repeated date/time variable; markdown structure.

Check, then book - never book on faith. Two functions is how the agent avoids promising a slot that does not exist.

cal.com event type + API key -> Retell Check Availability + Book Appointment functions with timezone; the prompt forces a single date and a confirmation before booking.

Retell does not send one end-of-call report. It sends two or three - and the first one is missing everything you want.

Post-call properties = Text/Selector/Boolean/Number fields extracted by prompt-quality descriptions; log via Webhook -> Filter(call_analyzed) -> Sheets Append Row.

Ask the client eight groups of questions, paste the answers into Claude with the second half of the document, and out comes a production-shaped prompt.

Discovery Form (8 question groups) + meta-prompt = generated voice-agent prompt in the standard structure; bundled in the Day 6 Drive folder.

Both can call tools. Both can classify. Only one remembers what you said a turn ago.

AI node = stateless single-provider LLM call for fixed tasks; Agent node = memory + swappable model + tool coordination for conversational/compound work; plan commands before the canvas.

Chain the agents and you pay every agent for every message. Broadcast and you pay the same. Keyword-switch and natural language breaks it. Classify-then-switch and 'email AND calendar' breaks it.

Master orchestrator agent with domain sub-agents attached as AI Agent (tool) nodes; master memory >= sub-agent memory; master prompt routes by domain and sequences compound requests.

Do you have the message ID? No. Then the first tool call is always 'get many'.

Tool = Resource x Operation; when an action needs an ID, instruct the agent to list first, extract the ID, then act.

Ask an agent to book 'tomorrow' and it books tomorrow relative to the day its training ended.

Add Date and Time tool + 'get current date first' instruction for any date-relative action; size memory windows deliberately (5 sub / 10 master) because every turn re-sends them.

Fireflies has no n8n node. Twenty minutes later Jerry is summarizing your last meeting anyway.

HTTP Request Tool + Import cURL + manual API key; multi-call APIs follow list-then-act; the agent composes dynamic request bodies from the prompt.

No single tool writes the report. Four tools in a row do - and the skill is knowing the hand-offs.

Decompose -> best tool per step -> connect outputs to inputs -> refine; the generalization of MCP stacking to any tool set.

Feed the framework one slide at a time - a screenshot, not a paragraph - and the model stops skipping ahead.

IDEA(L) = Identify/Import -> Describe/Discover -> Explore/Examine -> Analyze/Apply -> Learn/Leverage; drive it with one framework screenshot per step; the last step is human-only.

'Gmail connection is an MCP. Writing in a brand voice email is a skill.' If you can say that sentence, you understand the split.

Skill = metadata + instructions + resources, auto-invoked by description match; MCP = external capability; Project = context bundle; choose by repetition / external access / ongoing context.

The team automated everything and the videos flatlined. They gave editing back to humans and the numbers came back.

Idea -> Script (hook prompt + writing-DNA rewrite) -> Footage (ElevenLabs voice first, HeyGen synced to audio) -> Effects (Higgsfield, Suno) -> human Edit.

A sub-agent inside Jerry works only inside Jerry. The same Gmail logic as an MCP server works from every workflow you will ever build.

API = two-way sync request; webhook = one-way async event; MCP = agent-to-tool protocol; MCP servers are portable, sub-agents are platform-bound; scope MCPs narrowly.

Four causes of hallucination were named in one breath - and the fourth is the one nobody suspects: the chat is just too long.

Restart long chats; CLAUDE.md for persistence; MCP servers can be vibe-deployed from docs; scoped tool picks for apps, 3D, voice, WhatsApp, enrichment; per-client error workflows.

Two booking sites sell the same two rooms. The webhook is how the hotel finds out a room just went - instantly, in one direction.

Webhook = passive one-way event notification into your workflow; API = two-way request/response you initiate; GET reads, POST writes; prefer native nodes, fall back to Webhook/HTTP.

The scrape finishes, the webhook fires - and the payload has no lawyers in it. Just an ID. That is by design.

Apify Integrations -> HTTP Webhook (POST, on run succeeded) -> n8n Webhook node (POST, listening) delivers metadata with defaultDatasetId.

Every API on earth documents itself in the same cURL shape. Paste it and the node configures itself.

HTTP Request node + Import cURL from the API docs; replace token and placeholders; auth type per the API docs.

'I don't trust AI to always follow my instructions.' Neither should you - so make the parser enforce the shape.

Agent with System Message + Structured Output Parser (required format, JSON example) -> Gmail Create Draft in HTML; humans send.

Everything you just built by hand collapses into two dropdown nodes. He made you do it the hard way on purpose.

Native app nodes (Run an Actor -> Get Dataset Items) are the production path; the manual Webhook + HTTP build is the teaching path and the fallback for unsupported apps.

The workflow you built is a few kilobytes of JSON. Whether you sell the file or the service is the whole business model.

Sell the template or run the service; credit packs or flat-fee-with-margin; per-client API keys; n8n Cloud for small clients; GHL as CRM plus n8n.

An 18 GB laptop will not run a 671-billion-parameter model. Ask Perplexity which one it will run.

Parameter count vs RAM (18 GB ~ 14B); disk sizes 5-14 GB; Perplexity for hardware matching; Ollama + Claude Code; Genspark for offline agents; RunPod for rented GPUs.

Ask ChatGPT to add a calendar reminder and it politely cannot. Give the same model a calendar tool and a fixed script and you have a workflow. Give it the goal and let it figure out the steps - that is the only thing that counts as an agent.

L1 LLM (no tools) -> L2 AI workflow (tools, human-fixed path) -> L3 agent (goal in, ReAct loop chooses the path); complexity does not change the level, autonomy does.

'Would you allow an agent to handle your vendor payments?' The room says no. That no is the whole framework.

Seven yes/no questions on ambiguity, unknown path, value, recoverable errors, definable tools, step clarity, rigidity; >=4 yes -> agent; irreversible-error domains -> workflow regardless.

Overload an employee and they break down. Overload an agent and it gets confused, expensive and unreliable - in that order.

Narrow scope + minimal context + focused tools per agent; compose specialized agents under a manager rather than widening one agent.

'Here's what success looks like, figure it out.' If your prompt cannot end that way, you wrote a chat prompt.

Agent prompt = Objective + Tools (with usage rules) + Approach + Constraints (budgets) + Success/stop criteria; avoid endless-search, no-stop, conflicting instructions.

Four search engines and the agent freezes choosing. One search engine and a sentence about when to use it, and it moves.

Tools: clear name, complete spec, single purpose, explicit chaining; test with 3-5 realistic cases, iterate; add evals when production.

The bank-reconciliation system has no AI in it at all - and that is the most professional decision in the whole session.

Human 5% setup -> agent 90% execution -> human review; choose level by error cost: reconciliation = workflow, PO parsing = AI workflow, conversational sales = agent.

'Too many ideas, not enough time' got the best answer of the week: build a landing page with a waitlist before you build anything.

LLM reasons, MCP acts; validate with waitlists; per-client privacy via local models or Pinecone/Vertex; Claude custom connectors via config JSON; OpenRouter to compare cost.

If everything a client does lives in Google, the automation tool can live inside Gmail too - as long as they own a Workspace domain.

Workspace Studio = Starter -> Actions/AI skills -> branches inside Gmail; requires a Workspace domain; G-Suite-only; early stage.

Type 'shoes' into the knowledge base before you build anything. If the right chunks come back, the agent will work; if not, no prompt will save it.

Knowledge Base (upload + test retrieval) -> Agent (Role/Goal/Instructions via Generate with AI) -> Tool (native connectors) -> memory -> Create.

One agent that knows the catalog, the policy and every ticket needs a bigger brain for every question. Three small agents and a manager do not.

Scoped sub-agents each with their own KB and tone, under a manager agent (toggle) on a high-reasoning model; canvas shows the routing graph.

The embed button he remembered is gone. What is left is better for a builder: an API and fifteen lines of front end.

Lyzr deploys to a hosted chat or an API for custom front ends; pick Lyzr for fast chat agents with bundled costs, n8n for breadth and control.

'How do I get enterprise clients?' Referrals and free pilots. There is no shortcut without a portfolio.

Retainer over JSON; discovery -> whiteboard -> approve -> build; referrals/pilots for enterprise; thick wrappers add data + workflow; practical routes for free models, own servers, browser automation.

One misplaced comma and Claude Desktop stops loading every server you own. So you never type in that file - you let a model merge it.

Manual config editing = access to every MCP server incl. your own; merge configs with an LLM, never by hand; trust by stars/forks; restart after saving.

'My tool has no MCP server yet.' If it has an API, it does now - in about fifteen minutes and zero code.

API docs -> LLM writes cURL -> n8n MCP Server Trigger + HTTP Request tool (Import cURL, model-defined fields) -> Publish -> production URL in Claude config -> restart.

It built a stock analyzer and a trigonometry tutor from two paragraphs. It will not let you give either to a client.

Opal = Google Labs experimental no-code app builder; English -> node workflow; VPN-gated; internal POCs only, no external deployment.

Every fact ChatGPT remembers about you is a reason not to leave ChatGPT. Own the memory, and the models become interchangeable.

Provider-agnostic memory (Super Memory, mem0) via MCP stores small personal facts usable across LLMs; distinct from RAG; Pieces = local OS-level memory.

It asked whether to delete the installers before touching a single file. That question is the whole difference between an agent and a script.

Cowork = folder-aware agent in Claude Desktop with clarifying questions and visible steps; Claude Code = hand it a tutorial URL and let it build; beginners last.

A local model needs no API key - because there is no company between you and it. Paste the localhost URL into the node and go.

Ollama local URL into n8n (no key); .md/.txt/.json for RAG; Webhook + Respond to Webhook for site chatbots; LLM-edited JSON for randomized schedules; n8n evaluations for QA; Vapi complex / Retell simple.

The form submitted, n8n did nothing, and nothing was wrong - except the front end was POSTing to a node listening for GET.

Webhook node = test URL (manual listen) + production URL (live after publish); match HTTP methods both ends; keep the URL in .env, not in prompts.

You name the workflow. Lovable reads it through MCP and builds the interface. Then it cannot fix the one node you forgot - because it can only read.

Lovable Connectors -> n8n server URL (MCP Access); workflow must be published with schedule/webhook/form/chat trigger; add Respond to Webhook yourself; connector is read-only.

GitHub is Google Drive for code. The folder is a repo, the copy is a fork, and the license file tells you what you may do with the copy.

Repo=folder, fork=licensed copy, branch=isolated workspace, PR=reviewed merge into main, commit=history entry; self-host forks per the license.

Nobody buys a prompt. They buy the morning they no longer spend doing the thing the prompt does.

Package one skill into one system for one niche, prove it with a demo, price it on saved hours or reduced no-shows; domain knowledge is the unfair advantage.

'I help everyone' is a sentence that has never closed a sale.

Who / so-that / unique / painful / lucrative, narrowed by 1-2 of industry, demographic, geography, platform, price, delivery, 'without'; expressed as one I-help sentence.

A lawyer saves five hours at two hundred an hour. You built that. Charge a hundred - and then sell it ten more times.

Niche (d1-3) -> build/deliver/collect (d4-7); price = fraction of revealed value or hours x rate / 10; clone to 10, standardize, $500/mo; freelancer -> agency -> hybrid -> product; moats = data, community, reputation.

Fourteen days, twelve working artefacts - read the list once and you have the table of contents of this whole course.

Twelve breakout artefacts across 14 days; Catalyst re-enrolment offer; a year of weekly updates; hackathon Jan 25-27, demo Jan 28, certificates Jan 30.

The job title isn't 'AI expert' — it's problem-solver who uses AI as leverage, and half the qualification is the domain knowledge you already have.

A problem solver who uses AI as leverage, combining AI literacy, domain expertise, and operational execution. Not an AI/ML specialist, tool expert, or mere prompt engineer.

Four things happen to every prompt you ever send, and the third one is the reason prompting works at all.

The four things that happen under the hood on every prompt; the mechanism that explains why prompt wording changes output quality.

The model will never tell you it doesn't know — it will invent something plausible and say it with total confidence.

Models are probabilistic and never say 'I don't know' unprompted — demonstrated live by asking about the invented model 'Claude Juggernaut' (a café name), which ChatGPT confidently rationalized.

Buy a hundred-page journal and you can write a hundred pages — the context window is that limit, and your uploads use it up too.

Maximum tokens a model can hold — the '100-page journal' analogy. Uploaded documents count against it, not just chat text.

Instructions the model can handle on its own. Context is the part only you can supply — and it's where the quality actually comes from.

The art and science of filling the context window with the right information (Karpathy framing). Four-part context checklist: world context (who am I), task context (what must happen), examples context, constraint context (what NOT to do).

Add one sentence — 'let's think step by step' — and the model stops guessing the answer and starts building it.

Decompose a problem into linear step-by-step reasoning ('let's think step by step'). Google Brain paper (2023); trainer cites ~70% accuracy jump on reasoning puzzles. Reasoning/'thinking' modes in current models are CoT built in (1:43:28).

Open every prompt with who the model is. It's one line, and it decides which slice of everything the model knows gets searched.

Always start prompts with a role definition. It narrows the model's self-attention search space to the relevant slice of its training (the 'McKinsey partner' / 'worked for Salesforce' effect).

You don't have to read the three official prompting guides. Have the AI read them once, keep what it builds, and reuse it forever.

The 'father of all techniques': have AI assimilate the official prompting guides (Google, OpenAI, Anthropic) into a reusable universal prompt architect, then describe any problem to it and receive a complete high-quality prompt.

You've already built a RAG. Every PDF you've ever dropped into a chat window was one.

Answering from attached sources instead of model memory, eliminating hallucination for covered content. Uploading a PDF to a chatbot IS RAG.

Humans communicate in exactly three ways — text, image, audio — and AI now generates all three. That's the whole reason this moment feels different.

All AI applications are permutations of generated text, images, and audio; video is frames (images), calls/radio are audio, and images are RGB pixel matrices (1:25:10).

Every app you've ever used is two things: the movie the audience watches, and the production machinery nobody sees.

Front end is what the user sees and experiences (UI + UX — the finished movie); back end is where logic, storage, processing, and coordination happen (the production system behind it).

Two different questions guard every app: 'are you really you?' and 'what are you allowed to do?' — and mixing them up causes real design mistakes.

Authentication is identity validation (are you a valid user); authorization is access level (what tiers/features you may use — e.g. ChatGPT Plus vs Pro vs Enterprise).

Every button in every app is secretly a web address — press it and a request travels to a URL, code runs, and an answer comes back.

APIs are the communication bridge between front end and back end: every function (post a reel, like, comment) has a web address (endpoint) that receives an HTTP request, runs code, and returns a response.

Nobody builds their own VFX studio for one film — and nobody should build their own auth, database or design system for one app.

Off-the-shelf services and libraries used instead of building everything yourself (movie VFX analogy) — present on both front end and back end.

You never read a vendor's SDK documentation anymore — you paste its URL into your coding agent and say 'build the feature'.

Software development kits let you use a vendor's product inside your app (OpenAI, Anthropic, Gemini SDKs); modern workflow is pasting the documentation URL into your coding agent and asking it to build the feature.

A server is just a computer that's always on — your laptop can be one for an audience of you; the cloud is renting one for an audience of everyone.

The server is the machine where back-end code runs (movie editing-suite analogy). Your laptop can serve on localhost; for the world you rent machines from AWS/GCP — vibe-coding platforms bundle this hosting, which is why apps live at *.lovable.app-style URLs (0:44:07).

The framework is the session: never start building — start researching, and let the pricing pages of your competitors write your spec.

The session's core teachable: when you have an idea, first validate and research competitors, then define the MVP, produce a PRD, convert it into a tool-compliant prompt, and only then start building. Applicable to any domain and any coding tool.

Two core features plus one AI differentiator — that's the whole recipe, and everything beyond it is scope creep wearing ambition's clothes.

Don't copy the whole feature universe — for 'Task AI': projects + tasks structure, board/list status views, and an AI project generator that turns messy input (notes, transcripts) into structured projects and tasks.

Thinking is free in one kind of tool and metered in the other — so never pay credit prices for work a chat tool does for nothing.

ChatGPT/Claude allow unlimited iteration at no marginal cost; Lovable/Replit/Emergent charge credits per interaction — so do all research, planning, and PRD work in the chat tool and hand over only the finalized plan.

The most honest moment of the session: the planned Supabase build fought back, and the trainer pivoted to Lovable Cloud live — on purpose, mess and all.

Lovable now bundles database/auth/storage/edge-functions/AI as 'Lovable Cloud' (formerly a Supabase partnership) and actively pushes it; external Supabase still works but the wiring is deliberately harder.

Without row-level security, any logged-in user can read every row in your table — and real vibe-coded apps have leaked real user data exactly this way.

Supabase table-level protection; without RLS anyone can fetch sensitive rows (users, phone numbers, emails) from the front end. Enable automatic RLS at project creation — real Lovable apps have leaked data this way (1:33:06).

Your API keys are money — a leaked key is someone else's app running on your bill — and the whole protection system is three small files and one reflex.

.env holds real keys and must never reach GitHub (list it in .gitignore); .env.example documents which keys are needed without values; share real secrets via a password manager.

The moment your idea gets serious, the browser platform becomes the expensive place to work — and the exit is three clicks and one command.

Connect the Lovable project to GitHub (creates a repository), git clone locally, open in VS Code/Cursor, and continue building with Claude Code — the escape hatch when credits get expensive or the idea gets serious.

You're not choosing an automation tool — you're choosing who owns your automations, and n8n is the one you can take home.

n8n offers more control and logic customization, handles complex automations, is open-source/self-hostable/scalable, and is ideal for agents, decision trees, and stateful workflows; make.com is easier but closed-source, node-limited, and priced per-credit.

Every node is the same four-part machine — settings, keys, data in, data out. Learn one and you've learned them all.

A node has one clear job — execute its code. Every node carries parameters (settings/rules/options), credentials (API keys or OAuth connecting on behalf of your account), input data (JSON from the previous node or trigger output), and output data passed to the next node.

Every workflow is a sentence with the same grammar: one trigger to start it, then actions, logic, and — only where judgment is needed — an AI agent.

Trigger nodes start the workflow (manual click, on app event, on schedule/cron, webhook, form submission, chat message); action nodes perform work (e.g. Firecrawl crawl); core nodes hold logic/computation (e.g. insert row, spreadsheet ops); the AI agent node adds autonomous decision-making.

The AI agent node is five sockets: a soul (instructions), a brain (chat model), hands (tools), a diary (memory) and an escape hatch (human handoff).

Five components: instructions (system message — the agent's 'soul': role, rules, tone, what not to do), chat model (the LLM), tools (search, API access, knowledge bases, MCP servers), memory, and human handoff. Max-iterations governs how many passes the agent takes — more iterations, more tokens.

A skill is a hired consultant walking into the meeting room — and you can hire one into your n8n agent with copy, convert, paste.

Copy a published skill page (skills.sh), paste into Claude with 'convert this skill into a system prompt for my n8n AI agent node' — the agent inherits expert behavior, code, and resources. Skill = a hired consultant walking into the meeting room with their expertise.

One key, four hundred brains: OpenRouter turns 'which model?' from a rewiring job into a dropdown.

An agent node takes exactly one chat model; OpenRouter decouples that choice by routing 400+ models (including Chinese open-source models — DeepSeek, Kimi K2, Qwen) behind a single API key, so you can switch models without rewiring credentials.

A model is just a brain that has to live somewhere: rent one in a data center by the token, or run one on your own machine for free.

Cloud models (Anthropic Claude, OpenAI GPT, Gemini, Grok) run in providers' data centers and are paid per token; local/open-source models (Llama, Qwen, Gemma, DeepSeek, Kimi — some are both) run on your own hardware for free via Ollama.

Local model selection is one inequality: parameters in billions under RAM in gigabytes, with a fifth held back.

Parameter count (3B/8B/30B…) is the quality axis — 'the larger the parameters, the better the model' — and your RAM is the ceiling: choose models whose parameter count (in billions) is below your RAM (in GB) with a ~20% buffer.

Ollama is the app store for local brains: one install, one terminal command, and any open-source model is running on your machine — including the ones with no guardrails.

Ollama is an 'app store' for open-source models: install the app, `ollama run <model>` pulls and runs it locally, and the n8n Ollama chat-model node connects via a local URL credential (standard port, no API key). Searching 'uncensored' surfaces guardrail-free models (e.g. Dolphin).

n8n is a UI layer over JSON — which means the canvas is a rendering, and anything that writes JSON can build your workflow for you.

The build method: brainstorm the workflow as a mind map in Claude ('give me a simple mind-map flow'), then request the complete n8n JSON, paste it onto the canvas (n8n is a UI layer over JSON — a copied node IS a JSON blob), and iterate on errors.

Everything in the session lands in one build: trigger, scrape, format, document — with the credentials, the failure, and the fix all happening in front of the room.

End-to-end demo built from scratch: manual trigger → Firecrawl scrape of Hacker News → format → create Google Doc → append scraped data; credentials wired live (Firecrawl OAuth-style connect, Google account), one failing node debugged live, scraped output verified in Google Docs.

The Q&A answered the two questions every learner actually had: what does running this cost me, and can I get paid for it?

Local n8n needs ~4GB RAM / 16GB storage; skip the 14-day cloud trial by self-hosting; Intel laptops not recommended for local LLMs — rent a ~$10 RunPod VM or use Hostinger. Selling: sell the workflow outright, or host it on your server and charge a retainer.

Before a single node lands on the canvas, the whole newsletter already exists — as a map Claude drew.

Target flow mapped in Claude before building: schedule trigger → Firecrawl scrape of Hacker News → code node (brief prep) → AI agent with humanizer prompt → output parser → Google Doc (create + update) → Gmail delivery with HTML formatting.

One node does the whole harvesting job — if you configure it to extract exactly what you want and throw away everything you don't.

Install the Firecrawl community node, use the /scrape operation, and configure scrape options: two output formats (JSON with AI-extraction prompt + schema; markdown for LLM context), remove base64 images, block ads, disable store/cache, and choose basic vs stealth proxy.

Two file formats run the whole AI economy: one for when nothing may be interpreted, one for when everything must be understood.

Markdown (.md — hashtag headings, readable structure) is what LLMs read best, so it carries full-page context; JSON (.json, JavaScript Object Notation) is deterministic key-value structure, used when extraction must be absolute — 'we do not want Firecrawl to think about what the heading is'.

You don't need to know how to write a JSON schema — you need to know how to describe the box you're standing in.

Non-coders get schemas by describing the node context to Claude: 'I'm on the Firecrawl /scrape node, here's my URL and prompt, I'm struggling with schema — build the JSON schema for me.' Claude returned one more detailed than the trainer's production version.

The most valuable node in the whole workflow contains no AI at all — it's the one that stops you paying the AI to read brackets.

A JavaScript code node between scraper and AI agent strips raw JSON down to clean readable text — field names, brackets, and repeated structure removed — so the model sees only what it needs: ~40-50% fewer tokens for the same information.

The writing station is Part 3's skill-conversion trick promoted to production: a humanizer skill becomes the soul of the agent that writes the newsletter.

System prompt built the Part 3 way: copy the 'content humanizer' skill (based on Claude's official humanizer) from skills.sh, have Claude expand it into a detailed system prompt — 3-phase structure (detect AI patterns, humanize, verify) with a blacklist of AI-tell phrases — then set max iterations to 3.

Delivery is two habits dressed as three nodes: reference data with expressions instead of hardcoding, and know when the Gmail node stops being enough.

Create-document node (drive folder, expression-based JSON title) then update-document node (drag the document ID across), then a Gmail send-message node; subject and message should be expressions fed from prior nodes, not hardcoded.

n8n's assistant has two modes, and only one of them helps a non-coder: Ask explains your error, Build fixes it.

When nodes fail: 'Ask' mode explains (useless to a non-coder), 'Build' mode fixes — copy the error, @-tag the failing node, let it edit the workflow. It auto-inserted the missing parse-AI-output code node that made the Google Doc update work.

Same prompt, seven tools, side by side — the fairest vibe-coding comparison you'll see, and its conclusion is that the wrapper barely matters.

One prompt + the workflow JSON attached, run simultaneously on Lovable, Base44, Emergent, Bolt, Replit, same.dev, and Codex (GPT-5.5 'extra high') to build a blog front end that publishes the newsletters — outputs compared live.

'You cannot outsource taste' went viral as a warning — so someone packaged taste as a skill, and now you install it before building.

A skills.sh skill applying an anti-slop front-end framework so generated sites don't look like default AI output; named after the viral 'you cannot outsource taste' tweet. Install command embedded in the build prompt with 'download this skill before building'.

The best front-end prompt isn't written — it's derived, by handing Claude the back end and asking for the prompt that fits it.

Attach the n8n workflow JSON to Claude and ask for a hyper-specific Lovable 'mega prompt' — including the taste-skill install command and code blocks — so the front end is generated with full knowledge of the back end it must serve.

The blog and the workflow are separate machines until a webhook marries them — one URL turns the front end into the workflow's remote control.

A shared variant of the scraper swaps in a webhook trigger; give the workflow JSON to Lovable and ask it for/where to put the webhook URL. The n8n instance must be publicly hosted for the connection to work.

The Q&A drew the operational map: which scraper for which target, which host for which privacy need, and why your face still matters more than your stack.

LinkedIn without bans: rotating geo-proxies (e.g. Bright Data, which has n8n nodes) plus Apify's LinkedIn scraper. Apify = 'app store for APIs' (Instagram, YouTube scrapers); Firecrawl = scraping-only service. Fully-local stack = n8n + Firecrawl + Ollama all self-hosted.

The model you talk to every day has no memory at all — the app around it fakes it.

An LLM is the world's best next-word predictor, nothing more; it processes but cannot remember. Multi-turn coherence (capital of India → 'who is the PM of it') exists because companies like OpenAI and Anthropic manage a memory layer externally in the app.

An 'agent' isn't magic — it's just a model with two things bolted on: managed memory and tools.

The n8n AI agent node's three components generalized: ChatGPT and Claude apps are effectively 'super agents' — an LLM wrapped with managed memory and tool access — not bare LLMs.

The model never runs code and never reads code — it reads three lines about each tool and asks the app to do the work.

Anthropic's framework letting models use real-world capabilities: tools are scripts/functions/API calls; the model is configured to check its tools first, reads only each tool's name, description, and required inputs (never the code — reading a 10,000-line script would waste tokens), and instructs the app to execute.

With ten similar tools available, the model chooses by reading their descriptions — nothing else.

Selection runs on the natural-language descriptions; ambiguous or overlapping descriptions confuse the model exactly like vague instructions confuse an intern with three email apps. Corollaries: 'your AI agent is as good as your instructions' and tool descriptions must be concise and uniquely selectable.

MCP is a plug standard: one agreed way for any AI app to connect to any outside system, the way USB let any device talk to any computer.

Model Context Protocol, developed by Anthropic: a bridge letting hosts (Claude Desktop, IDEs like Claude Code, other AI apps) talk to databases, dev tools, and productivity apps without touching their UIs.

The whole bootcamp is one staircase: each layer hands the AI more of your context, and MCP is the top step.

Bootcamp arc recap: bare LLM + custom system prompts (persona/rules) + RAG (retrieve relevant docs) + MCP (act in the real world). Each layer hands the AI more of your context; MCP is the biggest layer — real-time action with the deepest personalization.

Three words carry all of MCP — host, client, server — and a restaurant explains all three.

You (customer/prompt) → host app (Claude Desktop) → MCP client (the waiter: coordinates, never cooks, only needs to know which chef to call) → MCP server (the specialist chef). Menu order = tool-call request; the dish served = tool response.

Open any MCP server and you'll always find the same three things inside: hands, a librarian, and a script.

Tools give the AI 'a pair of hands' (send email, run search); resources are 'the librarian' handing over files/emails/events the tools need; prompts are vendor-written templates (e.g. a send-email prompt) that shape sloppy user requests into effective tool inputs and can embed guardrails (don't read passwords, don't respond offensively).

The real product of MCP isn't capability — it's maintenance you no longer have to do.

DIY tool scripts mean you maintain every API version change, auth, and re-login across potentially 100 tools, running on your machine's CPU/GPU. An MCP server is the vendor's headless machine running the vendor's tools — Google maintains the Gmail MCP, so API churn and compute are their problem.

'Connectors' is just Claude's friendly word for MCPs — and wiring your first two takes five minutes.

'Connectors' is Claude's word for MCPs. Baseline shown first (no calendar/email access), then Gmail + Google Calendar connected live — every new connector requires fully restarting the desktop app — followed by cohort-wide exercises on free accounts using Haiku to conserve tokens.

When the built-in directory doesn't have what you need, the open marketplace almost certainly does.

Beyond the built-in directory: browse Smithery's MCP pages, copy the hosted server URL (this Google Sheets MCP was served via Composio; rated, with usage counts), then Claude settings → connectors → add custom connector → paste URL → authorize.

OpenAI built the same idea a different way: browser-based 'apps' instead of desktop connectors — younger, and it shows.

ChatGPT's MCP equivalent lives under Settings → Apps, browser-based rather than desktop-local (opposite route from Claude); recently launched and less reliable in the trainer's usage (~4/10 vs Claude's 7/10); no Google apps (rivals); Gemini has no connectors yet.

Forty people ran the identical Canva prompt and got forty different designs — and that's not a bug you can file.

Closing Q&A: AI is a probabilistic next-word engine, not deterministic — the whole cohort ran identical Canva prompts and got different designs; you can constrain outputs but never make an LLM deterministic.

A voice agent is a chatbot wearing a telephone: every 'conversation' is text underneath, with speech converted on the way in and out.

A smart assistant that understands human speech, processes requests with AI, and responds naturally: user speaks → speech-to-text → text fed to a pre-prompted LLM → LLM outputs text → text-to-speech. Three types: inbound (receptionist/customer service), outbound (sales), and interactive assistants living inside apps (Siri-style).

The pitch isn't that AI answers phones — it's that every missed call is marketing money you already spent, walking to the next Google result.

UK+US businesses collectively lose ~$100B/year to missed calls; leads contacted within 5 minutes are 21x more likely to convert than at 30 minutes, while the average UK business takes 4 hours; agents work 24/7 with no breaks — 'the perfect employee'.

'If you take nothing else away: your voice agent is only as good as your prompt' — and a good prompt is two ingredients, context and identity.

The prompt is how the agent is created: who it is, what it does, how it speaks. Bad: 'you are a bot that answers questions'. Better: 'you are a friendly assistant that helps customers track orders and give clear solutions' — a handful of extra words multiplying the context/identity signal.

A platform tour from someone with 50+ builds is really a map of what to ignore — half of Retell's menu is marked 'skip this' by experience.

Free signup, $10 credits, usage-based pricing (~11.5¢/min for the demo agent). Beginner-relevant: API keys (outbound only), call history, post-call properties, knowledge bases, phone numbers, webhook settings. Skippable: workspace webhooks, reliability/limits, pronunciation, boosted keywords, batch calling.

A long prompt makes your agent worse three ways at once — more expensive, slower, and dumber — so bulk information lives in a knowledge base the agent searches instead.

Big chunks of information (e.g. 10 service descriptions) belong in an uploaded knowledge base, not the prompt: long prompts make agents more expensive, slower, and dumber. The agent searches the KB on demand; upload as markdown for best AI readability; one KB can serve multiple agents of the same business.

The builder is a wall of dials, and the value of this hour is that someone has already found every sweet spot — including the counterintuitive one: faster isn't better.

Single-prompt agents (99% of his builds; conversational-flow only for methodical multi-path support calls), LLM choice, voice selection, welcome message (AI speaks first + custom text for conversational control), pause-before-speaking 0.4–0.6s, and speech/call settings each with tuned sweet spots.

The voice is a commodity you import: ElevenLabs has the library, Retell takes the ID, and one checkbox makes the agent bilingual mid-sentence.

Browse the ElevenLabs voice library (best/biggest selection), copy a voice ID, add as custom provider voice in Retell (billing unified, no double charge). Multilingual: the chosen voice must support the languages (check the '+16' tag); multi-select languages and the agent auto-switches mid-conversation at no extra cost.

Every production agent prompt has the same skeleton: role, context, personality, task, stages — and the last one is where you 'become conversational architects'.

Every agent prompt gets: role (who it is), context (who's calling and why), personality (traits plus the reasons for them — dental anxiety), task (split into ~5 small goals so the agent doesn't get pushy about one objective), and conversation stages — explicit stage-by-stage instructions making you a 'conversational architect'. Markdown ## headers delimit sections; ** marks importance.

Transcription will mishear names and mangle numbers — so you engineer the conversation itself to catch the errors before they reach the calendar.

Engineer the conversation to raise the odds of correct data capture: ask callers to spell their name, repeat it back and don't proceed until confirmed; read phone numbers back digit by digit (never 'one twenty-six'); one question at a time; force a single specific day before calendar checks — large availability payloads confuse the agent into silence.

Two built-in functions turn the talker into a booker — the work is entirely in the five minutes of cal.com plumbing, not the AI.

Retell's built-in cal.com functions power check-availability and book-appointment: free cal.com account, connect Google Calendar, create an API key (visible exactly once — save it), create an event type (duration, location, availability, minimum notice), grab the event type ID from the URL, add both to each function with your timezone.

Every property description is secretly a prompt aimed at a blank ChatGPT holding only your transcript — write it like one and every call becomes structured data.

Four property types (text, selector, boolean, number) extract structured data from every call (full name, reason, service, appointment_booked, call_outcome). Write each description as a full prompt with task, constraints, fallback ('return not provided'), and worked examples — the 'blank ChatGPT canvas with only the transcript' mental model — never one lazy sentence.

The test call is where every concept earns its keep — including two failures worth more than the successes.

Emma the BrightSmile receptionist handled a wisdom-tooth call: empathy on pain, spelled-name confirmation, digit-by-digit number check, single-day availability, booking. First booking attempt failed — the number wasn't in international format — and the agent self-corrected by asking for the country code.

One webhook, one filter, one append-row — and every call your agent ever takes files itself into a spreadsheet CRM.

Retell posts three webhook events per call (call_started, call_ended, call_analyzed); filter for exactly 'call_analyzed' (string must match character-for-character), then a Google Sheets append-row node maps summary, post-call properties, from-number, recording URL, and a Claude-generated n8n expression converting the UNIX timestamp to readable UK date format.

The Q&A is the agency's pricing sheet and vendor scorecard read aloud: which platforms, whose Twilio account, how humans get looped in, and what the big builds look like.

VAPI ≈ Retell but developer-oriented — recommend Retell for starters. GoHighLevel's native voice agents are 'rubbish' (no speech/call/transcription/post-call tuning), though call notes export to GHL fine. Client deployment: client's own Twilio account, you buy the number and SIP trunk on their behalf. Pricing scales with use-case and systems complexity — flagship build: a £25M/yr UK e-commerce agent wired to product, order, and ticketing databases.

One hundred pictures each and the dog is a cat. Five hundred each and it knows.

More and better labelled data -> better model; generative AI predicts rather than retrieves.

King sits near queen and far from barber. That is what an embedding is.

Embedding = meaning as position; attention = weighting; long context != reliable recall of the middle.

Prompt engineering is one layer. Context engineering is everything the model is holding when it answers.

Manage the five contexts; command clearly; edit, new chat, constrain; system = persona, user = scene.

Screenshot the framework, hand it to a project, and never hand-write a structured prompt again.

Six fields; a project that converts tasks into CO-STAR prompts; pick the model tier by job.

A 'worry translator' built live in both Claude and ChatGPT, broken twice, working on the third pass.

Artifact = published front-end micro-tool; Project = persistent instructions + knowledge.

'Summarise today's topics as a flowchart' - and Excalidraw draws it.

Connector = MCP server behind a product; start with the tasks you hate most.

The first scheduled run failed because the task had no memory of the roadmap. The fix was to put the roadmap in the prompt.

Folder access + roadmap + scheduled task; give scheduled tasks their context explicitly; browser agent for cross-tab work.

'Call yourself John Doe while you learn.' Once it is real work, it goes to an enterprise plan or a local model.

Dummy data to learn; enterprise/local to work; a maintained personal system prompt.

Don't tell the model what you want. Make it ask you first.

ACR = make the model ask, check its assumptions, then recommend.

Three roles, three chats. The analyst never sees the designer's enthusiasm.

DRA = three roles in three clean contexts; stakes language tightens output.

A connector is a door somebody built for you. MCP is the door frame. Composio is the hardware store.

Connector = product integration; MCP = protocol; Composio = marketplace; scheduled task = prompt + connectors + timer; draft, never send.

'A cool product shot' is not a prompt. Seven fields are.

Seven-field paragraph prompt; use an aggregator to pick the model per job.

A thirty-second product ad from a single product photo, in under an hour, on stage.

Stills (Nano Banana 2) -> motion (Kling) -> voice (ElevenLabs) -> edit (Premiere).

Every feature you can imagine goes in one of four boxes. Most of them go in the last one.

5 Whys finds the root pain; MoSCoW scopes the build to Must-haves.

Nobody builds a house by painting the walls first. Tables, then auth, then screens.

PRD -> Supabase schema + RLS -> auth -> one screen at a time -> publish.

Upload the syllabus, then tell it how to teach you - the Configure box is the part everyone skips.

Sources -> Configure persona and goal -> cited chat -> audio overview.

'Who do I know who has hired a fractional CFO?' - answered from your LinkedIn, Gmail and Twitter, not the open web.

Natural-language search over your own contact graph.

A cook follows the recipe. A chef knows why the recipe works and changes it.

Learn the pattern, not the recipe.

The model learned from documents with headings. Give it headings.

Headings + bullets + bold + fenced examples; structure is read as priority.

Paste ten things you wrote. Ask for the rules that make them yours. Save the rules. Never explain your voice again.

Samples -> extracted style guide -> tested -> packaged as an on-demand skill.

'Call my number and confirm the meeting.' The phone rings. That was an MCP server.

MCP server = an app the chat can use; Goose runs them locally; Ollama/LM Studio for private models.

Persona, knowledge, tools, number, test call. Fifteen minutes.

Assistant = prompt + voice + knowledge + tools + number; keep latency low; write the escalation rule.

You are leaving the camp at level two. Here is what levels three to five look like from the inside.

User -> prompter -> automator -> agent builder -> generalist; one project per rung.

The model is the engine. The agent is the car - it has somewhere to go and tools to get there.

Agent = model + memory + tools + a decision loop; most business needs are workflows with one agent step.

Every automation is a trigger, some nodes, and the question of where the model sits.

Trigger -> action nodes -> AI Agent node where judgement is needed; JSON between nodes; test node by node.

A $20 seat buys one person's chat. Two-tenths of a cent buys one ticket answered by a bot.

Seat for humans, key for software; ~$0.002 per support ticket; set a spend limit; store keys in credentials.

Every email to support gets read, classified, answered from the FAQ or escalated, and logged - before anyone opens the inbox.

Gmail trigger -> classify -> route -> FAQ-grounded draft or Slack escalation -> Gmail draft -> Sheets log.

Kodak filed for bankruptcy in 2012 for refusing to go digital. The thumbnail that used to cost you a designer's afternoon now costs four cents.

AI touches every stage of a creator's workflow - ideas, scripts, thumbnails, brand graphics, B-roll, voice, edit - at cents per asset; the competitive risk is not adopting it.

'Plan a five-day vacation for me' gets a generic answer. Add your city, what you like doing, how long you'll fly and what weather you want, and it gets specific - and it remembers all of it for the next question.

Detailed prompts + thread memory; toolbar = upload / search / Deep Research / DALL-E / Canvas / voice; Customize ChatGPT and Memory settings persist context.

Tell ChatGPT once to ask you questions when you are vague - and 'make me a banner' turns into 'what's your channel name, colours and tagline?'

Context = control; (1) custom instruction to ask clarifying questions, (2) generate-then-edit the prompt, (3) iterate conversationally, (4) reverse-engineer admired work into a prompt.

iPhone or Android. All three are good; the prompt matters more than the pick - but each has one thing it does best.

ChatGPT = versatile default; Claude = best writer, lower free limits, weak images; Gemini = Google integration + huge context + biggest free tier; paid ~$20 = more usage.

You do not need a thousand tools. You need five to ten - and one account that lets you pay per use for all of them.

Tool = single model/app; marketplace = many models, one account, pay-per-use; aim for 5-10 tools; PromptEdit.com is the instructor's own marketplace.

Some image models here cost a penny. A hundred images for a dollar, no subscription.

fal.ai = credits-only model marketplace; prompt left / output right; aspect, variations, prompt-optimizer; buy credits under Account > Billing.

If the tool just got better, the video stands. If the steps changed, the video gets remade. Either way the note is in the description.

Performance update = same method, better output (video stands); process update = new method (video remade); read lesson descriptions for deltas.

Never prompt the video model first. Get the still perfect for pennies, then animate exactly that.

Images-first pipeline; Nano Banana Pro for edit-preserving generation; Gemini (free/watermark) or PromptEdit (paid/clean) as the front end.

Draw three colored rectangles on the photo, tell it white is a lamp, red is a carpet, blue is a plant - and it puts them exactly there.

Edit / environment / style / reference / combine / thumbnail / camera angle / consistency / superimposed instructions - each driven by explicit image references and 'keep X exactly the same' phrasing.

Save 'Anthony in Office' once - four angles of your face - and every future prompt can @-mention it.

@-mention = name-based reference in the prompt; Elements = saved multi-image references for recurring subjects.

Grok is three times faster and up to four times cheaper. It also lost seven of nine rounds.

Grok Imagine = fast, cheap, permissive draft tool; Nano Banana Pro = fidelity and editing; draft on one, finish on the other.

The thumbnail is the wrong aspect ratio. Generative Expand fixes it with no prompt and three options.

Expand (no prompt) / Fill (lasso + text) / Background / Distraction Removal / Generate Similar; Firefly, Photopea, Canva as cheaper routes.

Most image models mangle letters. Ideogram 'nails text every time' - for about eight cents.

Ideogram V2 (fal.ai) for text-accurate graphics; detailed prompt -> single-element edits; vague prompt -> reverse-engineer into a detailed one.

Stop the scroll, solve a problem, make the click a no-brainer - then generate ten variations before lunch.

Three ad principles; product + face references; text in a second prompt; swipe competitor style; retainer pricing $500-1,000/month.

The video model can only animate the pixels you give it. Give it more.

Upscale stills (Clarity on fal.ai or Magnific) before animating; for site graphics, prime ChatGPT with page copy and let it self-prompt.

The workflow is older than AI. AI just swapped what sits under each step.

Idea -> script -> storyboard (stills) -> video creation (hybrid / image-to-video / talking-head) -> edit; keep humans in the loop; short shots are normal.

Upload a selfie from the front camera and the clone will not look like you. That is the photo, not the model.

Reference photos (rear camera, one person, good light) or a character sheet PNG; prompt subject/action + environment + outfit + expression + lighting + style; references can replace any element.

'Make a video of a cat jumping on a chair' - which cat, indoors, what time, what weather? The still already answered all of that.

Still first; Kling default, Veo fallback; prompt = subject action + explicit camera movement + mood; static shots look professional.

No still to lean on, so the prompt has to be the storyboard.

Subject + framing + environment + style (required); lighting, light colour, time of day, atmosphere, palette (bonus); ChatGPT drafts from the worksheet.

Give it where the shot starts and where it ends. Then make the ending of each shot the beginning of the next.

Start still + end still + prompt; Veo for realism, Kling for creative bridges; chain last->first frames for multi-shot sequences.

'Create a new wider angle version of this clip.' Same actor, same motion, a camera you never had.

Aleph = prompt-driven edits of an existing clip (effects, weather, relight, new angles) with consistency; 5 s; Runway subscription + credits.

Cinematic tools stop at ten seconds. HeyGen will let a still talk for as long as your script runs - as long as nothing behind it has to move.

HeyGen = long-form lip-synced avatar from one still + script/audio; styles, resolutions, ratios; simple backgrounds; segment; hybridize with voiceover + B-roll.

Every clip came back with a different voice. Export the audio, run it through your clone, and they all speak as one person.

TTS (stability 0.1-0.4), clone (long clean sample), changer (MP3 in, one voice out); clone drives HeyGen or Seedance 2.0.

Film yourself once. Replace yourself with a robot, a second character, anyone - the movement and lip-sync stay.

Video + Nano-Banana-edited frame -> Wan 2.2 Replace; guidance/steps/quality settings; split large files; performance preserved.

Front-load everything on the first minute. If the hook holds, the rest gets watched.

Iterate the script short; narrate; score; sync by crescendo; one timestamped Seedance prompt; patch shots in Kling; SFX seen/felt; ~20 minutes.

Four identical vague prompts gave four strangers. The template gave the same man four times. That is the whole difference between an ad and slop.

Script -> template characters -> Doc storyboard -> Veo (dialogue, transformations) + Kling (product, reactions, minors) -> ElevenLabs V3 cues + Voice Changer -> Resolve edit.

Hover the image, click Edit, and the model starts from what you already approved.

Edit-in-place from approved outputs; explicit swap prompts naming image one and image two; repeat the face swap per scene; blend references for undescribable detail.

'Roll on the floor' failed five times. 'Safety roll' - the parkour term - worked first time.

Motion prompt = precise start state + end state + the professional term for the move.

Replace swaps the face. Move takes your head, arms, weight shifts and micro-expressions and gives them to the clone.

Storyboard -> iPhone base + headshots -> base clone -> scene stills -> Kling animation -> Wan 2.2 Move transfer -> Kling bridge -> masked edit.

The animation studio quoted more than the song would ever earn. ChatGPT read his old sketches, Nano Banana drew the cast, Hailuo moved them.

Extract story from existing sketches with ChatGPT; one master prompt; front-view sheets; Hailuo with a stability preset; salvage sub-clips; parallel pipelines; cut by feel.

Stitching is where 'low-effort AI content' turns into something that 'feels more like cinema'.

Resolve for assembly and audio discipline; zoom cuts and nested speed ramps to hide seams; plugin SFX; deep-dive in the editing section.

A fishing lure alone on a table stops nobody. A person holding the fish does - and then the lure becomes the question.

Instant recognizability; one subject + one helper + two colours; <=4 words; a curiosity trigger - with measured lifts.

Do not chase the perfect prompt. Get a base image, then tell it to move you closer and enlarge the icons.

Reference -> descriptive prompt -> 16:9/2K/x2 -> re-upload and edit; GPT modes: scratch / improve / inspire; inspiration != copying.

Paste one script you actually wrote. From then on it writes like you, formatted for a teleprompter.

Style-analysis prompt into Memory + standing format instruction + ongoing corrections; voice-to-text as a seed.

'ChatGPT is like a muscle. The more we ask of it in one single request, the more it's going to start to fatigue.' So ask for the hook. Then the next section.

Context -> 10 ideas -> 5 title variants <60 chars -> SEO pick -> outline (hand-edited) -> section-by-section script -> read aloud.

Open a reply into Canvas with the button and you get a text box. Create the Canvas first and you get a rewrite toolkit.

Canvas = persistent editable doc with tone/length/level tools; create via button or /canvas, not by converting a reply.

'If chat doesn't know the answer, it will tell you' - as long as you asked it to be honest about statistics.

Seeded research prompts; script feedback prompt applied manually; script -> blog -> newsletter + CTA -> 3-5 shorts.

Swap one hook and the worst ad in the account became the best. Everything after the first sentence is contingent on it.

Hook > Problem/Desire > Solution > Offer > CTA + proof/urgency/guarantee; strategies: worksheet+prompt (Project), your hook + AI body, remix a winner + new hooks.

Same footage, same script, two editors. Once you see the moves line up you stop caring which app you are in.

Cut (Cmd+B) -> ripple gaps -> punch-in alternate clips + eyelines -> B-roll by I/O to the word -> transitions with ease -> music -> export; identical logic in both apps.

Lift is the base of the mountain, Gamma the middle, Gain the peak, Offset the whole mountain.

LUT then Lift/Gamma/Gain/Offset; track-level vs caption-level styling; keyframe = value at a time, two of them = motion, curves = organic.

Two Anthonys in one frame is a duplicated cutout and a feathered mask. The crickets are what sells it.

AI cutouts (Magic Mask / Auto Cutout) + feather -> replacements, clones, PiP; templates for titles and transitions; a final SFX pass on separate tracks.

Edit the interview by deleting sentences from a transcript. Remove the lamp with a mask and a clean plate. All in the free app.

Magic Mask, Transcribe, Subtitles, Voice Isolation, Smart Reframe, Super Scale, Music Remixer, auto colour, Object Removal, Speed Warp.

Drag the clip past where the footage ends and Premiere invents the frames. 'That is insane.'

Text-based editing with pause/filler filters; Extract vs Lift; Generative Extend; Remix; Enhance Speech 1.5-3; Scene Edit Detection; Auto Reframe.

Captions, multicam switching and audio cleanup are the three jobs nobody enjoys. Three tools do them for a subscription.

SubMagic = trim/caption/B-roll/clips for shorts; Autopod = synced multicam auto-cut in Premiere; Adobe Enhance = end-of-edit audio cleanup with free limits.

You said 'beach'. The script says 'waterfall'. Thirty minutes of your own audio and a paid plan fixes it while you sleep.

Professional clone from 30+ min matched audio (2-6 h processing) -> TTS with four sliders -> replace the word on the timeline.

Do not crop the shot. Grow the background, then lay the moving video back over it.

Export still -> outpaint to 9:16 (Photoshop or Pixelcut) -> composite original video over the still, masked and feathered -> nest.

A hundred sales a day at $48 is the business. A $14 add-on half of them take is the profit.

Smallest sellable product first; add a low-price order bump at checkout; small products scale marketing and free the calendar.

You do not need to be the expert, on camera, funded, or first. Someone in this list proved each one wrong.

Expert / money-topic / audience / on-camera / capital / saturation / time - each a myth with a student proof point.

Write the sales page before the product. If you cannot sell it in a page, do not build it.

Submarkets -> transformation options -> Trends check -> Reddit pain quotes -> sales page (Lovable) -> outline -> day-by-day script -> film -> partner/organic/ads.

'I'm going to show you how to go throughout this entire process as cheap as possible.'

ChatGPT script -> Nano Banana Pro stills -> Kling 3.0 motion -> HeyGen lip-sync per scene -> CapCut assembly and captions.

Upload the reference images, then talk about them by number.

Reference-by-number prompting: upload images, cite them numerically in the prompt, so identity and wardrobe persist across generations.

'Only make talking head videos for your intro and outro, then cover the rest with B-roll.'

Reuse generated B-roll across videos; restrict lip-synced generation to intro and outro; disable unused generation options; prefer pay-as-you-go.

Give the model where the shot starts and where it ends. Let it invent everything between.

Supply start and end stills to a video model and let it generate the in-between; supply a motion reference video when the movement matters more than the endpoints.

Point an arrow at the thing you want gone. That is the prompt.

Removal by arrow-prompt, object and wardrobe and background replacement, weather stacking, voice cloning (PromptEdit) versus dubbing (ElevenLabs), generated music and SFX, Topaz upscaling.

The 9/9 editor went and found footage in the channel's own back catalogue that nobody had given him.

Score on footage selection and initiative first, graphics second; unsourced or generic B-roll is a bigger fault than plain visuals.

A 10 on the cheese factor. Dollar signs, gold bars, confetti - all beautifully made, all wrong.

Judge every effect by whether a premium, trust-led brand would use it; well-executed cheese still damages credibility.

'All linear, not easy ease, which to me is just crazy how big of an impact that has.'

Apply ease-in/ease-out to all zooms, transitions and graphic motion; parent related elements so they move as one.

'Like misspelling something on your resume.'

Always review the rendered export end to end, with a break beforehand; visible artefacts read as carelessness, not inexperience.

He withheld the brand guide on purpose, to see who would go and find it.

Infer and amplify the client's existing identity - fonts, colours, motifs, logo animation - without waiting to be handed a guide.

Search before you post. Give before you take. Ask a specific question or expect silence.

Search first, reciprocate, ask specifically, follow the rules, show up live.

Every decision through one lens: does this affect the audience, or does it make me look cool?

Audience impact is the only criterion; learn craft from axioms of what moves people, not from copying style.

The first storytellers buried their dead curled up, as if for rebirth. Every story since has been that argument.

Story mirrors the rules of life: want -> pursuit -> defeat -> growth; no want, no story.

If your beats are joined by 'and then', it isn't a movie - it's Ikea instructions.

Want -> action -> conflict -> climax -> resolution; beats linked by but/therefore; stakes rise every beat; resolution = change.

Put a gun to someone's head and offer them a lie to live. If they tell the truth, now you know who they are.

Character = choice under pressure; ask what they stand to lose; protagonist drives events after the inciting incident.

One sentence that a stranger reacts to is cheaper than a month of writing nobody wanted.

Inciting incident + protagonist + want + antagonist + stakes; or protagonist + want + task against nature + stakes; test on strangers.

Search the thesis document, not the video. Ask in the community, not under the lesson - '100 times faster.'

Living reference doc + search-first, give-first community + weekly Q&A + free-response self-test.

Amateurs rewrite dialogue all day because they don't know the structure is the problem.

Logline first as a filter; 90% outline / 10% script; structure, not dialogue, is where scripts fail.

It works for a trilogy and for a thirty-second joke about a poisoned soda.

Eight-stage circle (comfort / want / unfamiliar / adapt / get / pay / return / change); ordinary vs special world; scale-free.

Repeat after me: no scene that doesn't turn.

Verb conflict vs antagonism -> opening value/charge -> beats (surface + gerund subtext) -> closing value must differ -> turning point on the last beat.

A pro gamer with insured hands asks his ex to break one. That is the whole Day 2 spine.

Logline -> circle -> beat sheet -> page, one scene, with the value flipping on the last beat.

'Carrie has a flair for the usual' - beautiful sentence, cannot be filmed, does not belong.

Slug / action / name / dialogue / parenthetical; present tense; filmable only; caps on intro; sparse parentheticals; O.S., V.O., CONT'D.

The screenplay is a blueprint. The building is the pictures, and you decide where the camera goes.

Director = author via camera placement; decide everything by the scene's meaning; craft is learnable; pressure is growth.

Nothing changed in the shot of the man. Only the image next to him changed - and so did he.

Juxtaposition of uninflected images creates meaning in the viewer's mind; story in the cut, not the shot; montage = assembly.

To groom. To approach. To entertain. To consider. Never 'to see the girl' - we cut to the chase.

Name each beat as a verb; show it with 2-3 uninflected images; escalate, never repeat; no narration, backstory or establishing.

'I didn't do anything. The director told me to stand over here and nod.' - Humphrey Bogart, on cinema's greatest scene.

Seven verb beats, each a handful of uninflected shots, flipping the scene's value; performance is a nod.

What does the character want? Start at the moment the problem begins. Cut any shot the beat survives without.

Through-line -> inception -> escalating verb beats -> shots pruned to the minimum that conveys each beat -> resolution.

'Shot of hand on doorknob' - not 'man waiting for professor.' The description stays uninflected too.

Scene# / shot# / uninflected description / size / movement / time (+ reference, timing, notes); take vs shot vs setup.

A $200 thesis beat the $20,000 ones - because the audience judged the story, not the stock.

Direct on the phone you own; spend on sound and story, not sensors.

Twenty-four frames a second, one forty-eighth of a second. Everything else is a creative choice.

Long lens flatters; lowest ISO; aperture for depth of field; shutter = 1/(2 x fps).

ISO 100, 1/48, and f1.4 in daylight gives you no image. A dark piece of glass gives it back.

Fix ISO and shutter; pick aperture for the look; ND filter corrects exposure.

1.85 fits a face; 2.35 fits a world; both end up 16:9 on someone's TV.

Choose ratio for genre and delivery; choose log/raw for latitude or default for speed - before shooting.

Max the resolution, 24 fps, stabilisation off on the tripod, lock ISO and exposure - and never, ever use the phone's mic.

Filmic Pro: max res, 24 fps, stab off on tripod, manual focus/ISO/exposure lock, ND, log add-on; external mic always.

'It's more important that you just start creating your film now than be one of those people who learns and never does.'

Poetics -> On Directing Film -> Directing Actors -> In the Blink of an Eye -> Hitchcock/Truffaut; shoot before you read.

Sensor size first. Dynamic range second. Resolution last.

Image quality (sensor > dynamic range > resolution) + ease of use + the practicalities; skip features you cannot use.

'The goal should be to get to full frame as fast as possible.'

Phone under $800 -> one APS-C plus fast glass at $800-1,500 -> full frame; never APS-C to APS-C.

'It can all happen almost instantaneously because they're literally all fused together.'

CPU cores and clock, RAM for bandwidth, GPU VRAM for rendering; Apple Silicon fuses them, so specs do not compare directly.

'It's like a waterfall where the active projects are SSD and then slowly they pour over and get stored in HDD drives.'

Active footage on SSD, finished projects poured down to cheap HDD; assume failure and plan copies.

'Neutral density filters are like sunglasses for your camera.'

Variable ND at 2-5 stops for exposure, a circular polariser for glare; buy the thread size up and use step rings.

'I just need to be able to see myself... that mirror mount is gonna let you do that.'

Name the problem, buy the cheapest solution; gimbal price = payload; a prompter suits some people and not others.

'Bad audio or even worse, no audio is mistake number seven on my list.'

6-12 inches, treat the room, then choose the mic by distance and mobility; TRRS phones, TRS cameras.

A wide lens spreads the room apart. A long lens pulls the background onto the subject's shoulder.

Focal length sets field of view AND compression; long lenses also magnify shake.

'One thing I typically try to stay away from is lenses with variable apertures.'

Two f-numbers with a dash means the aperture ramps as you zoom; prefer a fixed maximum, shoot wide open except for landscapes.

50mm is about a third of his footage, because it is closest to what the eye sees.

10-20 establishing and action, 20-40 the workhorse, 50 for people, 70-100 for attention, 100+ for what you cannot reach.

About 16 stops on an A7S III, about 12.5 on an EOS R, about 20 for the human eye.

Dynamic range = stops of highlight-to-shadow capture. Bit depth = grading headroom before banding.

The Canon has no log at all. He tunes a standard style instead, and it works.

S-Log 3 or Cine 1 where available (base ISO 640 on the A7S III); otherwise a standard style with contrast down one and saturation up one.

Hold the lock button and the camera stops hunting. Let go and it starts again.

Continuous/servo AF + area mode + a lock button; peaking for focus, zebras at 95% for exposure; lens compensation on; 'active' stabilisation crops.

Three feet from the wall to twelve, and the shot 'easily triples' in depth.

Low aperture + separation + a foreground layer + leading lines; separation is free and the biggest single lever.

'If there is one thing you can do to elevate the quality of your content, this is it.'

Direction (front, above, side), intensity (subject versus background), quality (hard or soft) - applied to any source, sun included.

A $5 bedsheet gives 'beautiful diffusion' - and moves your exposure two stops.

Add or move or diffuse a light, then re-expose. Cheap lights go close. A bedsheet is a softbox.

Many of his actual commercial setups are two lights, despite the name.

Key front-above-side to the Rembrandt triangle, fill opposite (often just a bounce), back for separation - two lights is often enough.

'Most fight scenes are filmed handheld' - the shake is the point.

Pan and tilt (angle), dolly, truck and jib (camera); push in, pull out, parallax, track, reveal; handheld for intensity.

'Never let it make the decisions for you... your phone, your camera left on auto will usually make a mistake.'

Set Kelvin manually; practicals ~3200K, daylight ~5600K; mix them only on purpose.

'This is where you hold all of your active footage' - one SSD, one project.

Externals only; one SSD for the live project; archive to cheap HDD on completion; second copies only for what matters.

'Keep the same exact format every single time you import footage.'

Work/Personal > client > shoot > camera. Assets in one shared folder. The archive mirrors the SSD exactly.

'Make sure you check the clips first before deleting the original files off of your SD card.'

Card -> named folder on SSD -> per-camera sub-folders -> copy -> PLAY BACK the copies -> only then clear the card.

'It's really just a wealth of continual content that you can build for your clients.'

Keep footage for repeat-client edits without a reshoot, for stock licensing, and for the demo reel.

'I like to drop three effects on my audio, generally speaking, unless it's really bad.'

Synchronize by audio -> compressor (voice leveler) -> parametric EQ (high-pass, mid/high lift, de-ess) -> hard limiter at -2dB.

The working method is more useful than the taxonomy.

Mute, rewatch, note the category per moment; then layer - varying repeats, using foley, choosing J-cut or hard cut.

'The highest level of structure is your library.'

Library > event (footage) > project (timeline). Save the library with the footage; import by leaving files in place.

'Premiere operates by being almost entirely in P mode all the time.'

A = Auto (magnetic, snaps). P = Position (free, allows gaps). Use P before touching a speed ramp.

An hour thirty-five down to seven and a half minutes in about forty minutes - then under two.

Pick and choose for modest footage and speed; timeline sift for thoroughness; duplicate the project before trimming again.

'So when I delete pieces of footage, it's not gonna start shifting our timeline around.'

Select the cut audio segments -> right-click -> new compound clip; the music is now immune to edits above it.

Stretch toward 100 and toward 0. Cross either line and the data is gone.

Correct to natural, then grade. Curves for contrast, hue/sat curves to isolate a colour, LUT as a preset, scopes as the referee.

'You don't want to choose any of these other presets.'

Assign audio roles to toggle categories; J-cut to lead; keep under 0dB; export Master File as H.264, resolution from the project.

'Premiere Pro is like mowing your lawn with an industrial lawnmower. After Effects is like trimming your beard.'

Premiere cuts side by side; After Effects layers top to bottom. Layer order is visibility. One shoot can yield several deliverables.

It 'basically defines where the center of your object is'. Move it and everything scales and spins differently.

Composition = sequence. Five transform properties on every layer. The anchor point is the pivot and must be recentred per element.

'What we want to do is have a more gradual slowdown of our words, which... represents real life.'

Easy Ease (F9) to smooth; the Graph Editor's velocity handles to shape it. Temporal = timing, spatial = path shape.

'It's basically like a filter. You draw a shape and it filters out everything else in the image.'

Duplicate the flat layer per element -> mask each duplicate to one element -> recentre anchors -> animate; shape layers behind for reveals.

'The faster the object is moving, the more motion blur it has.' Unless you forgot the master toggle.

Enable motion blur on the layer AND on the composition master toggle; apply as the finishing step after keyframing.

A fade in 'looks pretty boring and not that dynamic'.

Keyframe position over opacity; duplicate and reposition to build a phrase; stagger the start times; ease and blur.

'Aperture is as low as possible because we want that really nice, beautiful, blurred out background.'

Two cameras (70-200 tight, 50 wide), 24fps, 1/50, widest aperture, subject far off the background, prompter always.

'Each building off one another to raise viewers certainty to a point where they're ready to invest.'

Attention -> the gap -> the cost of the gap -> the solution -> social proof -> results and benefits -> visual support -> call to action.

Wardrobe and location changes let the client 'release content that essentially looks brand new' for months.

Design the day for several looks; mix polished, long-form and cinematic formats; record alternate endings in one pass.

'$500 per project back then versus now, charging a minimum of $2,000 per commercial on top of my monthly marketing fee.'

Define the process, then price against outcomes; the retainer sits alongside the project fee, not instead of it.

'You can save yourself so much time and headaches on the back end if you put the time in on the front end.'

Script early and rehearse it; pre-arrange B-roll and locations; research the benefits; clear the frame before rolling.

'We always export both a 1x1 and a 16x9.'

Export 16:9 and 1:1 with thumbnails; name by title, ratio and duration; store local, external and cloud.

A business page with twenty thousand fans gets 'a couple hundred people' looking at a post.

Four channels; lead with the one the client's buyers use; prefer personal profiles over pages; YouTube as the embeddable portfolio.

Steps one to five happen before anyone picks up a camera.

Commit, clarify the offer, choose a theme, script, storyboard, shoot, edit, release.

Problem and solution is 'by far and away the most powerful commercial theme out there'.

Problem-solution, value stack, demonstration, education, humour, desire fulfilment, visual wow, documentary, validation.

'Get attention, identify the gap, define the cost of not bridging the gap, identify the solution, introduce the product, results and benefits, social proof, and then finally, a call to action.'

Eight components in a fixed order, from a five-second hook through to a call to action shown on screen.

'Unless you've got some bottomless treasure chest full of advertising money your agenda for marketing probably looks a little like this: sell something now.'

Brand video: halo, no offer, no CTA, untrackable. Value video: ideal client, hook, value, trackable CTA.

'Without a powerful message a commercial will fall flat 100% of the time.'

Rank effort as messaging, then audio, then visuals - and treat too-perfect visuals as a social-platform liability.

'Less than 3% of a specific population is actually armed and ready to buy a specific product or service at any one point in time.'

Drill past the client's stated goal to a specific sub-audience, cast to match it, and sell one video per segment.

A $90,000 heart surgery is an easy sale, because the cost of not investing is death.

Sell the transformation; price against the cost of inaction; pick lead-gen, consultation or direct purchase.

A video 'shot with a one thousand dollar camera and a laptop' is credited with 1.5 million in sales in its first year.

Financial, relationship, time saved, conversion revival, differentiation.

The point of a system is that you never start from 'a blank piece of paper'.

Research, brainstorm, dimensionalise, finalise - four phases that replace starting from a blank page.

'One of the worst things that can happen to you after filming a video is to get into the editing process and realize you just don't have enough B roll.'

Turn the script into a reviewed shot list; shoot both breadth of subjects and depth of angles; cover everything twice.

'It's very natural for people to be kind of hurt if you stop the recording and say, hey, look, we need to redo that line.'

Plan, confidence, vocal direction, and pre-framing - all in service of a nervous non-actor's comfort.

'You're going to do 10 times less takes than you would if they're just going to ramble off what they think is right.'

Script in writing, sent for approval, then rehearsed aloud together before the camera comes out.

Existing customers of the business cover about 70% of it, free.

Customers, then friends and family, then drama students, then the portfolio card, then paid databases.

Two folders on import - A-roll is the story, B-roll is everything laid on top of it.

Two bins, a sequence per B-roll category, all stacked on one timeline with A-roll at the bottom - built before any trimming.

Synchronize by audio - never by clip start or clip end.

Synchronize by audio, apply the Canon Log to Rec.709 LUT, then compressor, parametric EQ and a hard limiter at -2.

'It really is what dictates the entire vibe of your commercial.'

Pick the song first, recut it to the energy curve, land the climax on the ending, duck -30 dB under voice, lift it at the open.

'I really don't mind using jump cuts in my work - if anything it aligns these videos with what people are already used to watching.'

Hard jump cuts on social; match-movement transitions with keyframed directional blur for cinematic work.

'What this actually stands for is consistent, creative, and valuable.'

Post on a sustainable cadence, distinct enough to notice, useful enough to earn attention - and cheap enough to produce that you keep going.

'Don't focus on the small details like oh, Anthony shoots with a 4K camera... people don't care about that.'

Qualify the client, ask four fixed questions, extract a number, then cut short, medium and long versions - each ending on a CTA.

One Iceland travel video is why a Costa Rica tourism company hired him on the spot. A general reel would not have.

Make one portfolio piece in the exact niche you want to be hired for, even unpaid, then pitch it directly.

'We don't just want to be a pretty video with nice visuals... We want to tell a story. We want to evoke emotion with our work.'

Establish, unify the niche, cut on the beat, sound-design the transitions, and end on a CTA with branding.

'This is what I like to call a win, win, win. Since three parties are all getting great benefits.'

Discount both the referrer and the referred; scale the incentive to retainer spend; retire it when volume becomes the constraint.

The most valuable variable in both lessons is free: how far the subject stands from the wall.

Diffused key at 25-45 degrees, hard rim behind, practicals for colour, subject well off the wall, camera at or above eye level.

Retainer clients kept paying through the COVID shutdown, when one-off bookings stopped.

Setup fee plus monthly management, priced on a three-level ladder, sold by diagnosing traffic vs leads vs conversions.

'So many businesses cripple themselves because they don't have a system to do all this crucial stuff in one place.'

Centralise contacts, automate follow-up, keep structured notes, and use real contracts, invoices and e-signatures.

'The biggest difference between a good kind of amateur editor and a great editor is someone who usually doesn't even need to lean in on effects and transitions and big graphics.'

Story-serving B-roll, eased motion, a strong hook, finished details, no cheese - and effort beyond the brief.

Flip the sequence, duplicate the clip, blur the bottom layer - and there are no black bars.

Flip the sequence ratio, duplicate the clip, scale the top layer onto the subject and Gaussian-blur the bottom to fill - or let AI reframing track it.

Three lessons, three offers, and no craft content in any of them.

Two own-brand products and one third-party discount route, presented inside the course as savings.

An $8,000-a-month software stack is the number the whole pitch rests on.

Consolidation reduces friction between tools - but validate the saving against your own bill, not the one quoted.

About 60% off Creative Cloud, contingent on an enrolment that has to be real.

Education pricing via a partner institution - real enrolment, current partnership, and Adobe's live policy all required.

Seventeen lessons, already taken apart in full - one course over.

The 17-lesson Resolve module, republished; canonical extraction lives in cc-sm-08.

Nineteen lessons, and the eight-part core is the spine of every edit in the main course.

The 19-lesson Premiere module, republished; canonical extraction lives in cc-sm-09.

If the camera moves a millimetre between takes, no mask will save you.

Locked-off camera + planned blocking + separate takes on opposite sides + Log profile = a maskable clone plate.

The top layer covers everything. The mask is just you telling it which half to let go of.

Two aligned layers; mask on top; invert to choose the side; feather to hide the seam; single audio track; LUT + SFX to finish.

On mobile the 'top' layer sits at the bottom of the list. Everyone gets caught by that once.

CapCut clone = Overlay (mobile) or second track (desktop) -> Horizontal mask rotated 270/-90 -> Reverse/Invert -> Feather -> mute one clip.

Zoom the program monitor out to 10% so your mask points can live outside the picture.

Premiere clone = V1/V2 -> Razor/Ripple Delete (R) -> Opacity pen mask drawn outside frame -> Unlink audio -> Mask Feather 100 -> Adjustment Layer LUT -> SFX.