Claude Duet Is a Robot Assistant: Where VAs Still Win

Claude Duet is Anthropic's new app that works like a robot assistant: it briefs you every morning, keeps an eye on your inbox and calendar, and asks before it sends anything. If you're a VA, that reads a lot like your job description. It doesn't replace you, and below I'll show you exactly where you still win.

Quick note first: I haven't used Claude Duet. Almost nobody has yet, because it's a research preview with a waitlist. So this is an explainer built from Anthropic's own pages, not a review.

What Claude Duet Actually Is

Anthropic opened Claude Duet on October 21, 2026, as a research preview. That means an early version they're still testing with real users.

It's a separate app for iPhone and Android, and you can also open it on claude.ai. Anthropic calls it "a proactive agent." An agent is an AI that can take actions on its own, not just answer questions. Proactive means it comes to you first instead of waiting for you to type.

Who can get it right now: Claude Pro and Max subscribers in the US, through a waitlist. The FAQ says Team and Enterprise plans are "not included yet."

What It Does All Day

Each morning it sends a short brief on the most important things across your connected apps. After that, it checks those apps every few hours and messages you only when something needs you. Anthropic says it doesn't check nonstop because that would use up your plan's limits much faster.

You can also hand it tasks by text or voice, all in one ongoing thread. The announcement gives examples like finding Gmail and Slack messages you missed, checking QuickBooks or Stripe for unpaid invoices and drafting reminders, preparing payroll in Gusto, and drafting follow-ups from HubSpot. It works on its own computer in the cloud, so your laptop doesn't have to be on.

One early user, Lydia Hallie, whose X bio says she works on Claude Code at Anthropic, posted that she has it "watch Slack/email/cal and only ping me when it matters." She works at the company that makes it, so read that as an insider's setup. The post still got 1,049 likes.

The Rules It Can't Break

This is the part I'd read twice if I were a client.

Before Claude Duet sends a message, makes a payment, signs a document, or deletes anything, it shows you exactly what it's about to do and waits for your OK. Some things are off-limits even if you say yes, like trading securities or moving money between accounts.

Anthropic's safety post, published two days later, adds that it never sees your passwords. When a site asks for one, you type it into a form inside the app, and it goes to Duet's cloud browser without passing through the AI.

Where a VA Still Wins

Anthropic is upfront about the limits. Its own FAQ says Duet "may misread a thread or miscalibrate what's urgent," and it can miss something that arrives between check-ins. The announcement also says personal errands, like booking tickets, "aren't quite as strong" yet.

That's your gap. Knowing which email is actually urgent comes from months of context: which client panics, which "quick question" is really a fire, which Tuesday is already packed. A check every few hours doesn't have that.

And because Duet stops and asks before it sends, pays, signs or deletes, someone has to look at each request and say yes or no. For a busy founder, that someone could be you.

What This Means for VAs

Anthropic says it built Claude Duet for "professionals and small business owners with more on their plates than they can track." That's exactly who most of us work for. So expect a client to ask, "Do I still need you if I have this?"

Here's how I'd answer. A tool like this flags and drafts. You decide, follow up, and fix what it misreads. If your client gets access, offer to set it up with them: connect only the apps it needs, tell it what counts as urgent for this business, and review its morning brief together for the first two weeks.

That's a new service on your menu, not a lost job. If you're in the US on Pro or Max, you can join the waitlist on the Claude Duet product page and learn it before your clients do.

If a client has already asked you about tools like this, tell me what they said on the comments below.

1Password for Agents: AI Logs In, Never Sees Client Passwords

1Password for Agents lets an AI agent log in to a website for you without ever seeing the password. The agent asks, you approve in 1Password, and 1Password types the login straight into the site.

If you've ever been tempted to paste a client's password into an AI chat so it can "just finish the task," this is the safer way. Here's how it works, who can use it today, and what I'd tell a client.

The Problem It Solves

An agent is an AI that does tasks on its own, like filling in a form or checking an order status, instead of only answering questions. Agents are getting good at this. But the moment one hits a login page, it stops.

1Password's announcement on October 22, 2026, describes the two bad options you have today. You take over and type the password in yourself every time, which is slow. Or you paste the password into the prompt, which gives the agent your login "potentially beyond the task at hand."

The post also points out that agents can't use passwords saved in your browser or written in notes. So without something like this, you keep getting pulled back in.

How 1Password for Agents Works

