Figure gallery

The bridge this session builds — from the skill side to the business side

Three levers — and the property-manager offer pulling all of them at once

Four variables, one fraction — and the bottom is where price lives

One question splits the tree; six sub-constraints locate the real problem

Three business models — pick by who you are, not by what's trending

Function + industry = niche; add the exact problem and you have the offer line

Four places the niche complains — AI summarizes the noise into validated pain

Scope → design → develop → QA → deploy — and deployment opens the retainer

Three multiplied variables set the power; three models collect the money

The standard stack — table stakes to nail, and exactly what reads as slop if that's all you do

A folder with a process inside — and a marketplace of other people's processes to build on

Four commands — and 'study' turns any site you admire into a reusable theme spec

Image → video → inward-masked hero — the $5-10k agency look, in minutes, near-free

Dataset → enrichment → two-mode app — the structure IS the product

Static book → extracted frameworks → citing evaluator → lead-magnet gate

Snapshots of the whole folder, a software that takes them, and a Drive that holds them

Codex → push → GitHub → Vercel — after setup, the live site updates itself

Five rungs — and the contact-vs-lead gap that decides your reply rate

Three layers plus BANT — where to aim, who to talk to, what to say

Foundation first — the front door is the only part they see, and the last part you build

The three lanes side by side — everything free except AnyMailFinder, all feeding tomorrow's n8n engine

Same energy, opposite outcomes — the gap between them is enrichment

Brain, Amazon, Claude, your outbound — one loop, five stages

Symptom → bucket → fix — months of guessing replaced by one diagnosis

Raw names in, decision-ready prospects out — five stations, Google Sheets as the spine

Offer + lead list, through Instantly, aimed at meetings — with the trash can catching spam, bounces and bad copy

Four slots, one sentence — and the weak-vs-strong contrast that shows why each slot earns its place

One pristine main domain; disposable outreach domains 301-redirecting into it; subdomains reserved for apps

Accounts in the pool exchanging mail to build reputation — then incremental real sends under the per-inbox ceiling

Subject → icebreaker → problem → solution → proof → low-friction CTA, under the four rules of engagement

Four memory blocks feeding the Copilot — and through it, lead search, campaigns, and both agents

Four emails, link entering at step 2-3, breakup at step 4 — any reply stops the machine

Email → short branded redirect → dedicated offer page (whole card clickable, no loader) → Stripe — every removed click is revenue

Where credits burn — enrichment per row, agent per reply, AI-enrichment scraping — and the levers: model choice, BYOK, skills instead of platform AI

Instructions, tools, skills — the three straps holding the agent to the cart, and the kitchen analogy for each

Sources in, judgment in the middle, a live website out — the self-learning factory he built on stage

Search, platforms, YouTube-for-free, blogs — four scrapers, each with a lane, routed by rule

Expertise × customer need — the intersection where ideas survive, with the crowded-market counterexamples

Onboarding wizard → levels 1-3 → pain popup → qualified? → pay (refundable) → book — the free tier as a lead-scoring machine

Four layers, a menu per layer, and one verdict: agonize over business logic, not database brands

Brainstorm → spec → implementation plan → build — decisions made where they're cheapest, autonomy granted where it's earned

The chat app gives you text to copy; Claude Code creates the files on your machine

One folder, one SKILL.md: the metadata travels with every chat; the prompt body loads only when the skill is invoked

Skills advise; hooks enforce — fixed X→Y rules that fire on events, every time

Three rings of memory: chat-only, folder-wide, and machine-wide (~/.claude)

The app-side build loop: vague prompt in plan mode, clarify, comment on the plan, accept into auto, iterate with screenshots

Three prompts, one pattern: strategist writes gtm-plan.md, the board is built FROM the file, features layer on

One fresh session, zero prompts typed — and 2% of a million-token window is already spent, almost all of it on MCPs

Agents are vertical departments with their own models; skills are horizontal SOPs every department can use

Two single-task skills piped together: persuasion first, implementation second, inspiration optional

Phase prompts → context extraction from your own landing page → React code → rendered MP4 → timeline studio for edits

One command, one server, one markdown file — what each extension mechanism really is

