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.

Can You Really Build a Whole AI Marketing Team? A Friendly Look at the Idea

 There's a popular video going around that promises something pretty wild: turn Claude into a full marketing team — five "agents" and a dozen "skills" — all working together to research, write, design, and even build landing pages for you. And the best part of the pitch? "Even if you're not technical, let's go."

It's a genuinely exciting idea. But before you dive in, here's an honest, plain-English take on what's great about it, what's tricky, and the one rule you should never skip.

What's the big idea?

Think of it like hiring a small team that never sleeps. You give the AI some "skills" (reusable instructions for tasks you do all the time, like making a branded slide deck or writing a blog post) and a few "agents" (specialists, like a data analyst or a content writer). Then you hand it a job — "launch our summer campaign" — and it produces research, social posts, images, and a landing page, mostly on its own.

In the video, it works impressively well. The decks follow the brand template, the images match the style, and the whole package looks professional.

What's genuinely good about this

The most appealing part is the time saved. Tasks that used to eat a whole afternoon — drafting posts, pulling a report together, mocking up a deck — can come back in minutes. For a small business or a solo marketer, that's a real gift.

It's also more approachable than it used to be. You're mostly talking to the AI in normal language, not writing code. And the idea of building reusable "skills" is smart: you teach it your style once, and it remembers. That consistency is hard to get when you're rushing.

Finally, it lowers the barrier to trying things. Want three versions of a campaign to compare? You can have them quickly, then pick what actually works.

What's not so easy (especially if you're non-technical)

Here's the honest part. The video says "even if you're not technical," but the setup involves downloading VS Code, installing tools, connecting "MCPs," and editing configuration files. That's a fair bit more technical than the friendly framing suggests. None of it is impossible to learn, but expect a real learning curve, not a five-minute setup.

There's also a cost to maintaining all this. Skills and agents need updating as your brand and goals change. And the more you pile on, the more you have to keep organized.

The rule you should never skip: check everything

This is the most important point, so I'll say it plainly. AI makes mistakes, and a human always needs to check the work.

Even in the video, the creator admits the result is "90% done" and that some charts still need fixing. That last 10% matters enormously. AI can confidently state facts that are wrong, invent statistics, misquote a source, or get your pricing or product details subtly off. It won't always tell you when it's unsure — it often sounds just as confident when it's wrong as when it's right.

So treat every output as a first draft, never a finished product. Before anything goes public:

• Fact-check the claims and numbers against a trusted source.
• Read it for tone and accuracy — does it actually sound like your brand, and is everything true?
• Double-check names, prices, links, and dates, which AI gets wrong surprisingly often.

You are the editor-in-chief. The AI is a fast, tireless assistant — not a replacement for your judgment.

The bottom line

Building an "AI marketing team" is a powerful idea, and the tools really can save you hours. If you're non-technical, go in knowing the setup is more involved than it looks, and start small with one or two simple skills.

Most of all, keep a human in the loop. AI can do the heavy lifting, but a person should always have the final read before anything reaches your audience.

I'm Stealing This AI Researcher's Workflow for My Own Projects

Karpathy doesn't use a fancy app to manage his research. He uses a folder, Obsidian, and an AI — and I want to copy it.

He posted about it last week. The short version: he dumps raw material — articles, notes, papers, images — into a folder, then lets a large language model (LLM — the AI brain behind tools like Claude or ChatGPT) build a wiki from it automatically. The LLM writes the summaries, creates the links between ideas, organizes everything into categories. He barely touches the wiki himself. When it gets big enough, he asks it questions and gets answers pulled from his own research.

I've been sitting with this for a few days, thinking about what it would look like for my work.

---

What My Work Actually Looks Like

I build things. Agents, content apps, Claude Code workflows, automation scripts. A lot of what I do involves figuring something out — what tool does what, how to wire two things together, what prompt pattern produces the right output, what broke last time and why.

Most of that knowledge lives in my head, or in scattered notes, or in past conversations I can't find anymore.

That's the problem. Every time I start something new, I spend time re-learning things I already know. What flags to use in Claude Code. What agent structure works for what kind of task. What API response format caused everything to break last month.

Karpathy's idea is simple: stop keeping that knowledge in your head. Dump it in a folder. Let the AI organize it. Ask it back when you need it.

—

The Specific Thing I Keep Thinking About

He mentioned that his wiki grows and gets more useful with every question he asks. He asks something, the AI goes through his notes and answers it — and then he saves that answer back into the wiki. So every session adds something. Nothing gets lost.

