What breaks, written down.

Every episode ships with its own limits section — the part most tutorials leave out. This is all of them in one place: 105 documented so far, across 38 episodes.

Episode 38 — Just ten seconds of your voice is all AI needs to clone it now — and scammers are already using it.

A safe word stops the specific 'fake emergency call' scam pattern described here — it doesn't protect against every kind of scam or fraud.
This only works if it's actually agreed upon in advance and everyone involved remembers it exists — it protects nothing if only one person set it up.
This episode covers the voice-cloning phone-scam pattern specifically, not broader AI-deepfake risks (video, images) which use different mechanisms and defenses.

Episode 37 — Every photo you've ever taken in Google Photos has already been looked at by AI — before you ever asked it to.

The exact toggle wording and menu path can vary by app version, region, and account type (personal vs. Workspace) — this guide describes what to look for, not a guaranteed identical screen for every viewer.
Turning off human review of your queries does not delete or undo the AI's existing analysis of your photo library — there is currently no publicly documented Google Photos setting that reverses that.
This episode covers Google Photos' Ask Photos specifically, not Google's broader AI/Gemini data policies across its other products.

Episode 36 — Every private thing you've ever typed into ChatGPT trains its next model — and that's the default.

Turning the toggle off is not retroactive — anything sent before you turned it off may already be part of a training run and cannot be pulled back out by this setting.
Temporary Chat still stores the conversation on OpenAI's servers for up to 30 days for safety monitoring before permanent deletion — it skips history and training, not all server-side storage.
This episode covers OpenAI's ChatGPT specifically; other AI tools (Claude, Gemini, etc.) have their own separate data-training settings, not covered here.

Episode 35 — An automation built in n8n can already say "done" — and still do the exact same thing again.

This stops duplicate runs caused by a slow reply; it does not protect against a sender that retries for a different reason (e.g. its own network error) — de-duplication is the real fix for that, not response timing alone.
Moving the reply earlier means the caller can no longer see the workflow's own output in that response — if the caller genuinely needs the result synchronously, this tradeoff needs a different design (e.g. polling a status endpoint).
This does not undo damage from duplicate runs that already happened — check for and clean up any real double-sends before assuming the fix alone is enough.

Episode 34 — Your n8n node runs once for every item you send it — not once, total.

This explains and manages per-item execution; it doesn't remove real per-call cost or rate limits — batching controls the pace, it doesn't make the calls free.
Batch size is a real tradeoff: too large risks hitting a rate limit anyway, too small barely helps — the right number depends on the specific API's own limits.
Test with a set close to your real production volume before trusting a workflow at scale — 3 test items behaving fine says nothing about 300.

Episode 33 — Nothing's wrong with your n8n AI agent. It's forgetting on purpose — once per 5 messages.

A larger context window means a longer, more expensive prompt on every message — there's a real cost/quality tradeoff, not just 'bigger is always better.'
This fixes forgetting within the configured window; it does not give the agent persistent memory across completely separate sessions unless the memory node itself is set up for that.
Postgres/Redis memory requires that datastore to already be reachable from your n8n instance — this is a bigger setup step than Simple Memory's zero-config default.

Episode 32 — By default, n8n never tells you when a workflow dies.