The tower the session climbs: framework at the base, skill at the top, each layer wrapping the last

The live build pipeline: fresh folder → plan mode on the strongest model → bypass → execute in phases

The marketplace's four-layer scanner: hidden text, dangerous patterns, script analysis, AI classifier — a critical finding blocks the skill

Skill + catalog + one prompt → design system → storyboard → six parallel frames → checked render

Describe → IDE → agent CLI → engineering systems: the promotion ladder

The checker refuses finish until the doer's work passes — that's the whole machine

Chef, waiter, food inspector, manager — the four-file restaurant that builds products

Rules, team, skills, guards, memory, loop+check — wrapped around one agent, it becomes your OS

One loop does one task; a graph is loops with dependencies — nodes are agents, edges are signals

Production sits untouched at the top; work climbs the tree toward it

The Rome rule — nothing crosses the gap until you push or pull

The PR gate — raise, review, then merge; access can stop at any step

Each branch drives its own Vercel site — only production wears the real domain

Three signals that an ad is a proven winner — and where the data legally lives

Duplication copies the ad; intelligence extracts the pattern and ships your brand

The split-screen loop — workflow JSON out, node code back, paste, run, repeat

Competitor image → vision description → strict system prompt → your branded ad

Providers, aggregators, cloning apps: the closer to the model, the thicker the moat

Product image in, analysis, script, Veo scenes, stitched UGC ad out

Small stories, fresh context per pass, human merge at the end

Firecrawl to copy to image-native slides to newsletter, with the human Publish gate last

Two disciplines, one destination: structured data

The measured RAG stack: chunk, embed, Qdrant, answer, every provider swappable

Skills audit, agents fix, the loop re-audits: the $8 report engine

One command center over swappable surfaces, open-source floor underneath

The correction that shaped every later build: the magnet demonstrates the product on one niche, end to end, with verified evidence - rather than explaining what a lead magnet is.

Cameron's funnel with the single job of each stage, and the friction dial that sits between the ad and the call.

From the Week 14 post-read: read lead volume against lead quality and no-shows, then turn the friction dial the matching way.

The four archetypes across five dials. Human involvement falls but never hits zero - the small bar on the right is the whole argument.

The loop he asks the cohort to memorise. The exit is owned by the checker, not the actor.

The model is one box. The four boxes around it are what you actually design.

The self-managed path he demonstrates, and the one branch he tells you not to take.

The four rungs the cohort has climbed, and where the money actually sits.

Not UI front end - business function. The ROI on the left is legible; the ROI on the right has to be argued.

Ritesh's comparison from the bonus session: what each side of n8n gives up, and which kind of user should start where.

The four components as taught on Day 4, with the design decision made for the email support agent: memory omitted, tools narrowed to RAG + draft.

Dileep's three MCP modes on Day 5: what you install, what plan you need, how many servers you unlock, and where each is portable.

One conversational turn as taught on Day 6: five steps in ~1-1.5 s, and the Retell settings Matt tunes at each stage.

Jerry as built on Day 7: one master agent routing to three domain sub-agents attached as tools, each with its own memory, model and app tools.

Day 9's two-node story: the webhook hears that the Apify run finished (metadata only); the HTTP Request then asks the API for the actual dataset.

Jitesh's ladder on Day 10: who decides the steps at each level, and the test that separates a complex workflow from an agent.

Day 12's no-code MCP server: API docs become a cURL, the cURL becomes an n8n HTTP Request tool behind an MCP Server Trigger, and the published URL becomes a Claude connector.

Four steps under the hood — and where your prompt actually lands

The window, and the four kinds of context you fill it with

Three vendor guides in, one reusable prompt architect out

The library — why chunking and indexing are the whole trick

The movie and the production — what users see vs where the work happens

Research → MVP → PRD → prompt → build — plan free, spend late

The escape hatch — browser platform to code you own

One node = one job — parameters and credentials in the box, JSON in, JSON out

One trigger starts it; actions do work, core nodes think, the AI node decides

Five sockets: soul, brain, hands, diary, escape hatch — the soul matters most

Two places a brain can live — and one router across both

Mind map → JSON → canvas → debug loop — errors are part of the method

The production pipeline behind agentmag.dev — scrape, distill, write, archive, send