That hit me because the opposite is true for how I work right now. Every build session ends and most of the small things I figured out just disappear. The next session starts almost from scratch on some of the same ground.

If I had a knowledge base for my Claude Code workflows alone — prompts that worked, structures that didn't, patterns I figured out, error fixes — and an AI that could surface the right piece when I needed it, I'd stop repeating myself.

—

The Part That Actually Excited Me

He also runs "health checks" on his wiki. He asks the AI to find gaps, spot inconsistencies, and find connections between ideas he hadn't noticed yet. The AI suggests new things to look into.

That's the part I can't stop thinking about.

Not just a system that stores what I know. A system that notices what's missing. For someone building content automation apps, that means the system isn't just remembering what tools I've used — it's noticing when two things I built separately could be connected. It's pointing to the next piece.

That changes how building feels. Less like starting from zero every time, more like picking up a thread.

—

What I'm Going to Test

I'm starting with one folder. My Claude Code workflows — the scripts, prompts, notes, fixes, things that broke and how I solved them.

I'll ask Claude to read through everything and build an index: summaries of each file, links between related ideas, a map of what I already know.

From there, I'll ask it questions mid-project. "What pattern did I use last time for a multi-step agent?" "What was the issue I kept hitting with streaming output?" Instead of digging through old files or trying to remember, I just ask.

I'm not building the full Karpathy setup yet. I'm testing whether the core idea holds: does having a searchable, AI-organized version of my own work actually save time and reduce the re-learning?

I Told an AI to Build a Full Newsletter. One Sentence. No Code.

I used to spend half a day on client newsletters. Last week I did it in 15 minutes — and I'll show you exactly what I typed.

---

🤖 What Claude Code Actually Is

Claude Code is an extension you install inside VS Code — a free code editor. Once it's set up, you have an AI agent sitting inside your project that can read files, write code, call APIs, fix its own errors, and run automations — all through a chat window.

You talk to it. It builds things. That's the whole loop. You don't need to know how to code. You need to know what you want.

---

🧪 What I Actually Tested

I set up a project, gave the agent a brand logo and a color guide, connected a few API keys (one for research, one for Gmail), and typed one prompt. That was it.

What came back:

• Research pulled from live sources
• Three branded infographics generated with AI images
• Full HTML newsletter formatted to the brand's colors and fonts
• Email sent directly to a list via Gmail
• Sources linked at the bottom, clickable

It hit errors along the way. An API endpoint had changed. A Gmail formatting issue broke the layout. Both times, it found the problem, explained what happened, fixed the tool, and kept running. I didn't touch anything.

---

🏗️ How the Whole Thing Is Organized

The system behind this is called

Component	What It Is
Pipeline	The instructions, written in plain English — like a step-by-step recipe
Tools	The specific actions the agent can take (research, generate image, send email)
Orchestrator	Claude Code itself, reading the pipeline and running each tool in order

You also give it a file called CLAUDE.md — a standing brief that tells the agent what the project is, where things live, and what it's supposed to do. Every time you open the project, it reads that first.

Once you've built and tested a pipeline, you can schedule it to run on its own — every Monday morning, every time a form is submitted, whatever you need. At that point the agent isn't running live. The code it built is. It runs predictably, like any other automation.

---

💼 What This Means for VAs and Small Business Owners

You don't need to learn to code. You need to be able to describe a process clearly.

If you manage newsletters, reports, client updates, or social content for clients — build a pipeline, test it once, let it run. If you spend hours every week on the same repetitive tasks in your own business, same idea.

What makes this different from something like Zapier is what happens during the build. The agent adapts. It hits an error, investigates, fixes the tool, and updates the instructions so the same thing doesn't break again. The final automation is more reliable — and you got there faster than mapping every node by hand.

---

💰 If You're Thinking About Offering This as a Service

Businesses aren't paying for a pipeline or a blueprint. They're paying for a solved problem.

Don't open with "do you want AI automation?" Ask: where are you losing the most time or money right now? Find that, build the thing that fixes it, and price it on what it's worth — hours saved, errors cut, costs gone — not on how long you spent building it.

A pipeline that saves a client 20 hours a week isn't a half-day job. Over a year, that's tens of thousands of dollars in time they're not paying someone else to cover. Price it that way.

---

🚀 Where to Start

Tool	Claude Code — runs inside VS Code (free to download)
Cost	Paid Claude subscription — $17/month on the Pro plan
Setup time	~1 hour, most of it connecting API keys