When the agent reaches a login, it asks for the credential it needs. You get the request in 1Password, check which login it wants, and approve it. Then 1Password fills in the username and password directly on the site. The agent never gets the password or the one-time code.

In 1Password's own example with Muse, you pick which login the agent can use, and it doesn't get anything else in your vault. You can also disconnect the integration at any time.

There's a nice side effect for anyone who changes passwords often. Your logins stay in one vault, so when a password changes, you update it once and every connected agent uses the new one.

Which AI Agents Work With It

Not all at once, and this is where I'd be careful with clients.

Two integrations are "rolling out over the coming days": Muse from Meta, and Grok Bot from SpaceXSI. Anthropic's Claude Duet, OpenAI's ChatGPT Work and dots, and Townie from Town are "coming soon." A longer list, including Perplexity, Browserbase, Browser Use and Ramp, is also marked "coming soon."

1Password adds that "the safeguards and controls vary by integration." So check each agent's own setup before you rely on it.

Is It Free?

For many people, yes. 1Password says it's available "at no additional cost" for Individual and Family accounts on 1Password.com.

Two limits. Accounts on 1Password.eu or 1Password.ca aren't currently supported. And the post only mentions Individual and Family accounts, so don't promise it to a client whose team uses a 1Password Business account.

What This Means for VAs

More clients are going to want an AI agent set up for them. Logins are the scary part of that job, and now there's a clear rule you can offer: the agent asks, a human approves, and nobody pastes a password anywhere.

Here's how I'd put it in practice. Write one line into your client SOP (standard operating procedure, your written how-we-do-things doc): "AI agents get logins through 1Password approval only, never a pasted password." Then list which agent the client uses and whether it's live yet or still "coming soon."

If your client is waiting on Claude Duet or ChatGPT Work, you have time to tidy their vault first. Remove old logins and name items clearly, so the right one is easy to spot when an approval request comes in.

You become the person who makes the AI safe to use. That's a skill clients will pay for.

If you're setting up agents for clients, tell me which one they picked.

Can Claude Make YouTube Videos? I Made a 4-Minute One

Yes, it can. This week I made a full 4-minute YouTube video with Claude: the research, the script, the voice, every scene, and the thumbnail. But it didn't happen the way most people imagine, and the part that surprised me most wasn't the video at all.

Here's exactly what Claude did, what I did, and what I'd tell any VA who wants to try it.

First, What "Making a Video" Meant Here

Claude didn't press a magic "make video" button. There's no camera and no AI-generated footage in this video.

I used Claude Code, the version of Claude that can run tools on your computer, not just chat. It wrote the video as a set of animated web pages, then recorded them frame by frame into an MP4. Think of it like building slides that move, then filming them.

The video is for my small test channel, The 1% Mindset. The topic: a new AI model that guesses an answer 93% of the time when it doesn't know.

How It Went, Step by Step

Research. I asked Claude to dig into the topic. It sent several research helpers out at once, then a separate set of fact-checkers who opened every source again. They checked 194 claims. Four were wrong, and none of those made it into the script.

Script. Claude wrote a 4-minute script in plain English, then checked its own opening against a retention checklist and rewrote the first lines. I read it and signed it off before anything else happened. That's the same job I'd do for a human writer.

Voice. The voice-over comes from Kokoro, a free voice model that runs on my laptop. Claude split the script into sections, voiced each one, then transcribed the audio back to check that every word came out right.

Visuals. Every chart and post you see is a real screenshot of the source. Claude added the red hand-drawn circles and underlines, timed to the voice. The only made-up art is the cartoon test sheets and bunny from the thumbnail, plus a few simple bar graphics.