Absolute vs readable — and the answer is both

Same information, 40-50% fewer tokens — the single most valuable node in the workflow

One prompt, seven tools, compared live — results track the model, not the wrapper

The tool-calling loop — model decides, app executes, reality returns

The bootcamp staircase — each layer hands the AI more of your context

The restaurant — customer, waiter, specialist chefs

Hands, librarian, templates — every server ships all three

DIY maintenance treadmill vs the vendor's headless server

Five steps per turn, three kinds of agent — this session builds the inbound receptionist

Every dial has a sweet spot — each number here came from 50+ production builds

Five core sections plus supports — markdown headers delimit, the prompt is the agent

Every call becomes a CRM row — and the CRM can flow back into the call

Anthony's 5-step workflow with the tools this course assigns to each step, and the three video-creation routes under step 4.

Each tedious editing job in Section 9 and its three answers: do it by hand, use the free built-in AI feature, or pay for the shortcut.

Nick's realtor-reel pipeline, the tool at each step, and the two habits that keep the credit bill down.

What actually moved the scores across five graded test edits: B-roll and restraint up, cheese and unchecked exports down.

Character wants -> acts -> conflict -> climax -> resolution, with every link a BUT or a THEREFORE and stakes rising at each step.

Harmon's eight stages: the top half is the ordinary world, the bottom half the special world where the protagonist takes control.

The same shot of a man reads as marksman or dog-killer depending only on the image placed next to it.

Lock ISO low and shutter at 1/48; choose the aperture for the look; let the ND filter absorb the exposure difference.

The three-category buying framework with the dynamic-range benchmarks, and the ladder that ends at full frame.

Focal length by job, with the compression effect and the crop-factor arithmetic that changes what a lens actually gives you.

Left: the three factors of light and the key-fill-back geometry. Right: the four ways to build depth, including the one that costs nothing.

The two-tier storage system, the folder tree that makes relinking a one-click job, and the ingest verification step.

Final Cut's three-level structure, the magnetic timeline's two modes, and the two rough-cut methods with the numbers from the demo project.

The compositing model, the transform properties with the anchor point highlighted, and the easing curve that separates amateur from professional motion.

The repeatable shoot recipe, the eight-part messaging framework, and the job's actual economics side by side.

The eight production steps across three phases, feeding the eight-component message

Script to shot list to coverage to bins to stacked timeline - where each failure gets caught

CCV posting into testimonials into referrals into retainers - the four bonus-section growth levers and how they feed each other

Diffused key at 25-45 degrees, hard rim behind, cheap practicals in the background - and the distance that makes it read as depth

The five things the scorers actually reward, and the two that lose points regardless of technical skill

Two takes, two layers, one feathered mask: the anatomy of every clone shot.

Bottom to top: splash plate, frozen cutout of the jumper animated down, the mug-rim shield, and the hand-hiding freeze frame.

Both sides of the cut sit at 8x: clip one ramps up and holds, clip two starts fast and eases down - the eye never catches the edit.

Three layers and one zoom: the grab plate plays inside the keyed phone, the hand is masked back in front, then the phone layer scales out of frame.

Object mask (static) + hand mask (animated) become one mask the frame the hand touches the mug, then travel out together.

What the script contains (four areas, top) versus how the day is spent writing it (four phases, bottom); every phase writes into the same storyboard template.

The gap between the prospect's Point A and Point B, the four things you write about it, and the offer as the vehicle across.

The barometer from don't-buy to buy, with the dimensionalizing techniques as the weights that move the needle.

How the live session builds the offer: anchor price, ROI math, 60% off, lead bonus first, meta-bonus second, one-line CTA.

Message, audio and image with the 80/20 weighting and the proof points behind each corner.

The Day 1 settings in the order the practice exercises teach them, with the frame-rate and shutter-speed arithmetic attached.

The four factors behind background blur on a phone: one you cannot change, two that fight each other, and the one that actually decides the shot.

Thirds, looking room and headspace on the left; the three-plane depth stack on the right - the two ideas that carry the day.

Left: key placement and the three-point setup. Right: the audio chain in the order that actually decides quality - proximity, room, levels.