Pick one task you do every single week. Something repetitive, something predictable. Let the agent build the first version, watch it run, fix what doesn't land, and build from there.

The hardest part isn't the tool. It's deciding what to automate first. 

This Paper Says We've Been Fine-Tuning the Hard Way

I was reading a paper that dropped in March 2026 and about three paragraphs in, I had to stop. The claim seemed too simple: you can adapt a large AI model to a specific task without gradient descent at all. Just random sampling and a vote.

---

What Fine-Tuning Actually Is

When an AI model gets trained, it learns general patterns from a massive dataset. Fine-tuning is the step where you take that general model and push it toward a specific task — coding, reasoning, following instructions — using reinforcement learning or optimization algorithms.

Methods like PPO and GRPO (types of reinforcement learning commonly used to fine-tune large language models) work well. But they're expensive, require careful setup, and involve a lot of iteration.

---

The Paper's Core Claim

Title: Neural Thickets: Diverse Task Experts Are Dense Around Pretrained Weights Authors: Yulu Gan and Phillip Isola Published: March 12, 2026 · arXiv: 2603.12228

The idea: in large, well-pretrained models, the weight space around the original parameters is already densely packed with useful task-specific solutions. The authors call these clusters "neural thickets."

In smaller models, good solutions are scattered — you need gradient-based search to find them. In large models, they're close to where you already are.

---

The Method — Remarkably Simple

They call it RandOpt. Here's how it works:

1. Take the pretrained model weights
2. Randomly sample N small perturbations of those weights
3. Evaluate each perturbation on your task
4. Keep the top K performers
5. Combine them with a majority vote

No gradients. No reward model. No RL training loop. Perturb, evaluate, vote.

💡 Code at github.com/sunrainyg/RandOpt

---

What the Results Showed

RandOpt kept up with PPO, GRPO, and evolutionary strategies on the tasks they tested — and this held on large-scale contemporary models.

That stopped me. These optimization methods have entire research communities, years of papers, and significant infrastructure built around them. The idea that randomly sampling neighbors of the original weights and taking a vote can match them says something about what's already sitting inside a well-trained model — waiting, not absent.

The way they frame it: small models have sparse expert solutions, so you need search to find them. Large models have dense ones. The pretrained weights aren't just a starting point. They're already rich.

---

What I Took From This

This paper shifted something in how I think about pretraining. We usually assume the pretrained model is a rough starting point and fine-tuning is where the real work happens. This flips that. If the solution space is already dense around the initial weights, the pretrained model is doing more work than we give it credit for.

There's also a question I don't have a full answer to yet: if random sampling with ensemble voting matches expensive RL fine-tuning, what does that mean for how we should be spending compute? I'm still working through the paper and the code, but it's the kind of result that sits with you.

Full paper: arXiv 2603.12228

Google Just Replaced Five AI Search Tools With One

Have you ever tried searching through a client’s content library where videos are in one folder, PDFs in another, and audio recordings scattered everywhere?

That’s the reality for most content libraries.

Until now, AI search tools struggled with this kind of setup because each type of content needed a different system to process it.

But that may be changing.

Gemini Embedding 2 — recently released by Google — can search across text, images, audio, video, and PDFs at the same time, without converting everything first.

For anyone managing knowledge bases, course content, research archives, or client media libraries, this could be a major shift.

---

What an Embedding Model Actually Does

Before explaining why this matters, it helps to understand what an embedding model is.

When AI systems search through content, they don’t read information the same way humans do. Instead, they convert content into numerical representations that capture meaning.

For example:

• A sentence about a cat

• A photo of a cat

Both produce similar number patterns, which allows the AI to recognize that they are related.

That’s how modern AI-powered search works.

The tool responsible for converting content into these numerical representations is called an embedding model.

---

The Problem With Older AI Search Systems

Until recently, every type of content required a different embedding system.

Typical setups looked like this:

• Text → processed by a text embedding model

• Images → processed by image models such as CLIP or SigLIP

• Audio → first transcribed using systems like Whisper

• Video → broken into frames or transcripts

• PDFs → converted into plain text

This created several issues:

• Multiple models to manage

• Several conversion steps

• More chances for things to break

• Slower search performance

In many cases, five different pipelines were required just to search one content library.

---

What Gemini Embedding 2 Changes

Gemini Embedding 2 solves this by creating one shared search space for multiple content types.

Instead of converting everything separately, the model processes different media formats directly and places them into the same semantic search system.

That means a single query can return results from:

• Documents

• Images

• Audio clips

• Video files

• PDFs

All at once.