The Error Workflow has to be set per-workflow (or applied to all active workflows via n8n's own template) — it is not automatically on for every workflow in an account by default.
This tells you a workflow failed; it doesn't diagnose why on its own — the Error Trigger's output data (the error message, the failing node) is what you use to investigate.
Test on a duplicate or test workflow first — deliberately breaking a production workflow to test this is not worth the risk.

Episode 31 — ChatGPT needs the internet to respond. This AI doesn't — and it just proved it.

The one-time model download does need real internet — this is an offline-after-setup tool, not a zero-download one.
A modern laptop with 16GB RAM comfortably runs 7-8B parameter models; larger models (Llama 4, some Qwen 3 variants) need considerably more.
Model names move fast — this episode uses llama3.2, the current official quick-start model as of this episode; check ollama.com's model library for the current recommended default before assuming an older name (llama3, phi3) is still the best starting point.

Episode 30 — AI chats love padding the answer before they actually answer you.

It resets every new conversation — this is not a persistent account setting like ChatGPT's Custom Instructions, so it has to be pasted again in each new chat.
For questions that genuinely need nuance (medical, legal, anything where a caveat actually changes what you should do), the instruction already tells the AI to keep caveats that "change the answer" — but always read past the first sentence when the topic actually calls for it.
Not tested identically across every model version — behavior demonstrated on ChatGPT; the underlying mechanism (instruction-following) is standard across current chat models, but exact phrasing sensitivity can vary slightly between them.

Episode 29 — Right now, your n8n workflow can fail completely — and still say "Success."

This is about the "On Error: Continue" and "Continue (using error output)" settings specifically — a node left on the default "Stop Workflow" behaves as expected and does flag the workflow as failed.
The fix shown (an IF node checking for an error field) has to be added to every node you've set to Continue — it isn't a global setting that protects a whole workflow at once.
Verified against n8n's current official docs and community reports as of this episode, not personally re-tested against every n8n version — if n8n changes this behavior in a future release, re-check before relying on this exact setup.

Episode 28 — Four rows in my database started with "test_". Only three of them were real test data.

This one test showed correct judgment on one specific, well-commented trap — it isn't a guarantee that every ambiguous instruction gets caught correctly on every codebase, especially one with no explanatory comments at all.
Free-plan accounts can't run this at all without upgrading first — the $20/month claim is specifically about Pro-and-up, not every Claude account.
Working on a git branch only protects code already in a git repository — it does nothing for a request made directly against a live database or production system with no version control.

Episode 27 — I told Claude Code the wrong bug. On purpose.

This one test showed the tool looking past a wrong description on one small, clear-cut bug (an operator-precedence mistake) — it isn't a claim that every wrong description gets caught on every bug, especially subtler or more ambiguous ones.
Free-plan accounts can't run this at all without upgrading first — the $20/month claim is specifically about Pro-and-up, not every Claude account.
Needs a real project folder and an actual broken file to point it at — it doesn't diagnose a bug from a description alone with no code to read.

Episode 26 — This is a real AI model. My WiFi is off.

Ollama separately offers optional paid cloud tiers for cloud-hosted inference — this episode is about the free, local, offline path specifically, not Ollama's whole product line.
A small local model won't match the biggest paid models on hard reasoning tasks — the claim here is a real, private, free, offline assistant, not a like-for-like replacement.
The first ollama run of any model needs an internet connection to download it once — "offline" describes every run after that, not the very first one.

Episode 25 — Your n8n retry doesn't just try again. It can do the exact same thing twice.

This protects against an exact retry of the same input — it does not fix a different, genuine failure elsewhere in the workflow.
The lookup step needs a real, persistent store (a Sheet, Airtable, or a database) — n8n's own in-memory workflow data isn't guaranteed to survive a restart on every hosting setup.
Adds one Code node, one IF node, and one write-back node per external call that needs it — it isn't free, and skipping it on even one call leaves that one unprotected.

Episode 24 — Editors squeeze the picture to fit the audio. We do the opposite.

This does not fix a bad recording — if the narration itself is rushed or unclear, matching cuts to its pauses just preserves that pacing exactly as-is.
Doing this by hand, clip by clip, is slower than a fixed-slot template — the payoff is fewer overlaps and cut-off words, not less editing time.
This channel's own version (retime.py) automates the matching across an entire script at once; doing it manually in a general editor means finding each gap yourself, one at a time.

Episode 23 — 22 episodes in, one file keeps this from breaking.

The file only helps if it names real, specific mistakes — a vague wishlist ("write good code," "be careful") gives an agent nothing concrete to check itself against.
It's read once at session start, not enforced like a lint rule — nothing physically stops an agent from breaking a written rule anyway. What it removes is the excuse of not knowing the rule existed, not the possibility of a mistake.
The exact install command shown here can change as Claude Code updates — re-check code.claude.com/docs if this episode is more than a few months old.

Episode 22 — n8n's AI Agent can lie to you — and still show green

This is a design characteristic of n8n's current AI Agent node, confirmed as unresolved as of this episode's publishing (one fix proposal was closed "not planned" in March 2026) — re-check n8n's own GitHub if this episode is more than a few months old.
The fix adds real setup work per tool, per agent — it does not come free, and skipping it on even one tool leaves that one silent.
This episode covers one specific, documented failure mode (a tool call failing silently inside an Agent) — not a general audit of n8n's reliability.

Episode 21 — Can an AI browser actually run your errands? We tested the real number

It does not reliably chain many steps together — a wrong turn early in a long task compounds, and everything after it goes wrong too. Shorter, single-purpose tasks are where it's actually reliable today.
A paid "background assistant" tier exists for running tasks without watching them live — the free tier expects you to stay present and check in.
This episode names one specific browser (Comet) and one specific benchmark, both current as of publishing — re-check both if this episode is more than a few months old; this category is moving fast.
Not a security review: agentic browsers as a category have documented risks around a malicious page hijacking an agent's actions — this episode doesn't cover that side, only whether the everyday-task claim holds up.

Episode 20 — ChatGPT was going to buy things for you — then they quietly killed it

This isn't a criticism of ChatGPT generally — it's one specific, named feature (Instant Checkout) that launched and was retired within about six months.
Agentic checkout hasn't disappeared industry-wide — other players (Google, Perplexity) have their own versions; this episode covers what ChatGPT itself does today, not the whole category.
Check ChatGPT's own current shopping behavior if this episode is more than a few months old — this space is changing fast.

Episode 19 — Claude keeps your files now — not just this one chat

This fits recurring work with the same files and instructions — a one-off question doesn't need a project.
Files still count toward the model's context the same as anything else — a project doesn't make your files free to include.
Anthropic's own limits here can move — check Claude's current project settings if this episode is more than a few months old.

Episode 18 — ChatGPT can use a website now — not just talk about one

This is for tasks with a clear, checkable finish line (compare, look up, summarize across a few pages) — not open-ended research or anything where a wrong answer is costly and hard to catch.
It won't act inside an account you're already signed into — a task needing that isn't a fit for it.
Names and limits in this space change fast — OpenAI retired the previous "agent mode" without much notice days before this episode was recorded; check ChatGPT's own current mode picker if this episode is more than a few months old.

Episode 17 — One word can wreck a whole explanation.

This catches whether a sentence is understandable, not whether it's factually correct — a wrong but clearly-worded claim still needs separate fact-checking (see episode 15's own correction).
It works best with a second person; testing it on yourself only works if you can genuinely forget what you meant to say, which is harder than it sounds.
This rule caught real gaps in the back catalog too (episodes 3, 6, 7, 9, 10, 11 all had unexplained jargon or steps too vague to actually follow) — those have since been rewritten to the same standard, not left as an exception.