Left: the three levels of story and the four pillars. Right: the ten-step editing workflow in order.

The four desktop techniques that transfer to any editor: keyframes with easing, the slow-motion ratio, log grading by waveform, and cutout plus mask.

Resolve's seven pages mapped to the stage of post each one serves, with the two a beginner actually lives in highlighted.

The ten-step order with colour deliberately early, and the compressed eight-step version used for commercial work.

Packaging decided before production: title and thumbnail first, hook anchored in five seconds, CTA placed mid-video where people still are.

Left: the short-form hook and the shareability levers. Right: the Day 14 client pipeline from conversations through the Deep Dive to a reel with a call to action.

The three-tier retainer ladder, the add-on services above it, and the three acquisition habits underneath.

Left: the four-column topic worksheet. Right: how a video is tested and scaled through escalating rounds of impressions.

Left: the four-step video formula. Right: the eight-step camera-anxiety ladder, one fault per take.

The camera checklist that outlives any model number, with the buying rules for light, sound, filters, gimbals and storage beneath it.

What is fixed and what is yours on a phone, the outdoor and indoor failure cases, and the fix for each.

The three groups of camera-buying criteria, the stabilisation ranking, and the three monitoring aids that replace guessing.

One lighting logic built three times - window light, one diffused light, full studio - with the substitutions that collapse the gap between them.

The ten-step assembly order on the left; the YouTube-to-product funnel and the proof-to-price ladder on the right.

Goal to audience to content on the left; the three pillars, five shareability hacks and the beat-synced reel workflow on the right.

The Premiere keys and menu items he leans on from cull to export, grouped by stage.

How Lumetri instances stack on a clip in Effect Controls - and where the log correction, masks and LUTs sit relative to each other.

The spec categories he weighs, in the order he teaches them, with the thresholds he names.

His setting order - ISO to the floor, aperture for light, shutter to the 180-degree value, ND to make it fit - and the histogram rule that checks the result.

The four light directions relative to drone and subject, with his verdict on each, and the hard/soft axis that cuts across them.

The twelve most-used moves as stick inputs - which stick, which direction, what the gimbal wheel does - grouped by what they are for.

His farm shoot as a sequence - prep steps on the left, the on-site shot list in order, and the reversible shots that give two options each in the edit.

The twelve tips grouped by what they govern - what gets in, how long it stays, where the cut lands, how it flows.

The speed-ramp procedure and its three uses - one clip, a two-clip transition, and a compressed middle.

The Fusion node chain from MediaIn to MediaOut - track, solve, set origin, export the scene, merge 3D text - with the checks at each step.

His typical node chain and the rule for what goes before the log correction, what goes after, and why the LUT comes last.

The three Studio finishing tools, where they sit in the chain, and the numbers he starts from.

The pattern under the walkthroughs - the six moves in order, with the two that do most of the work marked.

The five channels in the order he says to try them, with the free-video offer as the wedge in the first two.

The two-prompt Cowork workflow - lead list, then Gmail drafts - with the numbers from his run.

The sandbox and the website: design first, build second, two paid skills

Function first, style second - the failures happen when the order flips

Four phases, four agreement rounds - extras are paid, sign-off is email

The chapter's quantified core - palette structure, type scale, spacing tokens, container math

Discovery to direction: every arrow is an email the client confirms

Logo Hue in, connected Figma styles out - the Website Stylekit loop

Finish, send, feedback on a duplicate, detail passes, polished preview - the delivery loop

Files, hosting, WordPress, the theme content box, and the takeover

One post machine: types differ only in fields; templates + current query render them all

One primitive, infinite depth, with the 1140/1120 and 35/25/20+grow numbers

Eight color slots + rem/clamp type, proved by the style guide

Starter template in, hard things first, per-container completion, a package out

Missing feature? Native, then a CSS shim, then an add-on, in that order

Three backup layers plus the fleet layer, because hacks surface late

Harshit's architecture for Paul - from scattered chats to a self-hosted second brain

Watch, re-watch, study the gap, wait 12 hours, then re-test - as opposed to the failure pattern of consecutive retakes.

Tilting a multirotor resolves rotor lift into vertical lift and forward thrust; level flight needs vertical lift equal to weight.