For example, you could:

• Upload a photo and find related videos

• Submit a voice recording and find matching documents

• Search inside PDF files without converting them

---

Supported Input Types

Gemini Embedding 2 currently supports multiple media types in one system:

Text
Up to roughly 8,000 words

Images
Up to six images in one request

Audio
Raw audio files — no transcription required

Video
Clips up to two minutes long

PDFs
Original files can be processed without converting to plain text

All of this works through one model instead of multiple specialized ones.

---

Combining Multiple Inputs in One Search

One interesting feature is the ability to combine different types of input into a single query.

For example, you might have:

• A photo of a product

• A text description of what you want

Both can be submitted together, and the system generates one combined embedding representing the meaning of both inputs.

This allows searches that were previously impossible using single-modality tools.

---

Easy Integration for Developers

Another surprising detail is how quickly developers can start using it.

Gemini Embedding 2 launched with support for popular AI development frameworks, including:

• LangChain

• LlamaIndex

• ChromaDB

• QDrant

Because many AI applications are already built on these frameworks, developers can integrate the model without building a new infrastructure from scratch.

It’s available through:

• Google AI Studio (free tier for experimentation)

• Vertex AI (enterprise deployment)

---

Why This Matters for Virtual Assistants and Content Managers

Think about the kinds of content many clients manage.

A podcast brand might have:

• Audio episodes

• Show notes

• PDFs

• Promotional images

A course creator may have:

• Video lessons

• Slide decks

• Written summaries

A consultant might maintain:

• Recorded calls

• Presentations

• Research reports

Searching across all of that in a single step has been extremely difficult.

With models like Gemini Embedding 2, developers can build search tools where one query instantly returns:

• the right video segment

• the correct slide

• the relevant document section

All from one search bar.

---

The Bigger Picture

You probably won’t interact with Gemini Embedding 2 directly.

Instead, it will power the next generation of search tools used in:

• knowledge management systems

• research databases

• course platforms

• internal company search tools

But knowing that technology like this exists helps you understand what’s becoming possible.

That knowledge can make a big difference when clients start asking about AI-powered search, automation, or content organization systems.

---

If you manage content libraries, research archives, or client knowledge bases, this is a technology worth paying attention to.

The tools many teams will rely on in the near future are already being built on models like this. 

Google Just Had a Huge Week — Nano Banana 2, Opal's Agent Step and a New Developer Ecosystem for ADK

 There's been a lot happening at Google lately, and honestly, the updates from this past week alone are worth talking about. In just a few days, Google dropped a new default image model, upgraded their Opal workflow tool with real AI agent capabilities, and announced a brand-new integrations ecosystem for developers building AI agents. That's a lot to unpack — and I've been digging into all three.

I've been paying close attention to how Google is quietly (and sometimes not so quietly) building out their AI stack. These three updates feel connected in a bigger way. They're all pushing toward the same idea: faster, smarter, more autonomous AI tools that don't require you to be an engineer to use — or that supercharge you if you are one.

Nano Banana 2 — Pro-Quality Images at Flash Speed

One of the things that's always frustrated me about AI image generation is the trade-off. You either get fast and mediocre, or slow and beautiful. Nano Banana 2 — Google's new default image model built on Gemini 3.1 Flash Image — is trying to change that entirely.

What makes this interesting is the combination it's pulling off. It's generating at Flash speed while delivering what Google is calling Pro-level quality. To put that in practical terms: you're not waiting around for results, but you're also not getting blurry, inconsistent images. And the resolution range is wide — from 512px all the way up to 4K. That means the same model works whether you're making a quick thumbnail or something that needs to look polished and production-ready.

Here's the detail that really caught my attention: it can consistently handle up to 5 characters and 14 objects in a single image. If you've ever tried to generate a scene with multiple people or items and watched AI completely fall apart — characters blending together, objects disappearing — you know why this matters. Consistency across complex compositions has been a real weak spot in image generation, so this feels like a genuine step forward.

Nano Banana 2 is rolling out across the Gemini app and Google Workspace, and it's also available for enterprise use through Google Cloud. It's already the new default — which means if you're using Gemini for image generation, you're already on it.

---

Google Labs Opal Gets an Agent Step — Workflows Just Got Smarter

I've been curious about Opal since Google Labs introduced it as a workflow builder. The idea is that you set up a series of steps — like a recipe — and Opal runs through them to help you create something, whether that's a video, a piece of content, or a research brief. It's been useful, but the steps were static. You'd set it up once and it would just follow the same path every time.