Thumbnail. Claude wrote the prompt for Nano Banana 2 (Google's image model), then added the "100% SURE" text on top.

The final file: 4 minutes 12 seconds, full HD.

What Surprised Me

The checking. After the render, Claude pulled a frame from every 2 seconds of the video and looked at all of them, like a very patient editor.

It caught real mistakes. One red circle sat on the wrong bar of a chart, because the website had shifted its layout after the screenshot. Another section sat empty for 8 seconds. Both got fixed before I ever saw the video.

On a second video, it caught something worse: a screenshot that showed numbers we hadn't been able to verify. It cropped them out. As someone whose job is getting details right for a client, that's the part that won me over.

Is It Free?

Not completely. Claude Code needs a paid Claude plan. The voice model is free, and the thumbnail image costs a little through Google.

Time is the bigger cost. This took most of a day, with me reviewing at every step. It's still a fraction of what one person would need to research, write, voice, animate, and edit the same video by hand.

What This Means for VAs

If you manage YouTube for a client, this changes what you can offer. You don't need to be a video editor to turn a script and real sources into a clean explainer, a Short, or a slide-style video.

But notice who made the decisions. Claude did the heavy lifting, while I picked the topic, approved the script, chose the look, and said no when something felt off. That's still VA work. It's just a bigger version of it.

Start small. Ask Claude to turn one of your client's blog posts into a 30-second Short script, and see how much of the rest you'd want to hand over.

If you try it, tell me how it goes on the comments.

Putting Jev to work: a router that decides where your prompt goes

 The first two Jev videos were about what the thing is. This one builds something with it — a model router you run on your own machine.

The setup is a Next.js UI talking to a local FastAPI server. Every prompt goes to Jev first, and one call asks three questions at once against the same state:

• choice — what kind of task is this? Chit-chat, simple question, rewrite, code, reasoning, image.
• score — how much model capability does a good answer actually need? Trivial ("a 2B model handles this") through to frontier.
• noul — does this contain personal, client, financial, medical or credential data?

Because all three evaluate in parallel, asking three costs about the same time as asking one. What comes back is just numbers, so the routing is ordinary if/else. Chit-chat goes to MiniCPM5 2B running locally. Code goes out to DeepSeek V4.1 Flash on OpenRouter. An image request goes to Qwen Image 2.1, also local. Privacy above 0.5 and the whole thing stays on the machine regardless of everything else. Hard work escalates a tier — Opus 5 if it's switched on. And when confidence comes back low, the router doesn't guess, it falls back to a safe default.

The numbers are the interesting part. A "how's it going?" prompt was judged in 331ms, difficulty zero, routed local. Drop in a fake API key and privacy comes back at 0.96 and it never leaves the machine. Over a session of 53 requests, 75% were answered locally — and a full run of demos cost under one cent.

There's an honest flaw he flags before building: if you send the prompt to TypeSafe to ask whether it's private, you've already leaked it. So the second half swaps Jev out for SemIf running locally. Same decisions, same shape, 88ms, nothing leaves the box.

That's the real takeaway. Once the decision layer costs almost nothing and answers in under 100ms, you can rethink how agentic systems are structured — put a fast gate in front of everything and only spend real money when the gate says you have to.

SemIf — https://github.com/TheoLeeCJ/SemIf

Bespoke Nimble 9B — https://huggingface.co/bespokelabs/Bespoke-Nimble-9B

Decider — https://github.com/Mapika/decider

Alex Wortega's OpenJev — https://huggingface.co/AlexWortega/openjev

DiffusionGemma (vLLM PR) — https://github.com/vllm-project/vllm/pull/57250

NanoJev — https://github.com/TianyuCodings/NanoJev

Layla — https://github.com/NandhaKishorM/laya

Jev, and the week everyone cloned it

 For two years every frontier lab has been pushing in the same direction: reasoning. Longer chains of thought, bigger thinking budgets, models that will happily sit there for minutes before answering — and won't show you the chain of thought you paid for.

That's System 2 thinking, in Kahneman's terms. Slow, deliberate, effortful. But most decisions that actually sit inside software aren't System 2 problems. What kind of support ticket is this? Is this urgent? Did the agent's output break a rule? Those are gut calls. You shouldn't need 30 seconds for them, let alone two minutes.

A lab called TypeSafe AI just came out of stealth going the opposite way, with System One models and a model called Jev. You can't chat with it at all. It doesn't generate text. The founder, Diogo Almeida, was a lead author on the InstructGPT paper that made models good at talking to people, and his argument now is that chat is the wrong interface for software. Software doesn't want a paragraph. It wants a value it can use.

So you pass in a state — a ticket, a log, an agent trace — plus typed questions. Only three kinds: choice (pick one of these options), score (rate on my scale), and noul (yes/no, with a probability). What comes back is typed answers with real probabilities, in 70–500ms. Output tokens are free; input is four cents per million. Think of it as an if statement that understands language.

The honest caveats: there's no paper and no architecture diagram — just three hints (new architecture, parallel sampler, and RLCD, reinforcement learning for calibrated decisions). "Can't hallucinate" really means it can't break your schema. It can still be wrong.

Then the interesting part. Within 24 hours of that video, open replications started appearing — now 20 to 30 of them, and some are close. On JevBench, Jev scores 75.3 and SemIf — a frozen Qwen 3.5 4B with no training at all — sits right behind it. Everyone converged on the same trick: read the logits over the answer tokens and softmax, no sampling.

The gap is still real on hard, multi-hop work. The move there is a cascade — fast model first, escalate only when confidence drops.

How to Cut Your Fable Bill by 50–90% (Lessons From Someone Who Burned $1,486 in 4 Hours)

 Fable is back, it's brilliant, and it will happily drain your wallet. One creator spent over $1,400 in the first four hours after release — deliberately — to stress-test which token-reduction strategies actually work. I went through the whole breakdown, and the good news is most of the savings come from a handful of simple habits. Here's what stuck with me.

The core insight running through all of it: token management is context management. Almost every dollar wasted goes to Claude reading things it didn't need to read.

1. Minify tool output (RTK)

Claude Code runs tool calls constantly — hundreds or thousands per session — and the raw output is full of repeated noise: stdout, stdout, stdout, fixture setup lines, boilerplate. A tool called RTK (Rust Token Killer) strips and reformats tool inputs/outputs down to what the model actually needs. In the demo, one tool call went from 612 lines (36,700 characters) to 4 lines (177 characters) — a 99% reduction on that call. Not every call is that bloated, but across a real session you can expect 30–50% savings with zero quality loss.

2. Semantically compress your CLAUDE.md

Most system prompts and memory files are padded with pleasantries that carry zero information. "Hello, thank you so much for helping out with this project, we really appreciate..." compresses to "Project instructions and guidelines." Same meaning, fraction of the tokens. The demo took a CLAUDE.md from 865 words to 211 — roughly 1,125 tokens down to 274. Run this pass on every project's system prompt and memory files. Bonus: tighter instructions often produce better output, not just cheaper output.

3. Never let Claude read logs raw

If Claude needs to dig through a 5,000-line log file, don't let it read the file. Load the log into SQLite and give Claude a small query script instead. It finds the root cause — with exact line numbers — by running a query rather than eating thousands of lines of text. The same principle applies to CSVs and Google Sheets: query, don't read.

4. Block huge reads generally

Some files are just too big to read start to finish, and most never needed to be. A good pattern: have Claude sample the beginning and end of a large file, infer the structure, then use sed, grep, or a search function to jump straight to the relevant region. Instead of 20,000 lines, it reads 20 or 30. On large-resource tool calls, that's ~99% saved.

5. Prompt in English

English is unusually information-dense per token. The same query cost 51 tokens in English, 87 in Italian, 118 in German, 74 in Japanese. (Mandarin is a notable exception — symbolic characters are token-efficient.) Most models are also trained predominantly on English, so you're not trading quality away. If you work in another language, this alone can be a 20–80% swing.

6. Add context frugality rules

Bake frugality directly into your CLAUDE.md: read only files directly relevant to the task, ask before expanding beyond three files, prefer glob/grep to locate then read the region, never read generated files or fixtures unless asked. One caveat — this is the only tactic on the list that can hurt quality, because you're constraining where the model looks. The trade: be more specific in your prompts, pay less.

7. Audit your context regularly

Run /context periodically. Things creep in silently — the creator discovered he was running a dozen Chrome MCP instances simultaneously, each loaded with full context, bloating every request and confusing the model. System prompt, tools, memory files, and skills can quietly eat 8%+ of your window before you've typed a word. A neat trick: set up a looping watcher instance that snapshots your context daily and flags anything new.

8. Cap your thinking

Adaptive thinking tends to overspend. In a head-to-head bug-hunt test, low thinking found the bug in 7 turns and 1,028 output tokens; extra-high found the same bug in 9 turns and 1,363 tokens — typically closer to 1.5x over repeated runs. With a model as capable as Fable, default to low thinking and opt into big budgets only when a task demonstrably needs them. That's a 30–40% saving on its own.

Agent Loops, Explained Simply (And Why They're Not Magic)

 There's a lot of buzz online lately about "agent loops" and "loop engineering," with some people claiming you shouldn't even prompt your AI anymore — you should build systems that prompt it for you. A recent video does a nice job cutting through the hype and explaining what this actually means. Here's a plain-English version, plus an honest take on what's useful and where the hype gets ahead of reality.

What's an agent loop?

Strip away the jargon and a loop is simple. Instead of asking the AI to do something once and accepting whatever comes back, you let it repeat a cycle: reason (figure out what to do), act (do it), and observe (check the result). It keeps going — adjusting each time — until it hits a goal you've defined, then stops and tells you it's done.

The video compares it to a smart intern you don't micromanage. You hand them a goal and a clear definition of "finished," and they figure out the steps, check their own work, and only come back when it's actually done.

A loop really comes down to three things: a trigger (what starts it), an action (what it does), and a stop condition (how it knows to quit). And two pillars matter most — a clear goal and a way to verify progress.

Why this is genuinely useful

The big insight is that AI rarely nails something on the first try. Normally you would look at the output, give feedback, and ask for changes — over and over until it's good enough. A loop just hands that tedious back-and-forth to the AI itself, so it arrives much closer to "good" before it ever shows you the result.

In the video, the creator builds things this way: thumbnails scored against a rubric, a 3D plane that the AI repeatedly renders and inspects, even video edits where the AI cuts pauses and checks its own timing. The magic of "I did this in one prompt" is usually just a well-designed loop with verification baked in.

Where the hype gets ahead of reality

Here's the refreshing part of the video: most tasks don't need elaborate loops. You don't need five agents running 24/7 commanding other agents. The creator admits that for his own knowledge work, a single agent with a good prompt does the job most of the time, and that round-the-clock "swarms" mostly make sense for full-time coders building software.

The honest takeaways worth remembering:

• Loops aren't meant to deliver 100% perfect output — they just get you much closer, faster. In the video, the AI's attempt to recreate a famous photo in code still came out looking nothing like the original.
• A loop is only as good as its "done" check. Vague criteria like "until you're satisfied" lead to vague results; the best loops aim for something measurable.
• Just because an expert online does it doesn't mean you should. AI shows up differently in every job — staying informed isn't the same as copying someone else's setup.

The part that stays human

Notice what you still own in all of this. You define the goal, and you decide how "done" gets verified. The video is blunt that AI is never perfect and a loop without a good verification check just produces polished-looking mistakes faster. Some runs even went 12 hours and weren't useful.

So the human role doesn't disappear — it moves up a level. Instead of correcting every draft, you're designing clear goals, sensible stop conditions, and real checks — and reviewing the final result before trusting it.

The bottom line

Agent loops are a genuinely smart idea: let the AI handle its own feedback-and-iterate cycle so you get better results sooner. But they're a tool, not a miracle. Start simple, define "done" clearly, and keep checking the work — because a loop will happily repeat a mistake until you tell it not to.

Anthropic Just Made Claude Agents Boring. That's the Whole Point.

 The flashy AI announcements get the headlines — new model, higher benchmark, longer context. But if you've ever tried to actually deploy an agent inside a company with a security team, you know the model was never the hard part. The hard part is the question every CISO asks in the first meeting: how does this thing touch our systems without becoming the breach we read about next quarter?

On June 18, Anthropic answered the last open piece of that question. And the answer is delightfully unglamorous.

The news: identity finally caught up

Anthropic shipped Enterprise-Managed Authorization for Claude's MCP connectors. In plain terms: an admin provisions a connector once through the company's identity provider, and every employee inherits access automatically on first login. No individual OAuth consent screens. No "click allow" forty thousand times across the org. When someone leaves or changes roles, their connector access gets revoked alongside every other app — because it's governed by the same identity rules.

Okta is the first identity provider, using its Cross App Access plumbing. The connectors live at launch: Asana, Atlassian, Canva, Figma, Granola, Linear, and Supabase, with Slack rolling out. It's in beta, Team and Enterprise plans only.

If you've never run IT for a large org, this sounds like a footnote. If you have, you know it's the difference between "we piloted it with five people" and "it's live for the whole company."

The two pieces this builds on

Here's the context most of the recap posts are getting wrong: this isn't a standalone drop. It's the capstone on two features Anthropic shipped a month earlier, on May 19. Together the three are the actual enterprise story.

Self-hosted sandboxes (public beta) moved tool execution out of Anthropic's infrastructure and into an environment you control — your own infra, or a managed provider like Cloudflare, Daytona, Modal, or Vercel. The clever bit is the split: the agent loop that handles orchestration, context, and error recovery stays on Anthropic's side, but the code actually runs inside your perimeter. Your files don't leave. Your network policies and audit logging already apply. You set the compute.

MCP tunnels (research preview) solved the other half. Your agents can now reach MCP servers sitting inside your private network without exposing them to the public internet. A lightweight gateway you deploy makes a single outbound connection — no inbound firewall rules, no public endpoint, encrypted end to end. Your internal Postgres, your private APIs, your ticketing system become tools the agent can call, and none of them ever face the open web.

Why the trio matters

Line them up and you can see the strategy. The classic enterprise objection to AI agents has always been some version of "we can't let an external service into our internal systems." Anthropic just dismantled that objection at three different layers at once.

Tunnels mean no public endpoint and no VPN exceptions. Sandboxes mean code execution never leaves your walls. And enterprise-managed auth means access is provisioned and revoked through the identity system you already trust. Each one removes a specific veto that a security team can throw. Stack them and the "no" gets very hard to justify.

That's the real shift here. The bottleneck for enterprise AI was never reasoning quality. It was governance, and governance is exactly what this release is about.

The honest caveats

I'd be doing you a disservice if I made this sound finished. MCP tunnels is still a research preview — you request access, it's not broadly available. Self-hosted sandboxes is public beta, which means it's real but you should expect rough edges. And the enterprise-managed auth is beta, Team and Enterprise only, with Okta as the sole identity provider for now. If your stack runs on a different IdP, you're waiting.

So this is a direction, not a finished product. But it's the right direction, and it's further along than anything comparable from the other labs.

The takeaway

This release won't trend the way a new model does. There's no benchmark to screenshot. But if your job is getting agents past a security review and into production, this is the most important thing Anthropic has shipped this quarter. They made the deployment story boring — predictable, governable, auditable — and boring is precisely what enterprise buyers have been waiting for.

The model was always good enough. Now the plumbing is catching up.

Building an Affiliate Marketing Business with AI: An Honest, Friendly Look

 There's a video making the rounds where someone claims to build an entire affiliate marketing business in about an hour — a website, Pinterest pins, an email system, even the emails themselves — using Claude plus an AI tool called GenSpark. It looks almost magical. So is it real, and should you try it?

Here's a plain-English take on what's genuinely great about the idea, what's harder than it looks, and the one habit you can't skip.

The idea in a nutshell

Affiliate marketing just means promoting someone else's product and earning a commission when people buy through your link. The video's plan is simple: pick a niche (say, kitchen gadgets), build a clean website with AI, add an email signup with a free guide, and create eye-catching Pinterest pins that send curious people to your site. AI does most of the heavy lifting — writing, designing, and even building the website from a single prompt.

What's genuinely good about it

The biggest win is speed. Things that used to take days — designing a website, writing emails, making pins in Canva — can now come back in minutes. For someone starting out with no budget for a designer or developer, that's a real head start.

It's also more approachable than ever. You describe what you want in normal language and watch the website build itself, with no code to touch. And the underlying strategy is sound: sending people to your own site and capturing emails (so you "own" your audience) is smarter than dropping raw affiliate links on social media and hoping.

Finally, it's easy to experiment. Once you've built one funnel, you can repeat it across niches and see what sticks.

What's harder than the video makes it sound

A polished website is the easy 10%. The hard 90% is getting actual people to visit — and that part the video mostly skips. Pinterest, traffic, and steady sales take time, consistency, and a bit of luck. Most affiliate sites earn little or nothing for a long while.

There are also rules you have to follow, not optional extras. Amazon and other programs require you to clearly disclose that your links are affiliate links, and they have strict terms you can get banned for breaking. AI won't handle that compliance for you.

And be skeptical of the "people are making money with this" framing. Real money is possible, but these videos rarely show the failures, the months of effort, or the fact that the easiest person to make money is often the one selling you the tools.

The rule you can't skip: check everything yourself

This is the part to underline. AI makes mistakes, and a human always needs to review the work before it goes live.

AI will confidently invent product details, quote wrong prices, recommend items that are out of stock, or write claims about a product that simply aren't true — and it sounds just as sure when it's wrong. In affiliate marketing, that's not just embarrassing; misleading claims can break platform rules or even consumer-protection laws.

So treat every output as a first draft. Before anything is published, verify each product, price, and link is real and current, read every email and pin for accuracy and honest claims, and make sure your affiliate disclosures are clearly visible. You are the editor and the one responsible for what your audience sees — not the AI.

The bottom line

The tools really can collapse hours of work into minutes, and that's exciting, especially if you're not technical. But building the site is the beginning, not the business. Go in with realistic expectations, follow the disclosure rules, and keep a human firmly in the loop. AI can do the building — you do the checking.