Load factor against bank angle - gentle to about 45 degrees, then rising steeply beyond 60.

Nose-down moment from lift ahead of CG, balanced by tail-down force aft; moving CG aft shortens the arm and reduces the tail-down force needed.

Day, then 30-minute morning and evening civil twilight bands around sunrise and sunset, with night beyond - light required in twilight and at night.

The 400 ft ceiling drapes over rising terrain - flying a constant 400 ft indicated over a 200 ft hill puts you 600 ft AGL and illegal.

Categories 1-3 by weight, energy limit, laceration protection, means of compliance, label, and what each may do over people and open-air assemblies.

Upwind, crosswind, downwind at 1,000 ft AGL, base descending, final - with the 45-degree midfield downwind entry.

Inverted wedding cake - surface core over the airport, successive rings stepping up and outward, all topping at the same altitude.

Dashed magenta at the surface - standing alone means E2 and authorization; attached to Class C or D means E3/E4 and none.

Obstacle annotation - MSL top above, AGL height in parentheses below; the difference is the base elevation.

Density altitude against temperature and pressure at sea level and at 5,000 ft - the same field can feel 6,800 ft apart between a cold high-pressure day and a hot low-pressure one.

Four fog mechanisms - radiation (calm, valley, overnight), advection (windy, coastal), upslope (terrain-driven), and steam (cold air over warm water).

Unstable versus stable - cumuliform/showers/turbulent/good visibility against stratiform/steady rain/smooth/poor visibility.

A METAR broken into its ordered fields, with remarks decoded.

The five hazardous attitudes paired with their antidotes.

By day the cones give sharp central vision; at night the centre goes blind and the rods, offset to the side, take over.

Red left, green right, white tail - and how the arrangement reveals approach versus departure.

Appendix 1 legends, Appendix 2 figures - and why figure numbers do not match page numbers.

Bank angle vs G-load - and what a 60-degree bank does to stall speed

Forward vs aft CG - every gain purchases an equal and opposite loss

400 ft AGL hugs the ground; the structure exception builds a 400-ft tower of airspace

Upwind to final - the racetrack every manned aircraft flies around a runway

The airspace stack - who needs authorization, and where Class G hides

The airport data block, line by line - and what the colors do and don't promise

Hot, high, humid, low pressure - four dials that raise the altitude your drone feels

One METAR, dissected - each block labeled with its decode rule

Five attitudes, five antidotes - recognition is always step one

The three-account pipeline from FTN to certificate to currency

Five levels, each gated by proof — with 2 and 3 allowed to overlap

The canonical build: email in, classified JSON, guarded draft, logged row — human always between draft and send

Claude Code as muscle, Antigravity as mirror and warm standby, one repo underneath

The 50% ritual: log to memory, exit, resume fresh

tldraw sketch, key-protecting server route, vision model, preview + code

The nine steps, with the non-AI block, the AI-fitness gate and the Version 0 baseline that any build has to beat.

The AI-fitness screen: three gates, then the automate-or-augment call, the ROI arithmetic and the adversarial check.

The recommended GrokBot organisation - you as CEO, a routing-only chief of staff, specialist bots - sitting on one shared cloud machine, designed with the four ingredients in order.

soul.md, user.md, memory.md: onboarding paperwork for a day-one employee

Observe, act, evaluate, repeat, with the three loops built on it

One brand, four products: IDE, CLI, SDK, chat, plus the slash-command loop kit

The empty phone: the runtime ships bare; documents and skills make it an agent

Intelligence layer + execution layer: the seven documents around the agent

One visible message, seven invisible drains

Lead agent routes; each specialist is a folder with its own documents and model

Permissive to weak copyleft to strong copyleft: what each demands back

The DJ-mixer: training sets the knobs, fine-tuning nudges, quantization rounds

Five locks plus two prompt lines: the security floor for vibe-coded apps

Commit, build, release, watch, rollback: the loop that makes shipping safe

The five parts of an eval, mapped to the driving test that teaches them

The six-step loop — and every fixed bug becomes a permanent dataset row

The pizza-restaurant model of branch, PR, merge, and fork

Pay for the plan once, execute with the cheap model many times, review on its own branch