The new agent step changes that completely. Instead of a fixed sequence, Opal now has a step where an actual AI agent takes over — it understands your goal, picks the right tools (like Veo for video generation, or web search for research), manages memory across the workflow, and routes dynamically based on what's needed. Think of it like the difference between following a printed map and having a navigation app that can reroute you in real time when things change.

This is part of a bigger shift we're seeing across the AI space, where "agentic" capabilities — AI that can reason, decide, and act rather than just respond — are becoming the new baseline. Google adding this to Opal means even people without a coding background can now build workflows that genuinely adapt. You don't have to anticipate every scenario upfront; the agent figures it out.

You can try Opal right now at opal.google — the agent step is available for all users.

---

Google ADK's New Integrations Ecosystem — Big News for Developers

This one is more developer-focused, but it's worth knowing about even if you're not building apps yourself. Google announced a new integrations ecosystem for their Agent Development Kit, or ADK — which is the framework developers use to build AI agents.

The idea is to make it easier for developers to connect their AI agents with external tools and services, so agents can actually do useful things in the real world instead of just talking about them. It's similar to how apps on your phone connect to different services — except here, we're talking about AI agents that can go off and complete tasks on your behalf.

What I find fascinating is how this fits into the broader picture. Between Nano Banana 2 (powerful image generation, accessible to everyone), Opal's agent step (autonomous workflows without code), and the ADK ecosystem (tools for developers to build custom agents), Google is building out every layer of the stack at once. There's something for the casual user, the content creator, and the professional developer — all in the same week.

AI Is Finally Fighting Back — And Anthropic Just Made It Official

 I've been watching the cybersecurity space for a while now, and I have to be honest — it's one of those areas that used to feel completely out of reach for someone like me. No coding background, no deep technical knowledge of exploits or patches. Just a person who's curious about what AI can actually do in the real world.

But here's the thing I kept noticing over the years: the good guys were always playing catch-up.

Think back to how security worked — and honestly, how it still works for most teams. You'd have a tool scan your code, it would match against a list of known bad patterns, and spit out a report. The problem? The sneaky stuff, the subtle logic flaws, the vulnerabilities that had been hiding in open-source code for decades — those never showed up. Because rule-based tools can't reason. They can only recognize what they've already been told to look for.

Meanwhile, attackers got smarter. And faster.

That gap — between what automated tools could catch and what skilled human researchers could catch — was always the weak point. And there just aren't enough human security researchers to close it. That's not a criticism, that's just math. The attack surface keeps growing. The backlogs keep piling up.

This is why what Anthropic announced on February 20, 2026 actually stopped me mid-scroll.

Claude Code Security is now in limited research preview, and what it does is genuinely different from what I'd seen before. Instead of scanning for known patterns, Claude reads your code the way a human security researcher would — tracing how data moves, understanding how different parts of an application talk to each other, and catching the complex, context-dependent vulnerabilities that traditional tools walk right past.

What really got me is the verification layer. Claude doesn't just flag something and move on. It goes back and tries to disprove its own findings, filtering out false positives before anything reaches a developer. Every validated finding comes with a severity rating and a confidence score, so teams know what to prioritize. And nothing gets applied automatically — a human always has to approve the fix. I love that. It's AI as a sharp, tireless assistant, not a rogue decision-maker.

But here's the connection I keep thinking about: Anthropic's Frontier Red Team has been quietly building toward this for over a year. They entered Claude in cybersecurity competitions. They partnered with the Pacific Northwest National Laboratory to test AI on critical infrastructure defense. They used Claude to review their own internal code. This wasn't a product announcement that came from nowhere — it's the result of real, careful work testing what Claude could actually do before putting it in the hands of others.

And the results of that work? Using Claude Opus 4.6, their team found over 500 vulnerabilities in production open-source codebases. Bugs that had survived years of expert human review, undetected.

That's the part that really lands for me. These weren't theoretical vulnerabilities. They were sitting in real code, in real projects that real people depend on — sometimes for decades.

The reason I find this so meaningful isn't just the technology. It's the timing and the intent. Anthropic is releasing this in a limited preview specifically because the same capabilities that help defenders could help attackers. They're being deliberate about who gets access first — Enterprise and Team customers, plus open-source maintainers who can apply for free expedited access. They're working with the community to get this right before it scales.

That's a different posture than "ship it and see what happens."

We're at a point where AI is going to scan a significant share of the world's code — that's not speculation anymore, it's the direction things are clearly heading. The question has always been who benefits from that first. Attackers who use AI to find weaknesses faster? Or defenders who use it to find and patch those same weaknesses before they're exploited?