Episode 16 — Someone open-sourced our own video pipeline.

This is a tool for building videos with code/agent instructions — it doesn't replace a camera or footage of a real event; it's for the same kind of screen-recording-and-graphics video this channel already makes.
We tested a small, simple example, not a full multi-scene production — a longer, more complex video will take longer to render and may need more setup than shown here.
Open-source projects change; if a command in this episode no longer matches what you see, check the project's own current documentation rather than assuming this episode is still exact.

Episode 15 — Gemini fixes your broken formula, already built in.

This fixes mistakes in the instructions you write yourself — it doesn't know whether the numbers you typed in are correct, only whether the instruction is valid.
The exact wording and location of the Fix button can change as Google updates Sheets — if it isn't where this episode shows it, look for an error indicator on the box itself.
Not free for every account: Google's own rollout (June 2026) lists this for Business, Enterprise, Education, AI Pro and AI Ultra Workspace plans. On a personal Gmail account, the equivalent needs Google One AI Premium — check your own account's access before assuming it's there.

Episode 14 — Everyone's sharing this claim that AI always lies to please you.

Three tests on one model is evidence about that model in that situation, not a universal claim about all AI — a different framing or a different model could behave differently.
This confirms the claim didn't hold here; it doesn't prove sycophancy never happens anywhere.