Claude Code Security is Anthropic's answer to that question. 

Gemini 3.1 Pro Changed How I Actually Use AI — And It Has Nothing to Do With Benchmarks

I've been using AI tools almost every day for the past couple of years now, and if there's one thing I've learned, it's that a smarter model doesn't automatically mean you're getting smarter results. How you use the model matters just as much as what the model can do. And with Google's Gemini 3.1 Pro, there's something that I think is being really underrated in all the release coverage — the thinking level system, and what it actually means for the way you work.

This isn't a conversation about whether 77% on ARC-AGI beats 31%. It's about something more practical: the moment you realize you've been using these tools wrong, and how this new release hands you a dial you probably didn't know you needed.

What Even Is a "Thinking Level"?

Here's the quick version for anyone who hasn't come across this yet. Gemini 3.1 Pro lets you set how much thinking the model does before it responds. With the previous Gemini 3 Pro, you had two choices: low or high. With 3.1 Pro, there are now three — low, medium, and high.

Think of it like choosing between a quick gut reaction, a considered opinion, and a deep research session. The model isn't just choosing between "fast" and "slow" — it's choosing how much internal reasoning to do before it gives you an answer. At high, the model essentially behaves like a mini version of Gemini Deep Think, which is Google's most powerful reasoning model. That's a significant thing to have access to in a general-purpose assistant.

What surprised me when I started playing around with this is how much the choice actually matters. For a tricky math problem, setting thinking to high produced the right answer after several minutes of work. Setting it to low gave a fast but wrong answer. Same prompt, same model, completely different outcome.

The Problem Nobody Is Talking About

Here's what I find really fascinating about this. Most people who use AI tools have never really thought about what mode they should be in for a given task. We all tend to just fire off a prompt and expect the model to figure it out. But the thinking level system kind of forces you to be intentional, and that intentionality is where the real upgrade lives.

I started thinking about all the times I've used AI for tasks that fell into two completely different buckets. There's the stuff I need quickly — drafting a quick reply, summarizing a short article, brainstorming a list of ideas, generating a social post. And then there's the stuff where I actually want the model to sit with a problem — writing a full script outline, analyzing something complex, working through a nuanced question. Those two categories have always existed. What's new is that now I have a setting that actually reflects that difference.

Before 3.1 Pro, running everything at the same compute level was a bit like always driving in the same gear. Sometimes it worked. Sometimes it didn't. Now there's a gearshift.

How This Actually Changes My Workflow

When I started being intentional about thinking levels, a few things shifted for me pretty quickly.

For anything where I need a fast creative spark — like coming up with a hook for a video, finding synonyms, or doing a quick rewrite of a sentence — low thinking is more than enough. It's snappy, it's responsive, and frankly it's exactly what you want when you're in flow and don't want to wait. Speed matters there.

For medium tasks — things like drafting a structured outline, explaining a concept clearly, or building a content calendar — medium thinking has become my go-to. It takes a little longer, but the output feels more considered. Less surface-level. Like the model actually thought about the structure before it started writing.

And then there's high. I've started reserving high thinking for the things that actually deserve it. Complex analysis, tricky research questions, anything where getting the answer wrong would cost me time. The wait is longer — we're talking several minutes in some cases — but the quality of what comes back is on a different level. It's not just more text. It's more thoughtful text.

Why This Matters Even If You're Not Technical

I know a lot of people who use AI tools but feel like they're not getting as much out of them as they should. And honestly, after thinking about this thinking level system, I wonder if part of that frustration is just a mismatch between the task and the mode.

If you've ever asked an AI a complicated question and gotten a shallow answer, it might not be a model quality problem. It might be a compute budget problem. The model didn't spend enough time thinking. And now, for the first time, you have direct control over that.

That's actually a pretty big shift. Instead of just hoping the model figures out when to try harder, you get to tell it. It puts a little more responsibility on the user, sure. But it also puts a lot more power in your hands.

The Bigger Picture

What I keep coming back to is this: Gemini 3.1 Pro isn't just a smarter model. It's a model that respects the fact that not every question deserves the same amount of effort. And it's the first time I've felt like a general-purpose AI assistant is actually designed around how I naturally work — some things fast, some things slow, some things in between.

The AI tools that stick around aren't always the ones with the highest benchmark numbers. They're the ones that fit into how people actually think and work. This thinking level system feels like a step in that direction — and it's one I don't think enough people are paying attention to yet.