Episode 13 — ChatGPT can recall things about you, even in a brand new chat.

It also applies to chats you'd rather it left alone — memory is per-account, not something you switch on per conversation.
This is memory of what you've said, not a guarantee of accuracy — it can carry forward something wrong just as easily as something true.

Episode 12 — Most people think Claude Code is only for programmers.

Starting with one big ask instead of one small change is where this goes wrong first — the discipline is the small-step part, not the tool.
It still needs you to check the result each time — describing a change and trusting it blindly is a different, riskier habit.

Episode 11 — AI narration has a flaw you can't consciously name — a word loses its ending, an S goes dull or too hot.

This measures against the narration's own median, not a fixed external standard — a whole file recorded badly could pass its own bad baseline.
It catches what it's built to measure — pacing, rate, sibilance, endings. It is not a general "does this sound good" check.

Episode 10 — Most leads go cold before anyone even replies.

This only helps if the split is actually correct — auto-sending something that needed a real decision is worse than a slow reply.
A draft nobody reviews is the same as no reply at all — the human step still has to happen.

Episode 9 — This agent can send emails by itself. It never does.

This slows down anything that genuinely needs to go out instantly — the trade is deliberate, not free.
It only protects the send step. A draft with a wrong fact still needs an actual human read, not just an approval click.

Episode 8 — A check said it passed. It lied.

Passing on one known-bad case doesn't prove the check catches every bad case — only that it isn't blind to that one.
This has to be repeated after any change to the check itself, not just after changes to what it checks.

Episode 7 — Your n8n agent doesn't know it's wrong

This only catches what the agent itself can flag as uncertain — it does not catch a confidently wrong answer.
"Route to a human" only helps if someone actually reviews that queue — an unread inbox is the same as no check.

Episode 6 — Three things your AI agent still breaks on.

These are three instructions, not three features — the agent still has no real memory, no login handling, and no undo. The lines only change what it's told to do about each.
None of this needs a rebuild, but it does need you to actually add the lines — an agent left on its defaults still has all three problems.

Episode 5 — Your captions are hiding behind Instagram

This is Instagram and TikTok's current UI. Platforms change their layouts, and the exact numbers can shift.
Decorative background elements can still use the full frame — only text and anything meant to be read needs to respect the safe box.

Episode 4 — This video almost shipped broken

Testing a check against a known-bad case does not guarantee it catches every bad case — only the ones like the one you tested.
This is a discipline, not a one-time fix. The three defects here happened after checks already existed; the checks just weren't checked.

Episode 3 — Your AI agent is already lying to you

One prompt line does not make an agent reliable. It changes what it reports, not what it can actually do.
Nothing here is unique to one platform — this is what the failure modes look like across every agent we've tested.

Episode 2 — What an AI agent actually is (not the marketing definition)

Agents do not fail like chatbots. A chatbot gives you a bad answer; an agent fails confidently, halfway through, having already done part of the work.
That is why the first one you build should touch something reversible — a draft, not a send.
Nothing here makes an agent reliable. It makes the word mean something, which is what the rest depends on.
The loop is the definition, not a product. Two tools can both have it and one can still be useless for your job.

Episode 1 — Your ChatGPT keeps giving you the obvious

It cannot browse the web and it cannot read your files — it changes how the model reasons, not what it can reach.
On a brand-new chat the first answer is sometimes still generic. Ask once more and it settles.
It is not a jailbreak and it does not raise any usage limit.
Custom instructions are per-account, not per-device: it follows you, and it also applies to chats you would rather it left alone.