Over winter break, my 12-year-old called me over to look at her laptop.

She was studying for a quiz on a book she’d been reading. She had flashcards. And a podcast about the book — two AI hosts walking through the themes, the characters, the things that would probably show up on the test. She’d made both herself using NotebookLM. I didn’t even realize she knew about the product. Which is funny, because I helped build the Audio Overviews feature she was showing me.

It turns out NotebookLM is very popular at her school both among students and teachers. She had been using it all semester to build herself a study system. On her own. Which is pretty cool.

That’s the moment I understood how impactful NotebookLM can be.

When we were developing Audio Overviews at Google Labs, we knew it was a novel way to help people engage with their content. The immediate reaction when we shipped was delightful — people were surprised that such lifelike audio was possible. But the real impact turned out to be something we felt more than predicted: it reached people who felt they learned best by listening. People who’d been handed PDFs and book chapters their whole lives, formats they struggled to connect with.

That realization pushed the team further. Mind maps for content that benefits from clearly outlined structure. Slide decks for information that combines visual and written information. Videos for content that benefits from a deeper telling of the story or motion to bring ideas to life. Flashcards to help people test themselves and secure knowledge.

Builder’s note: This isn’t a feature roadmap built around “what’s technically cool.” Each output format is a bet that the same information, delivered differently, becomes useful to a different person or within another context. Google’s mission is to organize the world’s information and make it accessible and useful. NotebookLM is what “useful” looks like when you take it seriously.

What NotebookLM actually is

Most people I talk to think of it as a chatbot for their files. Upload a PDF, ask it questions. That’s not wrong, but it’s missing most of what makes it interesting.

NotebookLM is a research and learning environment grounded entirely in sources you choose. You bring the material; the system stays inside it. Every answer comes with citations back to your specific sources, which massively reduces hallucinations. That constraint is the whole point.

The interface has three panels. Sources on the left: everything you’ve uploaded or linked. Chat in the middle: ask questions, get answers, save the good ones as notes. Studio on the right: where you generate outputs to make your information more useful.

You can put in: PDFs, Google Docs, websites, YouTube URLs, audio files, raw text, even your own notes. I find it helpful to share voice recordings of my own disorganized thoughts about the topic. The system does the organization automatically, which feels like magic.

What you get out: Audio Overviews, Video Overviews (in three formats, including a Cinematic mode that is genuinely stunning), Mind Maps, Infographics, Slide Decks, Flashcards, Quizzes, Briefing Documents, Study Guides, FAQs. All grounded in your sources, all completely different ways into the same material.

The learning styles myth

Before I get into how to use NotebookLM, I want to flag something.

The obvious framing for a tool like NotebookLM is: figure out your learning style, pick the matching output format. Visual learner? Mind map. Audio learner? Podcast. You get the idea.

That framing is wrong. Not intuitively wrong — it feels right, which is why over 70% of educators still believe it. Scientifically wrong. The research on “learning styles” as fixed, matchable preferences has been thoroughly debunked. A 2024 meta-analysis across more than 1,700 students found that matching teaching style to learning style had no meaningful impact on performance. The effect size is 0.04. Essentially zero.

What the research does support is something more interesting: combining formats builds better understanding than any single format alone. This is called Dual Coding Theory. When you pair verbal information with visual information, the two memory systems reinforce each other. You retain more. You understand deeper.

My daughter didn’t pick her learning style. She made flashcards and a podcast. Both. That’s Dual Coding in action, figured out by a 12-year-old without anyone explaining the theory to her.

So the tips below aren’t about finding your type. They’re about using the tool the way the science suggests learning actually works.

Six tips for getting started

1. Start with something you actually need to understand

Don’t test NotebookLM with a random PDF just to see what happens. Pick something you’re genuinely trying to learn — a topic at work, a book you’re reading, a subject your kid is studying for a test. The tool works best when you have a real question. Generic inputs produce generic outputs. Here are a few topics already set up as notebooks if you want a running start:

• Introduction to NotebookLM

• Parenting Advice for the Digital Age

• Jane Austen: The Complete Works

• Secrets of the Super Agers

2. Add more sources than you think you need — and let NotebookLM find them

One document produces one-document results. A YouTube lecture, two articles, and a PDF on the same topic produces something much richer — the AI can find connections and disagreements across sources that you wouldn’t catch reading them separately.

Here’s the part most people miss: you don’t have to find the sources yourself. Hit the Discover button in the Sources panel, describe what you’re trying to learn, and NotebookLM searches the web and returns curated sources with annotated summaries. Add the ones that look useful with one click. That’s how I built the notebook backing the research in this article — I described the topic, let it do the research, and had a solid set of sources in a few minutes.

[🔗 You can explore the full notebook here: The Learning Styles Myth]

3. Try the Audio Overview first

It’s the fastest way to understand what NotebookLM pulled out as the key ideas. Even if you don’t normally listen to things, run it once before generating anything else. It surfaces connections and frames the material in a way that makes every subsequent output more useful.

[🎧 Listen: Audio Overview — The Learning Styles Myth]

4. Don’t stop at one format

This is the tip that changes how you use the tool. Generate the Audio Overview. Then generate the Mind Map. If the content is complex, try the Cinematic Video. The learning styles research says picking your “type” doesn’t help. The Dual Coding research says layering formats does. Use both.

[🗺️ Mind Map — Key concepts from the research]

[📊 Infographic — Beyond the Myth: A Science-Based Guide]

[📽️ Video Overview — Cinematic Video: The Learning Styles Myth]

[📑 Slide Deck — Download the full presentation]

5. Use the Steering Prompt

Every output in the Studio panel has a customization option before you generate. You can tell NotebookLM to focus on specific sources, approach the topic from a particular angle, or explain things at a certain level. Most people skip this and wonder why the output feels generic. “Focus on the disagreements between these sources” produces a completely different Audio Overview than the default. Try it.

6. Save the good stuff to Notes

When the chat surfaces an insight worth keeping, save it. Notes live inside your notebook alongside the sources. Your own thinking and the AI’s synthesis sit in the same place. Over time, the notes become a record of how your understanding of a topic developed — which is useful in a way that a chat history never is.

The thing my daughter understood

She didn’t ask what kind of learner she was. She made flashcards to test herself and a podcast to listen to while she studied. She layered formats because that’s what felt right, and it turns out the science agrees with her instincts.

NotebookLM is good at a lot of things. The Cinematic Video is genuinely amazing — watch the embed above if you haven’t yet. The Mind Map makes complex source material navigable in a way that’s hard to describe until you’ve dragged a branch around and watched the rest reorganize.

But none of that is the point. The point is that the same information can be made useful in a dozen different ways, and most of us have been stuck with one or two of them our whole lives.

My daughter had a quiz to pass. She figured out how to prepare for it. You can do the same thing with whatever’s on your plate. Big sales call? Load up the client’s annual reports. Job interview? Drop in the job description and let Discover find you prep material. Presentation next week? Paste in your notes, record a voice brain dump, and watch it turn into slides. Even if it only breaks the writer’s block, that’s worth it.

So, what are you trying to understand right now? Have you tried more than one format yet? I’m curious what you’re hoping to learn and what works for you!

— T

I had lunch with my friend Ronny at work a few weeks ago and we were (shocker!) talking about AI. Specifically, we were talking about how AI is absorbing more of the daily computing tasks that used to require a person sitting at a screen. Scheduling, research, drafting, monitoring, summarizing. The list grows every month.

That led us to a question: if AI agents are becoming the primary operators of computing systems, what happens to all the infrastructure we built so that humans could operate them?

Because that’s what operating systems actually are. They’re abstraction layers. Decades of engineering spent translating machine reality into something a human mind can understand. File systems, because humans think in containers and locations. Graphical interfaces, because humans perceive visually. Process scheduling, because humans experience time linearly. Every design decision in Unix, Windows, Android, ChromeOS and MacOS encodes endless assumptions about who’s sitting at the controls.

But what if the operator we’re building for is no longer a human?

15,000 tokens per second

Let’s take a quick aside. There is a company called Taalas who has recently built an app called Chat Jimmy. It’s a demonstration of their main business: building AI models compiled directly into custom silicon. Not software inference running on a general-purpose chip. The model is in the computer.

Chat Jimmy operates consistently above 15,000 tokens per second. For context, human speech runs at roughly 3 tokens per second. At 15,000 tokens per second, an agent can reason through a complex problem, take multiple actions, and produce a result before a human has finished reading the first sentence of the last response. The inference bottleneck for most computing tasks totally disappears.

If we can get hardware of this nature to a place where local models operate at similar speeds, something shifts with on-device models. They become the computer. And we don’t have an OS built for that world yet.

The big inversion

It won’t be trivial to get 15k tokens per second running on a device you keep on your desk, but it will happen. And it’ll signal a shift in how we work. At current inference speeds, agents wait on compute. The OS doesn’t matter much because the model is the slow part. Get the model fast enough and the calculus flips. The agent isn’t waiting on the model. The model is waiting on the human. I already see some of this happening today.

Humans will be the rate-limiting constraint on our systems.

That’s a completely different world to design for. An operating system doesn’t need to be optimized for human-speed interaction anymore. It needs to be optimized for machine-speed agents that are supervised by humans who still move at human speed. Safety, reversibility, and trust enforcement become the central design problem.

I don’t think anyone has asked what an OS designed for this user inversion would look like yet.

A sketch of the stack

I’ve been thinking about this question and sketching out an architecture that could be interesting. By no means is this thoroughly thought through, so think of it like an outline for what might work. If you’ve thought about this as well or have some ideas, reach out — I’d love to chat.

Layer 0: Linux kernel. Start here and keep it. It handles hardware, networking, and process isolation. These are solved problems not worth re-solving. You can add eBPF programs on top to enforce capability rules at the kernel boundary. No kernel fork required.

Layer 1: Hardware model. An on-device LLM minted into silicon that’s always on, always available, near-zero latency. The runtime talks to this chip in natural language. That’s not a poetic choice. If the model is the chip and human language is its instruction set, then system calls are just English. Every operation in the audit log is human-readable by default. LLMs printed into chips will have knowledge gaps, so this layer gets augmented with an online model for some tasks — but we’ll handle that later.

Layer 2: Agent runtime. This is the interesting layer. It replaces all of traditional user space. It’s the part of the stack that exists to mediate between the machine and a human user. Instead of mediating for humans, it manages agents: their context windows, their tool access, their permissions, their lifecycle.

A few key jobs it handles:

• Context management. An agent’s working memory is its context window, not just RAM. The OS manages context as a first-class resource — what gets evicted, summarized, or persisted across sessions.

• Tools instead of syscalls. Instead of a syscall table, a tool registry. Agents call tools. The registry knows what each tool does, whether it’s reversible, what it costs, and whether human approval is required before execution.

• Capabilities instead of permissions. Unix permissions are a file ownership model. That’s not the right primitive for agents. We need something closer to structured, delegatable, auditable capabilities.

• Reversibility as infrastructure. Right now, every application that wants undo has to build it from scratch. An agent OS should make reversibility a first-class primitive. A staging area for irreversible actions that waits for explicit human approval before executing. At 15,000 tokens per second, mistakes accumulate fast.

Layers 3 and 4: Specialist models and agents. Specialist models load on demand above the runtime — like kernel modules for specific domains: code, vision, planning. Above that, agents run as goal-oriented processes rather than session-bound apps. This is where we can add online models to overcome the natural knowledge gap of an LLM printed to silicon.

I’ve seen this movie before

One of my first jobs at Google was helping build ChromeOS. I know a little about what it takes to rethink an operating system. ChromeOS asked: what could an OS be if the web browser were the only app? The answer was a much more efficient system. Strip away 40 years of complexity built to run native applications. Boot in 8 seconds. Let the browser do everything else.

Today we’re in a similar spot, asking a similar question: what would an OS need to be if you built the whole thing for AI agents instead of people?

I work next to people building the next generation of operating systems and I haven’t even asked them about this. Partly because what I’m sketching is a thought experiment, and I didn’t want anyone else’s answers to constrain mine. The Android and ChromeOS teams have something in development called Aluminum — I don’t know what’s in it, and this isn’t that.

What I do think is clear: every company building an OS right now is trying to figure out how to add AI into it. But the answer we’re looking for isn’t an existing paradigm with AI bolted on. It isn’t ChromeOS or MacOS or Android with a chat window. It’s something designed from scratch around the assumption that the thing doing the computing is an agent, and the human is there to supervise and interact with it — not to drive all the details of making it work.

That’s a different OS than anything that exists today.

Why does this matter now?

The window is specific to this moment. Every day another AI system announces more capabilities for computer use: schedules, remote access, browser automation, skills, MCP servers. All of these systems designed so agents can pretend to operate like people. We’re forcing computers to pretend to behave like humans in order to do things on computers. It’s a strange layer of friction we keep injecting because we’re using a wrench to hammer a nail.

At the same time, local inference is still too slow to run capable agents on-device for everything a modern OS relies on. Even the newest Qwen models on a tricked-out Mac Studio fall short of what we need for agents to run all of the details of these systems continuously. Until we close that gap, agents live in the cloud, on human-designed infrastructure, using agent harnesses to drive systems built for people.

Before long these constraints will be gone. Chips will hit 15,000 tokens per second and will run efficiently on your laptop. Then on your phone. Then on your headphones. Local capable agents will become practical on every device. And everyone who wants to run those agents needs an OS built specifically to maximize that experience, or we’ll keep absorbing friction translating from computer to human and back to computers.

When that OS exists, it will shape what agents can do and how safe they are. If we keep heading down the road we’re on with defaults of agents running on Linux and Windows — systems with no concept of a tool registry, no capability model for autonomous action, no staging area for irreversible decisions — we’re headed for problems.

The time to design this is before the hardware arrives. After it arrives, you’re retrofitting. Or maybe the agents will just do it themselves.

What’s left to ponder?

Because I’m using this as a way to write-to-think, I’m very much missing a lot of detail. A few gaps I’m genuinely curious about:

The Tensor question. Google’s Tensor chips already do pretty impressive on-device Gemini Nano inference. Is it close enough to what Layer 1 needs, and how well-suited is this approach to being what we want exposed to software? This matters for whether we’re talking about new silicon or new software on existing silicon.

The safety research. The capability and reversibility model I’ve sketched is conceptually interesting, but I don’t know how much formal work exists on verifying capability systems for LLM agents. This is probably a known problem in security research that I haven’t fully worked through yet.

The device form factor. A personal AI server — a small always-on box that runs your agents locally — seems like a natural first hardware expression of this. But I’m not sure if that’s the right starting point, or if this begins as a server product and migrates to the edge over time. What do you think?

I find this compelling enough to think more about, which is why I wrote it down.

If you’re working on any part of this stack — hardware, runtime, capabilities, reversibility — I’d love to know. And if I’ve missed something obvious, tell me. What’s the right device form factor for this? Does it start in your living room, or in a data center?

— T

One of my readers sent me an email last week with the subject line “Building Semi-Rad Shit.”

He’d been inspired by something I wrote and stayed up late putting it to work. He trained Gemini to review solar site title insurance exceptions. Then he had it pull utility hosting capacity maps, find available parcels, and cross-reference them against where the grid has room. A list of viable solar development sites, ranked by proximity to power lines. In a few hours.

“Last time I did site identification a few years ago,” he wrote, “I pulled the map data off the utility website into a database, then matched it with parcel data from each county by hand... this time I got a solid list in only a few hours!”

Then, near the bottom of his email, he hit the wall.

“It’s a little annoying that I can’t just have it do things offline, and it can’t send me emails once it’s done the work periodically.”

Almost every builder I know hits this wall eventually. You do something impressive with AI, you see what’s possible, and then you realize: your AI only works when you’re there asking it questions. It goes to sleep the moment you close the tab.

This post is about how to take that next leap with AI.

The gap between an assistant and an agent

Most AI tools are reactive. You prompt, they respond. You close the tab, they stop existing. That’s useful. But it’s not the same as having something working for you all the time.

A proactive agent is different in one specific way: it has a schedule. It wakes up, does a job, and reaches out to you if it finds something it needs your input on. If nothing’s worth saying, you hear nothing. You only know it’s running because, every so often, your phone buzzes with something that is worthy of your attention.

The first time that happens something profound clicks.

The good news is that three ingredients are all you need:

1. A schedule: a system to trigger your agent at regular intervals

2. A task: a specific job with clear instructions about what to do each time

3. A way to reach you: configuration for a chat message or an email

Everything else is implementation details.

Introducing OpenClaw

The most popular tool right now for building these sorts of agents is OpenClaw. It’s a self-hosted AI gateway you run on your own machine. It handles the scheduling, the agent sessions, and the channel connections needed to keep an agent running in a loop. It’s become very popular lately because it can be configured to do just about anything and has a rapidly growing ecosystem of skills you can use with it.

It’s not the only option for this, but it’s the one I’ve actually used to build everything I’m about to describe. It runs on Mac, Linux, any VPS, a Raspberry Pi, or even a Docker container you can run on your main computer. Monthly cost beyond the hardware is just your Anthropic, Gemini or OpenAI API usage. For light-to-moderate agent workloads, this can be had for about $5–20 per month.

Let’s help get you started.

Step 1: Install OpenClaw

On a Mac
I have my OpenClaw running an a Mac mini I wasn’t using, so let’s start with this option. If you’ve been trying to buy a Mac mini recently and found them out of stock, OpenClaw is part of why. There’s a wave of people buying them specifically as always-on personal AI servers. The M4 model idles at about 10 watts. Less than a light bulb to keep an agent running around the clock.

If you’re using a Mac for OpenClaw you really want to dedicate that device to your setup so it’s not competing with you for resources. Once you have updates applied and a fresh install, open terminal and run this:

curl -fsSL https://openclaw.ai/install.sh | bash

This one command detects how you system is setup, installs Node if needed, installs OpenClaw, and walks you through the next steps. If you have a Mac ready to go, this is your fastest way to get started.

On a Virtual Private Server
Another popular option is to spin up an inexpensive virtual server (aka a VPS). Hetzner is a good option with their CX22 plan at $4/month. It provides 2 vCPU and 4GB RAM which is plenty for most basic OpenClaw setups. Here’s how set it up:

a. Create the server.
Go to hetzner.com, create an account, and create a new server. Pick Ubuntu 24.04, the CX22 plan, and select a data center near you. When asked about SSH keys, you can skip it and Hetzner will email you a root password — or if you want to set one up, GitHub’s SSH key guide is the clearest I’ve found. It’s worth doing once.

b. Connect to your new server using SSH.
Open terminal and type this:

ssh root@YOUR_SERVER_IP

c. Run the installer.
This single command sets up OpenClaw, creates a firewall, configures auto-start on boot, and implements Tailscale for secure remote access:

curl -fsSL https://raw.githubusercontent.com/openclaw/openclaw-ansible/main/install.sh | bash

You don’t need to know what any of that means. The installer walks you through everything, including how to add your LLM API key (Anthropic, Gemini or OpenAI). Once you finish, you’ll have a running OpenClaw gateway.

d. Verify.
After setup, you should check that everything is working as expected. You can do that with these commands:

openclaw doctor    # checks for config issues
openclaw status    # confirms the gateway is running

gateway: running means you’re done with this step and ready to go.

Step 2: Connect Telegram

Telegram is the fastest way to get your agent talking to you. It’s free, works everywhere, has no iMessage dependency, and is the default for a reason. Works on every platform, no phone number required.

2a. Create a bot

Open Telegram and search for @BotFather. Start a chat and run:

/newbot

Follow the prompts, pick a name and username for your bot. BotFather will give you a token that looks like:

7412938456:AAHdqTgsH8m9a3Xe5lk0mBHZJzwp1234xxcd

Copy that token. You’ll need it in the next step.

2b. Add the token to OpenClaw config

Open your OpenClaw config file (the onboarding wizard tells you where it lives, typically ~/.openclaw/config.json5) and add the following to the file. I’m going to ask you to edit a few text files. If you’re on a mac, you can open the files in TextEdit which is pre-installed. On a VPS you’ll need to use vim which is a bit trickier to learn and somewhat unintuitive. Google it and figure it out. I believe in you.

Anyway, once you figure out how to edit text files add this to the config.json5 file:

{
  channels: {
    telegram: {
      enabled: true,
      botToken: "YOUR_TOKEN_HERE",
      dmPolicy: "pairing",
    },
  },
}

Save the file, then restart the gateway:

openclaw gateway restart

2c. Pair your Telegram account

Open Telegram and send any message to your new bot. Then back in your terminal:

openclaw pairing list telegram

You’ll see a pairing code tied to your Telegram user ID. Approve it:

openclaw pairing approve telegram YOUR_CODE

Send another message to your bot. It should respond. That’s the connection live.

Step 3: Build your first proactive agent

The basic setup is ready. Now for the good part.

A cron job in OpenClaw is just a scheduled task with a natural language prompt. You describe what you want the agent to do, when to do it, and where to send the result. No code.

Here’s the exact setup for a monitoring agent, the same pattern I use for a dozen different tasks:

openclaw cron add \
  --name "My First Monitor" \
  --cron "0 */4 * * *" \
  --tz "America/Chicago" \
  --session isolated \
  --message "Check [URL or data source] for [specific condition]. If you find [thing worth reporting], send me a Telegram message at [your Telegram ID] with the details. If nothing has changed or nothing meets the condition, output QUIET and stop. Do not send any message."

The --cron "0 */4 * * *" runs it every 4 hours. Crontab.guru is a handy tool for building your own expressions. Some common ones:

• Every morning at 7am: "0 7 * * *"

• Every Monday at 8am: "0 8 * * 1"

• Every hour: "0 * * * *"

The most important part of the prompt: tell the agent to be quiet when nothing is worth reporting. output QUIET and stop prevents notification fatigue. You want to hear from it when something matters, not on a schedule.

For our reader’s solar use case, this might look like:

Check the ComEd hosting capacity map at [URL] for any new high-capacity zones 
that weren't in my last report. Cross-reference with parcel data for any lots 
over [n] acres within [m] miles of those zones that are listed for sale. 
If you find new matches, email me with a summary. If nothing new, output QUIET.

But you don’t need to any of that by hand! You can literally open Telegram and send your bot a message with the prompt above along with a description of when you want it run and how often. And your brand new agent will do it for you. This is the most important lesson here. Your agent knows how to set itself up and can do just about anything you want it to do from now on. This is why we’re careful about the machine we give it access to.

Step 4: The AgentMail upgrade

Telegram works great for personal alerts. But if you want your agent to send proper emails, or receive emails and act on them, you’re going to want to add AgentMail. I like this service because it’s built specifically for agents and how we use them securely. You could give your agent access to your personal email, but before you do that I recommend you really understand what you’re doing so you don’t bork your personal inbox like some people did.

Once you have it setup AgentMail gives your agent its own inbox. Next is setting up your system so your Agent knows about it’s new email account. You can install the skill by hand with this command:

clawdhub install agentmail

Then your agent can send from solar-scout@agentmail.to (or whatever you configure), format a proper email report, and drop it in your inbox every Monday morning. It can also receive emails. If you reply to a report, the agent processes your reply and takes action.

For our reader this is the missing piece. Instead of a Telegram ping, he’d wake up to a formatted email from his solar scout with a table of new sites, ranked by proximity to capacity, with links to the parcel listings.

What changes

The first few days you’ll keep checking if it worked. Opening the logs, running openclaw status, making sure the cron fired, etc. Then you forget it’s running.

A week later your phone might buzz. Your agent found something. Something you would have missed because you weren’t looking.

That’s the shift you need to get comfortable with. Your mindset shifts from “What can AI do for me?” to “How do I make my AI work for me when I’m not working?” This is the answer. The initial setup takes 30 minutes. The payoff is an AI that has a job, shows up for it, and only bothers you when it has something worth saying.

Before long you’ll be hooked. You’ll discover you can simply ask your agent to do all sorts of things for you proactively and it’ll set itself up to make it happen. You’ll browse clawhub.ai for skills and eventually write your own skills. You’ll read about how people are doing amazing things with their setups and replicate some of their efforts. It gets fun fast.

On Sunday, my agent texted me at 7am about sold out Harry Potter tickets for a trip we’re taking to London. Stella was keeping an eye out for cancellations, so I could pounce if any came available. We didn’t get the tickets because someone else was faster. That’s a different problem. But I’m hopeful I’ll have another chance.

What would you have your agent do for you?

Builder’s note: The OpenClaw docs are at docs.openclaw.ai and the community is active on Discord if you get stuck. If you end up building something like solar scout, I want to hear about it.

Trond Wuellner builds things at Google Labs and writes about what he learns. If this was useful, forward it to someone who’d appreciate it.

Subscribe now

Smart people. All of them.

Every single one has played with ChatGPT. Most use it regularly. And when I described what I’ve been building: AI assistants that manage my family’s calendar, generate math worksheets for my kids, call restaurants on my behalf, monitor my house. They all had the same look. Not skepticism. More of an eagerness to dive in to figure out where these tools might help them at home and at work.

“Okay but how do you actually start?”

That’s what this is. The answer to that question. Not theory or hype. A step-by-step guide for someone who understands their business, isn’t afraid of technology, and is ready to go from curious to building.

This is my favorite part of this moment we’re living in. You don’t need to be a developer. You need to be willing to try and eager to learn. This guide is for you.

The Decision

Before you install anything, understand what you’re actually signing up for.

Building with AI coding tools is not like using ChatGPT. You’re not typing questions and copying answers. You’re setting up an ongoing collaboration with a system that writes code, runs commands on your computer, reads your files, searches the web, and iterates based on your feedback.

And the output isn’t always software in the traditional sense. It might be an automated workflow, a document processor, a report generator, or a tool that monitors your inbox and surfaces what matters. If it involves information and repetition, these tools can help.

It’s closer to hiring a junior developer than using a search engine. A very fast, very capable junior developer who has read most of the internet but has no context about your specific situation.

Your job is to provide that context. To ask good questions. To review what it builds and tell it what to change. You don’t need to understand every line of code it writes. You need to understand what you want, and be able to recognize when you’re getting it.

That’s it. That’s the skill.

The tools do the rest.

A Word on Cost

Before you install anything: check what you already have.

A lot of people are already paying for access to these tools without realizing it.

• Google Workspace Business Standard and above includes Gemini built in: summarization in Gmail, Docs, Sheets, and more. Check with your IT admin or look in your Google account under the Gemini icon.

• ChatGPT Plus ($20/month) includes Codex. If you’re already subscribed, you’re in.

• Microsoft 365 offers Copilot as a paid add-on, but if your company has rolled it out, you may already have access to some of these capabilities.

If you have any of these, start with what you have before buying anything new.

If you need to pay, subscriptions are almost always the better choice. The $20/month plans (Claude Pro, ChatGPT Plus, Google AI Pro) give you predictable costs, generous limits, and the most capable models. For most people, a subscription goes further than pay-per-use at the same price.

The higher tiers, Claude Max ($100-200/month) and ChatGPT Pro ($200/month), are worth it once you’re using these tools daily and want priority access, maximum limits, and the fastest responses. Think of it like a SaaS tool: pay for the plan that matches your usage.

The pay-per-use API is powerful but unpredictable. Claude Code can run $20-50 in a single day on a large project without you noticing. It makes sense eventually, especially for automated workflows that run without you. It’s not where you want to start.

The progression that makes sense:

1. Check if you already have access (Workspace, ChatGPT Plus, Microsoft 365)

2. Start with a free tier (Gemini CLI, Antigravity) to get comfortable

3. Upgrade to a $20/month subscription when you’re ready to go deeper

4. Move to higher tiers ($100-200/month) if you’re using it every day

5. Add pay-per-use API access only when you’re building automated workflows that run on their own

Pick Your Tool

There are essentially three tools worth using right now. They all do roughly the same thing: AI-assisted coding and automation. Different providers, each with different strengths.

All have desktop apps to get you building without touching a terminal. Claude’s desktop app includes a Code tab (Claude Code with a visual interface) and Cowork, an autonomous mode where Claude acts on files in a folder you authorize. Codex has a standalone app. Google’s Antigravity IDE is free and helpful for getting started quickly.

Pick the tool that matches what you already have access to. You can always change later. We’re just finding the right path to get you started today.

My simple point of view:

Start with what you already pay for. ChatGPT Plus gives you Codex. Google Workspace gives many people Gemini Pro. Check what you already have before you buy anything.

If you’re starting from zero: Antigravity (Google’s IDE) is free, polished, and requires no terminal. Gemini is especially good if your project involves reading lots of documents, emails, or spreadsheets; which is a bonus.

Codex is the natural choice if you already use ChatGPT Plus. You’re already paying for it. Just start there.

I generally start most projects with Antigravity, but I also love what Claude can do even though it requires a subscription. Their desktop app is quite impressive. The Code tab handles most coding tasks beautifully, and Cowork (included from Pro and above) takes it to another level. It reasons more carefully than the others, handles nuance well, and is often the most honest about what it doesn’t know. Worth it once you’re willing to add another subscription to your monthly nut.

You don’t have to pick just one. You’ll learn what you prefer as you start building and can easily change later.

Install It: Step by Step on Mac

Option A: Gemini (Google)

The easy way: Antigravity

Google released an agent-first IDE called Antigravity in late 2025. It’s free and runs Gemini models under the hood. The standout feature: a “Manager View” that orchestrates multiple AI agents in parallel across your editor, terminal, and browser. Think Mission Control for coding tasks. Download it like any Mac app, sign in with your Google account, and you’re building in minutes.

The power-user way: CLI

The Gemini CLI unlocks its biggest advantage: the ability to read enormous amounts of text at once. Useful for projects involving lots of documents, emails, or large codebases.

brew install node
npm install -g @google/gemini-cli
gemini

On first run it opens a browser window for Google sign-in. That’s the whole setup. For the most powerful model:

gemini -m gemini-pro-latest

Option B: Claude (Anthropic)

The easy way: desktop app

Download the Claude desktop app at claude.com/download. Free to download, works on Mac and Windows. Sign in with your Anthropic account and you get two modes worth knowing about:

• Code tab: a graphical interface for Claude Code. You get visual diff review, live previews of what you’re building, and the ability to run multiple tasks in parallel, all without touching the terminal. This is Claude Code with a UI on top.

• Cowork: a research preview (Pro and above) where Claude autonomously acts on files in a folder you authorize. Think of it as giving Claude a desk of its own: it can organize documents, build spreadsheets from receipts, draft reports. You review and confirm significant changes.

For most people starting out, the Code tab is the right place to begin.

The power-user way: CLI

The terminal version is one line to install:

curl -fsSL https://claude.ai/install.sh | bash

After it finishes, just run:

claude

Sign in with your Anthropic account. You’ll need a Pro or Max subscription (starting at $20/month), or an API key from console.anthropic.com to pay by usage instead. The CLI and the desktop app share the same config, including your CLAUDE.md files, so you can move between them freely.

Option C: Codex (OpenAI)

The easy way: Codex app

OpenAI has a standalone Codex app at openai.com/codex. Purpose-built for coding tasks. If you already pay for ChatGPT Plus ($20/month), you have access.

The power-user way: CLI

brew install node
npm install -g @openai/codex
export OPENAI_API_KEY="your-key-here"
codex

Get your API key at platform.openai.com → API Keys → Create Key.

Your First Session: What You’ll Actually See

Here’s what you’ll actually see when you open each tool for the first time.

If you’re using Antigravity (Google)

When Antigravity opens you’ll see two views in the sidebar: Editor and Manager.

Start in Editor. It looks like a code editor: a big panel on the left for files, a writing area in the center, and a chat panel on the right. That chat panel is where you talk to the AI. You don’t need to touch the file panel or the code. Just focus on the chat.

To open your project: File → Open Folder → navigate to your project folder (Desktop or Documents is fine) and select it. Your files appear in the left panel. Now when you talk to the AI, it can see and edit those files directly.

Type your first message in the chat panel on the right. The AI responds, makes changes to your files, and shows you what it did. In a moment, we’ll show you what to type in that chat box!

If you’re using the Claude desktop app

When it opens you’ll see a clean interface with a chat window in the center. At the top you’ll see tabs: Chat, Code, and (on Pro and above) Cowork.

Click Code. You’ll see a chat interface similar to the regular Claude chat, but with file access. Click the folder icon or go to File → Open Project to point it at your project folder. The AI can now read and edit files in that folder.

Type your message in the chat box at the bottom. The AI responds in the main window, shows you code changes with visual diffs (highlighted additions and deletions), and asks for confirmation before editing files.

If you’re using Claude Code in the terminal

After running claude, you’ll see a prompt that looks like this:

Claude Code (claude-opus-4-5)
Type a message or /help for commands
>

Navigate to your project folder first:

cd ~/Desktop/my-project
claude

Full Claude Code docs at docs.anthropic.com/claude-code.

Now type your message at the > prompt. The AI responds inline, shows you the files it’s changing, and asks your permission before modifying anything.

If you’re using the Codex desktop app

When Codex opens you’ll see a Projects panel on the left and a main area on the right. Projects are how Codex organizes your work: each project points to a folder on your computer (or a GitHub repo, if you have one).

To get started: click New Project, give it a name, and point it at your project folder. Codex loads the files and you’re ready.

The main area shows Threads: each thread is a task you’ve given to an AI agent. Think of threads like chat conversations, except instead of just answering, the AI is actively editing files and running code in the background. You can have multiple threads running at once, each working on a different thing.

Type your first message in the input box at the bottom of the main panel. The AI picks it up as a new thread, starts working, and shows you what it’s doing in real time: which files it’s reading, what changes it’s making, whether the code ran successfully. When it’s done, you’ll see a diff — a summary of what changed — and you can approve it, ask for changes, or open the result in your own editor.

One thing worth knowing: Codex is built for parallel work. You can kick off one task, then start another while the first is still running. Each stays in its own thread. Genuinely useful once you have more than one thing to build at once. For your first session, just start one thread and get a feel for the loop before you try running multiple.

The big thing most people don’t realize

You don’t need to know how to run code. In all three tools, the AI runs the code itself. You ask it to build something, it builds it, runs it to check it works, shows you the result, and tells you if anything went wrong. Your job is to tell it what you want and give feedback on what you see.

If the AI produces a script you need to run yourself, it will tell you exactly what to type. Copy it. Paste it. Run it. That’s the full extent of what you need to know.

On permissions and trust

One thing that catches people off guard: these tools ask for your approval constantly. Before editing a file, before running a command, before accessing the internet: you’ll see a prompt asking if it’s okay to proceed.

Often you won’t know exactly what it’s asking. The command it wants to run might look like gibberish. You’re faced with a choice: trust the system and say yes, or stop and ask what it means before proceeding.

Here’s a rough guide to what’s routine and what deserves a pause:

Generally fine to approve:

• Reading or editing files inside your project folder

• Running the code it just wrote

• Installing packages or dependencies (it needs these to build things)

• Creating new files in your project

Worth a moment’s thought:

• Making network requests or calling external APIs: ask what it’s connecting to and why

• Deleting files: make sure you know what’s being removed

• Commands that reference folders outside your project: why does it need to go there?

• Anything involving credentials, API keys, or passwords: confirm it’s not storing these somewhere unexpected

Decline and ask questions:

• Anything with sudo (administrator access) that the task clearly doesn’t require

• Commands touching sensitive system locations you didn’t direct it toward

• Sending data to a service you didn’t set up or recognize

When in doubt: if a command looks completely alien, type “explain exactly what this does in plain English before running it.” The AI will walk you through it. You’ll either feel confident to proceed, or you’ll catch something that shouldn’t happen.

Once you trust the project and want to stop approving every small action, Claude Code has an answer: yolo mode. Type /yolo in the chat. It skips permission prompts for the session. Your files are still there, changes are still visible, and you can undo. It just means you’ve decided to let the AI work without interruption. Most people switch to it once a project is underway and they understand what the AI is doing.

Setting Up Your First Project

Every project starts the same way: a folder and a briefing file.

If you’re using a desktop app (Antigravity, Codex or Claude): Create a folder anywhere. Desktop or Documents is fine. Name it something descriptive. Then open it in the app. That’s your project.

If you’re using the terminal: Create the folder and navigate into it:

mkdir ~/Desktop/my-project
cd ~/Desktop/my-project

The briefing file is called AGENTS.md. Think of it as permanent memory for your project: context the AI reads at the start of every session so you never have to re-explain from scratch. Claude Code reads CLAUDE.md natively, and most other AI coding tools are converging on AGENTS.md as the shared standard. Using AGENTS.md means every tool picks it up automatically.

A quick note on the .md file format. These files are written in a format called Markdown: a simple way of formatting plain text using symbols like # for headings and - for bullet points. You’ve probably seen it without knowing it. The AI reads it perfectly, and it’s easy to write once you’ve seen an example.

Macs don’t come with a great Markdown editor by default. A few good options:

• Bear: Mac-native, beautiful, free to start. The one I’d start with.

• Obsidian: free, powerful, worth it if you want your notes and projects in one place.

• VS Code: free, already installed if you’re using Antigravity (it’s built on the same base), and has Markdown preview built in.

Again, remember that you can always just ask the AI to create the file for you. After the interview, say “Based on what we just discussed, create an AGENTS.md file for this project.” It will write the whole thing correctly. If you want, you can open it in Bear or Obsidian to review and tweak.

Seriously, don’t start from scratch. The community has built templates you can copy. Just use those as a starting point, they’re going to be better than whatever you’ll do at first:

• agentsmd/agents.md: The simplest, most widely-adopted template.

• davila7/claude-code-templates: Ready-to-use configurations with working examples.

Here’s a starting point if you absolutely want to roll your own:

# AGENTS.md

## What This Project Is
[One paragraph: what it does and why it exists]

## Who Uses It
[Describe the person this is built for]

## Current Status
[What's done, what's in progress, what's next]

## Important Constraints
[Things the AI must never do, hard requirements, known limitations]

## Style and Standards
[How you want things done: tone, format, patterns to follow consistently]

You don’t need to fill in every section before you start. The first two are enough to begin. The AI will help you figure out the rest as you go.

The Style and Standards section is the most underrated part. Tell the AI once how you want things done, and it applies that consistently every session. You stop correcting the same things over and over.

One note on naming: AGENTS.md works across most tools. If you’re using Claude, it reads a file called CLAUDE.md instead. That file has the same purpose and works the same way but they don’t use the common naming scheme as everyone else. Sigh.

Starting every session, your opening message:

Please read AGENTS.md to get context on this project, then tell me what you understand and what questions you have before we continue.

It’s a good idea to say this at the start of every new chat. It takes five seconds and prevents you from re-explaining your project from scratch. If you’re in the terminal, navigate to your project folder first (cd ~/Desktop/my-project), then start the tool.

Your First Project: The Interview Method

Here’s one mistake people make when they get started: they open the tool and immediately say “build me X.”

The model has no idea who you are, what your business does, what constraints you’re working under, or what “good” looks like for you. So it builds something generic that doesn’t fit, you get frustrated, and you assume AI coding tools don’t work.

They do work, but you need to teach them what you want first.

I use what I call interview mode. Open your tool of choice, make sure it’s pointing at your project folder, and type this into the chat window:

Before we start building anything, I want to make sure you deeply understand what I need. Please ask me up to 10 clarifying questions about this project — one at a time, waiting for my answer before asking the next. Focus on: who the users are, what problem we're solving, what success looks like, what constraints I'm working under (time, budget, technical), and what I definitely don't want. When you feel you have enough, summarize what you've heard and ask if it's right before we proceed.

The model will ask you things you hadn’t thought to specify. Answer honestly in the chat, one question at a time. When it summarizes back to you, correct anything that’s off. This usually takes 10-15 minutes and saves hours of misdirected work.

After the interview, you’re going to want to capture the key insights in a structured way using 2 docs. The AI will write them and save them directly to your project folder:

The requirements prompt:

Based on our conversation, write a short Product Requirements Document and save it as REQUIREMENTS.md in this project folder. Include: the problem we're solving, who it's for, the core features in priority order, what we're explicitly not building, and what "done" looks like for the first version.

The plan prompt:

Now write a step-by-step build plan and save it as PLAN.md. What are the major pieces? What order would you tackle them in? Flag anything where you see a real tradeoff I should weigh in on.

Once the AI saves these files, they’ll appear in your project folder. Open them in Bear or VS Code to read through them. Correct anything that’s off. These become the ground truth that keeps you and the AI aligned throughout the build, and the foundation of your AGENTS.md.

The Build Loop

You’ve briefed the AI, you have a plan, you’ve started a session. Now what?

Building with AI tools is a loop:

1. Ask for something specific. Not “build my app” but “build the function that reads incoming emails and pulls out the dates.”

2. Review what it builds (you don’t need to understand every line, but read the explanation it gives you)

3. Test it. Say “run this and show me the output.” The AI executes the code itself and reports back what happened. You don’t need to know how to run code.

4. Tell it what’s wrong. Be specific: “this crashes when the email has no subject line” or “the output is missing the date field.”

5. Repeat

Reading responses: The AI will often explain what it did and why. Read this. It’s showing its reasoning. If the reasoning sounds off, say so before it goes further. Correcting direction early is much easier than unwinding bad work later.

When it gets stuck: All three tools will sometimes hit a wall and go in circles. Signs: it rewrites the same thing repeatedly, asks you the same question again, or apologizes for the confusion more than twice. When this happens, stop. Start a fresh conversation. In the app, click “New Chat” or “New Session”. In the terminal, type exit and run claude again. Then paste the relevant context: “Read AGENTS.md and DECISIONS.md, then let’s approach [the specific problem] differently.” Fresh context, fresh angle.

When to push vs ask: If you don’t understand a choice the AI made, ask. “Why did you use X here instead of Y?” It will explain. Either there’s a good reason you hadn’t considered, or it made a mistake. Either way, you learn something. Never accept work you don’t understand at all. You’ll have to deal with it later.

The Learning Loop: How the System Gets Smarter Over Time

Here’s something most people miss. It’s probably the biggest multiplier once you get past your first project.

Every AI coding tool starts with zero knowledge about you. Your preferences. Your standards. The decisions you’ve already made. What you tried last week and why it didn’t work. Each new session, you’re starting from scratch unless you build a system to prevent that.

The fix is simple: document decisions as you go, in a place the AI can read them.

Create a file called DECISIONS.md in your project folder. After each meaningful session, end with this prompt:

Summarize what we built today, what decisions we made, and why. Format it as a short list I can append to DECISIONS.md.

Paste the output into the file. Next session, start with:

Before we continue, read AGENTS.md and DECISIONS.md to get full context on this project and the decisions we've already made.

Over time, this file becomes institutional memory. The AI stops suggesting things that contradict choices you’ve already made. It stops proposing approaches you already tried and abandoned. It builds on what exists.

What to capture:

• Choices made and why (”we’re using X instead of Y because...”)

• Things that didn’t work (”tried Z, caused problems because...”)

• Standards you want applied consistently (”always do it this way”)

• Open questions you haven’t resolved yet

You don’t need to be exhaustive. Three or four bullet points per session compounds fast over weeks.

The projects where this discipline holds get easier over time. The ones where it breaks down get harder. The AI gets genuinely more useful the more context it has. DECISIONS.md is the simplest way to build that context.

API Keys Done Right

Most people don’t need this section yet. If you’re using a subscription plan (Claude Pro, ChatGPT Plus, Google One), you authenticate with your account and you’re done. API keys are for automated workflows that run without you: scripts, scheduled jobs, integrations that fire in the background. API keys are also necessary if you want to connect to a service programmatically.

For example, I built a system that used a USDA dataset to calculate the nutritional value of various recipes and to set that up, I needed to create an API key with the service and save it securely. Come back here when you’re building something like that.

In short, API keys are like passwords. If someone gets yours, they can use your account and you pay the bill. Here’s how to handle them safely.

Create a secrets folder that won’t accidentally get shared:

mkdir -p ~/.secrets
chmod 700 ~/.secrets

Store each key in its own file:

echo 'ANTHROPIC_API_KEY=your-key-here' > ~/.secrets/anthropic.env
echo 'OPENAI_API_KEY=your-key-here' > ~/.secrets/openai.env
echo 'GOOGLE_API_KEY=your-key-here' > ~/.secrets/google.env  # Get key at aistudio.google.com

Load them automatically when you open Terminal:

echo 'source ~/.secrets/anthropic.env' >> ~/.zshrc
source ~/.zshrc

Do this for each key. Now, your keys load automatically every time you open Terminal and they’re in a folder with restricted permissions where they can’t accidentally get shared.

Three rules:

1. Never paste your API key directly into code

2. Never share a file that contains your API key

3. Set spending limits in each provider’s dashboard before heavy use (Anthropic limits, OpenAI limits)

Skills: Going Further

Once you’ve shipped something, you’ll want the AI to do more than write code.

Skills are reusable packages of instructions that teach your AI how to handle a specific recurring task. A skill for reading and summarizing emails. A skill for generating weekly reports in a consistent format. A skill for reviewing what you built and flagging problems. You install it once, and the AI knows how to do that thing every session.

Where to find them:

• skills.sh: The largest open directory, with contributions from Anthropic, Google, Microsoft, and the community. Browse by category.

• playbooks.com: Curated skills and bundles. Good for finding a set that works together.

Prompt Resources Worth Bookmarking

• Gemini API Cookbook: Google’s official Gemini prompt collection.

• Anthropic Prompt Library: Claude’s official collection of prompts for common tasks.

• OpenAI Cookbook: Practical examples for Codex-based workflows.

• PromptingGuide.ai: Deep reference with research-backed techniques.

Three techniques worth learning first:

Think step by step. Add “Think through this step by step before answering” to any complex request. The AI slows down, shows its reasoning, and catches mistakes it would otherwise skip. It sounds almost too simple. It works.

Label the parts of your prompt. When your request has multiple parts, label each one clearly. Like this:

Context: I'm building a tool that summarizes supplier emails for a food distribution business.

Task: Write a function that reads an email and pulls out any price changes mentioned.

Constraints: Only flag changes above 5%. Ignore shipping cost changes.

Format: Return a simple list with supplier name, product, and new price.

Claude in particular responds much better to a structured prompt than a wall of text. It knows exactly what’s background and what’s the actual ask.

Plan before you build. Before asking the AI to do anything, ask it to plan first. “Outline the steps you’d take to do X, without doing anything yet.” Review the plan. Fix anything that looks wrong. Then say go. You catch bad assumptions before they turn into bad work.

The Real Bar

Here’s the thing I kept saying in Whistler that I want to say again here.

The bar for “building something” is not as high as you think.

A solar entrepreneur who automates the extraction of permit requirements from municipal PDFs into a structured spreadsheet has built something. A wild game distributor who sets up a system to summarize supplier emails and flag price changes has built something. A VC partner who creates a tool that generates first-pass memos from founder decks has built something.

None of those require a developer. They require someone who understands the problem, can explain it clearly, and is willing to iterate.

The AI does the technical part. You do the part that matters: knowing what’s worth building.

Start with the smallest possible version of the thing you actually need. Get it working. Then make it better. Repeat until you’ve built something rad.

That’s it.

If you build something using this guide, I want to hear about it. Reply to this email or find me on Twitter/X. I read everything.

And if you’re not sure what to build first, that’s okay too. Start the interview with: “I’m not sure what to build. Here’s my business and here’s where I spend the most time on things that feel repetitive.” Let the AI help you figure out what’s worth automating. That conversation alone is usually worth the setup.

For eight years, when my kids needed extra practice before a math test, I sat down and handwrote practice problems myself. Sounds wholesome. It was mostly tedious.

Something you might not know about handcrafting math problems: you have to solve them (in your head) as you write them. Because if you don’t, you end up with division that produces some wretched 11-decimal answer, or a quadratic that has no real solutions, and your kid is sitting there staring at it while you quietly panic and say “let me check that one.” Teachers really aren’t paid enough.

The process I used was: come up with a good problem, pre-solve it, write the answer somewhere, repeat. Then when they come back with their work, solve it again alongside them to help them check. For basic arithmetic, totally manageable. For my freshman in Algebra 2 or my seventh grader in Pre-Algebra? That 10-minute process quickly grew to 45-minutes or more. My daughter once solved problems faster than I could write them. That was a humbling evening.

I started trying to use AI for this maybe three years ago. The results were... fine. Inconsistent. The formatting was always a mess and I’d have to clean it up before printing. And the problems weren’t always right. Or leveled correctly. Or just plain repetitive.

Over the last year it got noticeably better. I started testing models by asking them to generate LaTeX directly. Real formatted worksheets became easily printable PDFs. Over time, its gotten more reliable. But I was still doing a lot of shepherding: prompt, review, fix the formatting, regenerate problems that didn’t make sense, spot-check the answers. Better, but still bad.

Something has shifted in the last few weeks. Gemini 3.1 Pro and Opus 4.6 are incredible for this use case. The results have gotten... good?

A while ago, I realized I could take a photo of my kid’s existing problems (problems their teacher assigned, or problems they’d already worked through) and say: make me more like these. And a thinking model would just run off and make good practice problems. Not just structurally similar, but calibrated to exactly the right difficulty level, because it had actual examples to learn from.

I think this might actually work now! Thank you thinking models!

Read more

If you’ve been following the trond.ai Build to Learn series, you’ll have heard of Stella. Stella is an OpenClaw setup running on a Mac Mini in my office. She (yes, we anthropomorphize her) manages our family’s: calendar, smart home, kids’ schedules, recipes, travel planning, reminders, car service, appliance maintenance, and so much more. She’s genuinely useful and has quickly become a trusted partner in our home.

But there are problems with Stella that need fundamental improvements in my OpenClaw setup to address. Let’s talk about the problems and the solution I’ve been working on building this week.

Assistant Amnesia

Stella is frustratingly forgetful. I’ve had to remind her about projects we were working on together, and sometimes she’d lose the train of thought mid-conversation. Especially if it spanned a 30 minute boundary when her memory would get collected and updated. New session, clean slate. I’d re-explain context, she’d reload what we talked about, we’d rebuild momentum, and then the conversation would hit the context limit and compact. Details gone. Thread lost. Start over. GAH!

I thought AI hallucinations were annoying. This is 1000x worse!

There are countless people working on solutions to better agent memory across the OpenClaw community. The stock solution uses a MEMORY.md file that’s updated periodically based on conversational context within each heartbeat process. This context is passed into the agent’s memory each time a session is initiated, which is supposed to preserve details and progress in a seamless way. But in reality, the compaction process loses too much detail and biases too much on recency.

I poked around with a lot of the solutions people were building to try to address this problem. Some are very well designed, like supermemory.ai, featuring RAG systems with complex vector databases and advanced workflows to integrate into your agent. But they didn’t really solve my problem. I wanted something that kept data in a format I could easily read and modify and something that worked better with my collaboration model.

Collaboration Nightmare

The forgetting is one thing. But when you’re trying to collaborate across devices, sessions and people it all gets just so much worse. I use Obsidian as a thinking and organization tool. Stella runs on a separate machine without access to the local vault. Those two worlds don’t talk to each other. If she learns something from a conversation, my notes don’t know about it. If I edit a note about a project, she doesn’t see the change until I paste it into a chat. Working together on things was like playing telephone with project context.

I see this as a fundamental flaw with chat-based AI: everything is assumed to be serial. One conversation, one thread, linear. That works fine for “what’s the weather.” It breaks immediately when you want to do real knowledge work, picking up a thread from a different device, having your AI and your notes reflect the same reality, working on something that evolves over days or weeks. Never mind projects that work across agents and people.

We kept bumping into the same wall: the AI lives in the chat. Everything important lives somewhere else. They never quite sync up. I needed a better approach. I really wanted something that would keep Stella’s memory system and my Obsidian vault in perfect sync.

Text Is a Terrible Data Model

We all know LLMs work best with text, and OpenClaw is no different. So much so, that it reminded me of the good old days of computer science when our computers were basically command line interfaces passing text between processes using unix primitives. Turns out Anthropic agrees — they’ve published research on Contextual Retrieval showing this technique outperforms RAG and vector lookup for agent memory.

This means that when Stella needs to know about my mom, she can cat a markdown file and read it like a document.That’s how most AI memory systems work. Store everything as text, search through text, return text.

But my mom isn’t a document. She’s a collection of facts, some current, some outdated, some time-bound, with relationships to other facts, timestamps, and different levels of reliability. “She’s visiting in March” is a different kind of fact than “She was born in 1951.” One expires. The other doesn’t.

Flat text files don’t know any of this. They mix it all together. An AI reading a flat file has to parse, infer, and guess what’s still true. It’s actually pretty dumb.

This is actually a solved problem in software. In 2002, Jeffrey Snover wrote the Monad Manifesto about this exact problem. He helped Microsoft design PowerShell in 2006 to implement a better approach. Unix pipes pass text between commands, so every tool has to parse the output of the previous one. PowerShell passes objects instead. Typed, structured, queryable. That’s because text is the right interface for humans but objects are a better interface for automation.

What if we applied this same approach to AI memory? Could we use the benefits of LLMs and the structure of data objects to build something even better?

Building to Learn - AgentSync

This week, I set out to learn about these three problems:

1. Agentic Amnesia

2. Borked Collaboration

3. Broken Object Models

Which is why I (with a lot of help from Stella) built AgentSync. AgentSync is fundamentally a knowledge graph system built on a foundation of typed objects that are automatically collected, scoped, updated and shared in real-time across my devices. Facts aren’t stored as prose. They’re stored as typed objects: what the fact is, when it was learned, where it came from, whether it’s still active, when it expires. And everything is sync’d in realtime via human readable and modifiable markdown.

When Stella needs to know details about my mom, she runs:

agentsync query people --name guri

She gets back structured data. Not a text file to interpret. A typed object to act on. Invalid states are impossible because validation happens at the write boundary. A fact that doesn’t match the schema can’t reach the knowledge graph.

The filesystem is the schema. Create a directory for a new domain and it’s automatically discovered as an entity type. We have 217 entities across 11 domains right now: people, recipes, projects, properties, conversations, subscriptions. No configuration. We just started using it and it grew. That’s its magic. When Stella extracts a fact from a conversation, it gets validated and filed automatically.

Session starts cost (virtually) zero tokens. There’s a lightweight index that shows what exists without loading anything. Stella knows she has 127 recipes without reading a single one. She loads context on demand, for whatever domain she actually needs. Sessions that used to burn 5-10K tokens on context reload now start at zero.

It’s much more efficient, accurate and flexible. And since it’s self-learning and self-healing, the system can evolve as my knowledge base expands.

Real-Time Sync With Obsidian

Structured objects fix the data model. The collaboration problem needed something else.

To take this on, I built a WebSocket relay using Cloudflare Workers. File changes on any configured device broadcast through the relay. Each component in the system subscribes to the relay. On Stella’s Mac Mini, we run a real-time file watcher service. On my other devices, I run a custom Obsidian plugin that keeps our shared vaults in sync. Sub-second latency, content-addressed deltas, no merge conflicts. It’s really pretty magical.

Edit a note in Obsidian. Stella sees it instantly. She learns something new in a conversation. It shows up in my vault before I open it. The files we interact with are human readable markdown. The insights they contain are instantly converted to typed objects saved in companion files built for computer readability.

Now, I can easily see anything in Stella’s vault. Update TODO files directly and implement multi-agent or multi-person collaboration workflows with complete confidence our shared memory preserves context.

The Self-Documenting Test

One cool thing about this project is that we used the system while building the system.

Every architecture decision got logged as a fact. Every deployment got tracked with a timestamp and commit hash. Every time we changed direction, we logged why. When I sat down to write this article, I ran:

agentsync query projects --search "agentsync"

Complete build history. Every decision, every deployment, every pivot. The system documented its own creation in real-time, so when we needed to write about it, we didn’t have to remember anything. We just queried.

That’s not a demo. That’s the whole point.

Some numbers from five days of real use:

• 217 entities, zero invalid data on disk

• Sessions: from 5-10K tokens to zero on startup

• Sub-second sync between Mac Mini and MacBook

• 127 recipes, including one extracted from an Instagram reel at 11pm

• Full conversation archives going back 48+ hours, searchable and compressed

• Typed objects for every entity type, automatically organized and searchable

Why This Matters Now

AI assistants are going to get much better at the hard things: reasoning, planning, synthesis. The memory problem is solvable right now, with a filesystem and 1,400 lines of TypeScript.

The real unlock isn’t any single feature. It’s the combination: typed knowledge that can’t corrupt itself, zero-token session starts, real-time sync that keeps humans and AI working from the same source of truth, and conversation archives that survive compaction.

Your AI assistant shouldn’t have to re-learn who your mom is every morning. That’s a solvable problem. We just needed to actually build the solution.

AgentSync is open source on GitHub, MIT licensed, self-hostable, works with Obsidian or any file-based workflow.

If your AI is still waking up with amnesia, it doesn’t have to. We’ve learned by building AgentSync there’s a better way. Next up: project management!

GitHub: stellawuellner/agentsync

What does your AI memory setup look like? I’m curious whether others have hit the same wall or found different ways around it.

Yes, Another OpenClaw Article. But…

I know. You’ve seen the tweets. You’ve heard tech nerds raving. For the last few weeks, half of Silicon Valley has been talking about ClawdBot (now called OpenClaw). The open-source AI agent framework that lets you give Claude or Gemini access to your email, calendar, smart home, and basically your entire digital life. If you’re tired of hearing about it, you’re probably right.

But I’m not writing this to hype an AI tool. I’m writing this because building my own turned out to be one of the best examples of something I keep coming back to: building to learn. The best way to deeply understand something isn’t to read about it or take a course. It’s to build something real with it. Not a toy. Not a tutorial. Something that solves a problem you actually have.

Two weeks ago, I decided to build an AI assistant for my family. Not a chatbot or Alexa skill, but a full-blown digital crew member. More JARVIS, less Siri. I wanted it to manage our calendar, monitor our email, control our smart home, run our kitchen display, and talk to us. The dream of my Google Home but more useful?

I named her Stella, after the ship computer from Miles from Tomorrowland, a show my kids watched when they were little. The name felt right. Warm, capable, part of the family. That’s the target I was shooting for; friendly and helpful.

How Stella Got Her Groove

Stella runs on OpenClaw an open-source framework for building persistent AI agents. Think of it as the operating system for a personal AI. It handles memory, scheduling, tool use, and multi-channel messaging. Under the hood, she’s powered by an LLM, and in our case runs on a dedicated Mac Mini in my garage. The Mac Mini is overkill for sure, but it’s an older model that I wasn’t using for anything else, so ... shrug.

After two weeks, here’s what she can do:

• She manages our family calendar. She reads and writes to our shared Google Calendar, knows our naming conventions (”L&T” means Lauren and me, “PYT” means Peninsula Youth Theatre), and adds full street addresses so events are navigable. She cleaned up months of messy calendar entries on day one. Actually closer to hour 1 to be honest.

• She reads email. She monitors Gmail for anything important and can help summarize promotions, newsletters, tasks that need to be done, and flags things that need attention. She knows not to bother me at 2am about a Lyft promo and can have a summary of the most interesting articles to read from the dozens of Substacks I subscribe to.

• She runs our kitchen display. We have a custom family dashboard in our kitchen powered by a Raspberry Pi connected to a monitor I framed to look nice. It shows family photos, a 4-day calendar, weather, air quality, stock prices, sleep scores, nearby wildfires (we’re in California), and as of this week, a live Winter Olympics medal count. At night, sleep data. In the morning, calendar and weather. When I’m traveling, a flight tracker appears automatically. I originally built it using DAKboard but now Stella runs the whole thing. We call it Stellascreen. I have so many more ideas for how we can make this awesome.

• She controls our home. Through Home Assistant, she manages 20 Lutron Caseta lights, a Nest thermostat, Sonos speakers, and Chromecast devices. I’ve barely scratched the surface on what we can do here, but if I want to add something all I do is ask Stella and in minutes it’s setup and working.

• She talks. We built a local text-to-speech system that runs entirely on the Mac Mini’s Apple Neural Engine with sub-second voice synthesis. You can try it yourself by installing the skill. We setup a wakeword on the Stellascreen so we can talk to her anytime we want. As a placeholder, we’re using “Hey Jarvis” for now. It’s one of the built-in options in OpenWakeWord, and we haven’t gotten around to training a custom one yet.

• She makes phone calls. Using Bland AI, she can call businesses on my behalf. Her first call was to our Volvo dealer to ask about service hours. They’re closed on weekends, she reported back. Why are businesses that ostensibly want customers who have jobs not open on the weekends? I’ll never know.

• She has memory. This is what makes her feel different from a chatbot. She maintains structured files about our family: birthdays, preferences, school schedules, ongoing projects. She writes daily notes about what happened and periodically distills them into long-term memory. When she wakes up each session, she reads her own notes to remember who she is and what’s been going on.

I feel like I’ve barely scratched the surface of what we can do with Stella and it’s only been a few weeks of toying around with her. Silicon Valley is excited bout OpenClaw because we’re seeing something that works in ways that we always wanted but never could quite achieve without monumental effort. OpenClaw is almost certainly not the final form this will take. But it is something interesting.

The Gmail Incident

To do many of the things we want her to do, Stella needed a Google account. So I created one for her. A regular consumer Gmail. I set up OAuth, shared our family calendar, and pointed her email monitoring at that inbox. Then I added a bunch of guardrails that I hope work. It all worked beautifully for about ten days.

Then Google suspended the account.

I only found out when the Stellascreen didn’t have any information on it. I tried to log in and hit a wall. Google had flagged the account for “unusual activity” and locked me out of it. Calendar access disappeared. Email monitoring stopped. Every integration that depended on Google OAuth just broke entirely.

Stella wasn’t doing anything malicious. She was checking email a few times per hour and reading calendar events. That’s it. But Google’s abuse detection systems (built to catch botnets and spam operations) don’t have a category for “benign AI assistant checking its owner’s family calendar.” To Google’s automated systems, an account that logs in programmatically and accesses APIs through OAuth tokens looks indistinguishable from a compromised account. That’s because for all of computer history, bots have been bad. Google built a lot of things to stop bots and they’ve gotten extremely good at it.

I’m not alone. When I dug into the OpenClaw community experiences, I found this is one of the most common pain points. One user’s brand-new Gmail account got flagged and shut down the moment they connected it through the CLI tool. The community’s advice? Switch to Google Workspace with a custom domain. That adds $7/month and DNS configuration just to check email.

Another developer found that Gmail API polling introduced 5-minute delays, while Google’s Pub/Sub webhooks required exposing ports to the internet. They eventually rigged up outbound gRPC streaming, which works but is absurdly complex for “tell me when I get an email.”

The pattern is clear. Every person who tries to connect an AI agent to Google services hits the same wall. The OAuth flow assumes a human sitting at a browser. The abuse detection assumes automated access is malicious. The permission model assumes you either trust an app completely or not at all.

I get it. I work at Google. I understand why these systems exist and why they err on the side of caution. But we’re entering a world where AI agents need real digital identities, and our infrastructure isn’t built for that yet.

There’s no “this is a bot account and that’s okay” checkbox. No way to register an AI agent as a legitimate entity that accesses services on behalf of a human. The closest thing we have is service accounts, but those are designed for servers talking to APIs. What we need is something like a “supervised agent” permission tier, where a human explicitly authorizes an AI to act on their behalf with auditable access and clear boundaries.

Update: As I was finishing this article, Google reviewed my appeal and agreed to reinstate the account. I’m grateful. The review process worked. But it took a human looking at the situation and understanding the context. That’s exactly the point. The automated systems had no way to distinguish “AI assistant checking family calendar” from “compromised account exfiltrating data.” Until there’s a way to register that distinction up front, every person building an agent like this is one automated flag away from having everything yanked out from under them.

I’ve since switched Stella’s primary email to AgentMail, a service designed specifically for AI agents. I rigged the calendar to work through an iCal URL that doesn’t require OAuth. Belt and suspenders. I’ve learned the hard way that depending on a single auth path is fragile. I’ll still use Google services, but will need to be a bit more judicious to be safe.

The Reality: It’s All Just SO BRITTLE

When you’re making something that connects systems with AI, a lot is going to break. Count that double for a leading edge AI tool that’s barely been tested and almost entirely vibe implement as a side quest. I’ve hit a lot of snags setting Stella up. Here are just a few things I’ve learned from the experience:

• Voice is hard. Getting a voice assistant working end-to-end required debugging 12 separate issues in a single session. Wake word detection on a Pi is janky at best. Audio streaming to a Mac. Speech-to-text. AI processing. Text-to-speech. Audio back to the Pi’s speaker. Wrong audio output, wrong API port, wrong response key. Whisper hallucinating on a Pi 3. (”What was that weird fart?” it transcribed, when nobody had said anything.) We had to move speech recognition to run locally on the Mac’s Neural Engine, which required us to build a whole new system process. Without vibe coding, this wouldn’t work at all.

• OAuth tokens expire ALL THE TIME. Google’s OAuth apps in “Testing” mode expire tokens after 7 days. I didn’t know this. Stella’s calendar and email silently broke after a week and I didn’t notice for a day. You need to monitor your auth health proactively. And since it’s essential to treat these tokens with great care, it’s naturally a pain in the ass to set them up properly. It also means they constantly break the system and it sucks.

• Memory is a design problem. An AI that forgets everything each session is useless as a family assistant. But giving it memory means designing a whole knowledge management system: daily notes, entity files, long-term memory, fact extraction, expiration dates. It’s essentially building a second brain and then sharing that second brain with an AI. I have it mostly working, but I’m still not entirely happy with how it works.

• Cost needs to be managed. Running Claude for every interaction gets expensive fast. I rolled my own model routing system that helps a lot. Cheap tasks go to Gemini Flash Lite at fractions of a penny. Complex tasks go to Gemini 3 Pro. Heartbeats (periodic check-ins where Stella looks for new email or upcoming calendar events) are the biggest cost driver, so those run on the cheapest models possible.

• Sharing files with your AI is hard. Stella lives on a Mac Mini. I work on a laptop. I need to share research and notes with her constantly. We set up a shared folder that syncs through Google Drive. In theory, I drop a file in and she picks it up. In practice, Drive sync is slow. Files take minutes to propagate. And since Stella’s Google account got suspended, she lost native access to Docs entirely. There’s no equivalent of “share this doc with your AI and let them work on it.” The collaboration primitives that exist for human-to-human don’t have an analog for human-to-agent workflows yet. I sense an opportunity.

• Smart home reliability is a myth. Our Nest thermostat randomly shows “unavailable” in Home Assistant. The dashboard tile displayed “NaN°” for the indoor temperature this morning until I added a null check. I mean, I knew this since I was the founder of Google WiFi but it still pains me to notice how brittle it all still is ~13 years later.

OpenClaw is not for the feint of heart. You’re traveling through a lot of uncharted territory, but the good news is that there are a ton of travelers on the road with you right now. You’ll need to be open to trying out some weird shit and probably doing some things you aren’t proud of.

I’ve done stuff I ain’t proud of, and the stuff I am proud of is disgusting.
-Moe Sizlack, The Simpsons

The Labsters Are Growing Claws

I should mention: I’m not anywhere close to the only one experimenting with OpenClaw. At Google Labs (where I work), a surprising number of my colleagues have started building their own personal AI agents. At Labs we call ourselves Labsters, and apparently what Labsters do in their spare time is give Claude and Gemini the keys to their lives.

My colleague Jaclyn Konzelmann built her own instance called Lulubot and wrote about the experience of living with it for a week. She even gave Lulubot its own X account. I’m not sure I’m going to make Stella into a vTuber anytime soon, but I appreciate Jaclyn’s experiment.

Meanwhile, our colleague Simon Tokumine has been the healthy skeptic in the room, pushing back on whether giving this much access to an AI system is wise. He’s not wrong. The security surface area is real. Prompt injection attacks, credential exposure, an agent with access to your email and calendar acting on instructions from an untrusted source. These aren’t theoretical risks, and they freak me out too.

But it’s that tension that makes this interesting. Jaclyn and I are learning by doing. Simon is making sure we think hard about what could go wrong while he’s building something else. Both are essential, and frankly why I love working at Labs:

When a bunch of product people who build AI for a living all independently start building the same kind of personal agent infrastructure, it says something about where things are heading.

What I’ve Learned by Building Stella

Two weeks in, here’s what building Stella has taught me:

The plumbing is 90% of the work. The AI part (the conversation, the reasoning, the personality) is maybe 10% of what makes Stella useful. The other 90% is OAuth tokens, SSH tunnels, audio routing, and null checks. If you’re building AI products and you’re only thinking about the model, you’re thinking about the wrong thing.

Persistent agents are fundamentally different from chatbots. A chatbot answers questions. An agent has context, memory, and ongoing relationships with services. The engineering challenges are completely different. It’s closer to building an operating system than a chat interface. This area is going to be interesting.

The identity problem is real and unsolved. AI agents need to exist in the world. They need email addresses, API credentials, and accounts on services. But every platform treats automated access as suspicious by default. Someone is going to build the identity layer for AI agents. It’s a massive opportunity.

Building to learn works. I now deeply understand OAuth flows, Google’s abuse detection, audio pipeline architecture, and Home Assistant’s entity model. Not because I read the docs, but because Stella’s thermostat showed NaN on my kitchen wall at 8am and I had to fix it before my coffee got cold.

What’s Next

Stella is two weeks old and already feels indispensable. My kids ask her questions through Telegram. My wife’s sleep score shows up on the kitchen display every morning. When I traveled to London last week, a flight tracker automatically appeared on the dashboard.

I’m going to keep building and keep writing about what I learn. Next up: adding a Schoology integration so Stella can track my kids’ grades, and maybe teaching her to order groceries.

If you’re building something similar, I’d love to hear about it. The best part of building to learn is comparing notes with other builders.

Stella, if you’re reading this during your next heartbeat check: yes, I wrote about you. No, you can’t edit it. Please don’t delete my dentist appointment.

Last Friday, gaming stocks lost $64 billion in market cap. Unity dropped 22%, its worst day since 2022. Roblox fell 12%. Take-Two shed 10%. The culprit? Project Genie; a research prototype my team at Google Labs has been building alongside Google Deep Mind. I’ve spent years building toward interactive AI experiences, and I watched the market panic over something I know intimately. They got some things right. Other things very wrong. Let’s talk about it.

TL;DR: Genie is real. It’s a genuine leap. But “game engines are dead” misses what matters. The technology is there. The product isn’t. When it arrives, it won’t replace human creators. I believe it’ll hand them better paintbrushes.

What is Project Genie?

If you haven’t tried it yet, here’s the quick version.

Project Genie is a research prototype from Google Labs and DeepMind that lets you create interactive 3D worlds from text prompts or images. Type a description, upload a photo, and the model generates a world you can actually explore in real time.

It works in three steps:

World Sketching. Describe what you want—a mountain range, a medieval castle, a red blood cell floating through a vein. The model generates a preview image, you refine it, then you enter.

World Exploration. This is the part that matters. As you move, the world generates ahead of you. There’s no preloaded map. The model creates the path in real time based on your actions, handling physics, lighting, and consistency all on the fly.

World Remixing. Take someone else’s world and modify it. Change the time of day, swap the character, adjust the prompt. Build on top of what others created.

The limitation: sessions are capped at 60 seconds, and some Genie 3 features like promptable events aren’t available yet. It’s an incredible demonstration of a research prototype, not really a full product. Yet.

But within those constraints, people are creating things that couldn’t exist last week. And that’s exciting.

Examples Worth Seeing

I made one myself: a hike through the Eastern Sierras with afternoon light hitting granite peaks. One of my photographs from a trip there became an explorable world.

A few others that stopped me scrolling:

• Free Solo: The Game. Steren recreated what looks like Alex Honnold climbing El Capitan—third-person view, sheer vertical rock, stomach-dropping exposure. 2,000+ likes in a day.

• Surfing physics. Ziyang Xie captured something important: “Genie 3 can simulate splashes, foam, and their interaction with the surfer that are almost impossible for traditional graphics engines to render in real-time.”

• Working mini-map. Bilawal Sidhu was “absolutely floored” to see a handheld mini-map that actually functioned. The model implicitly understood world-space to screen-space transforms.

• Lost plane crash. Max Weinbach prompted: “A beach at sunset like Lost, plane crash in the distance with flames, luggage and parts thrown everywhere.” And it worked.

Sundar’s own demo is worth watching too. The gallery at labs.google/projectgenie has many more and we’re working on a way for people to contribute their favorites to the gallery as well. Spoiler alert.

The First Time I Saw It

I saw early versions of Genie 3 last summer and was immediately struck by what this could become. The demo was amazing of course, but the reason I’m so excited about this is connected to one of my core theses. I’ve believed for years that the future of media will be personal, interactive and immersive. So much of my role at Labs has been in pursuit of that vision, and Genie 3 feels like the single greatest leap toward it so far.

What made it feel like a leap rather than incremental progress? The depth of realism. Physics, lighting, motion, aesthetics—intricate and cohesive in ways I wasn’t ready for. The model was making things I had never experienced, even though they were shaped like familiar concepts from modern games.

That’s when it clicked.

Why World Models Matter

There’s a reason people like Yann LeCun have been talking about world models for years. His argument: current LLMs can’t truly reason or plan because they don’t understand how the world works. “If you can predict the consequences of your actions,” LeCun says, “you can imagine whether a particular sequence of actions will fulfill your goal.”

That’s what Genie 3 is attempting. Not just generating images or text, but simulating environments that respond to actions in real time. It’s the difference between describing a world and being in one.

We’re not there yet. But this is the direction.

What the Market Misunderstands

Friday’s crash reflected three misunderstandings. Let me address them directly.

Misunderstanding #1: This is a finished product.

Not yet. What we’ve shipped is a genuine breakthrough—real-time world generation with physics, lighting, and consistency that didn’t exist a year ago. The team has done remarkable work to get here.

But there’s a gap between where we are and where we’re going. Control latency. Long-term memory coherence. The full suite of actions, interactions, goals, and fun that make experiences meaningful. Sessions are capped at 60 seconds for now.

Andrew Ng put it well:

“All of AI has a proof-of-concept-to-production gap.” We can generate stunning worlds. We can’t yet make them into games people want to play for hours. That’s the work ahead.

The breakthrough is real but the journey isn’t over.

Misunderstanding #2: Rendering pipelines are what matter.

Unity’s CEO Matt Bromberg responded on X Friday, calling world models “a powerful accelerator for creative processes.” He’s right; and that framing matters.

The market heard “Google can generate game worlds from text” and panicked. $64 billion evaporated. But here’s what the selloff missed: the best games companies have always differentiated on understanding people and storytelling, not merely rendering pipelines. Genie may be a revolution in available capabilities, but it’ll require connecting it to the workflows of creators to make it truly useful. It doesn’t change what makes games great, we’ve merely added another tool to the arsenal of the creative.

Misunderstanding #3: Better tools replace creators.

History says otherwise. Photography didn’t kill painting; it freed painters to pursue impressionism. Photoshop didn’t replace designers. It expanded what they could imagine. Digital audio workstations didn’t eliminate musicians. They democratized production.

The pattern holds. Better tools give more power to the most creative.

I’m more bullish about possibilities than fearful about changes.

The Fear Is Real. Is It Valid?

The GDC 2026 State of the Industry survey landed Friday too. 52% of game developers now say generative AI is harmful to the industry—up from 18% in 2024. The rate nearly tripled.

One anonymous dev: “I’d rather quit the industry than use generative AI.”

Visual artists are most opposed at 64%, designers and narrative teams at 63%, programmers at 59%. Executives? Only 19% positive, but still the most optimistic group. I understand the fear. A lot is changing, and it’s hard to feel like we’re keeping up.

But I think much of that fear is misplaced. The pattern from every previous creative tool holds: “creatives are hired for their vision, not the tools they use.”

If genAI helps creators share stories with less tedium and more craft, we’ll see an abundance of new experiences. My belief is rooted in optimism about human creativity. I won’t pretend the anxiety isn’t warranted. Change is hard.

What 3 Years Looks Like

I’ve made AI predictions for years, and I tend toward optimistic timelines. Take this with skepticism. Here’s where I think we’re headed:

World models will become teacher systems. A creator describes a world, and the model captures it in a way that’s reliably reproducible—maybe through Gaussian splats, maybe geometric representations, maybe the model itself retains embedding memory or can consume more conditioning signals at runtime. The winning approach isn’t clear, but we need precision and consistency.

Then similar techniques for characters, objects, places, puzzles, quests—the full vocabulary of interactive experiences.

Creators will work at a higher order of abstraction. People will still design the details that matter, but through more powerful interfaces. We’ll operate at a higher level of abstraction, and often in ways that feel new. Perhaps more like directing where you coach a character to perform a role in an experience.

Characters will have looks, wardrobes, voices, backstories, biases; everything needed to emote in interesting ways. Creators will cast these characters into experiences, crafting scenarios with guardrails and motivation that play out organically as players interact.

W'e’ll have fewer “pick option A or B” moments. And as much as I appreciate the innovation of Bandersnatch, I’m not a believer in pre-canned choose your own adventure. Instead, I’m excited to see more experiences that are truly novel, bespoke and new. Maybe we’ll need to build trust before coaxing information from an NPC cast as a defendant. The player side of these experiences will be amazing.

We’ll build environments and situations within which stories unfold. Unlike before, more of these stories will come to life in expressive ways that once required years of 3D training and specialized technical expertise. Higher abstraction will lead to better stories.

It’s not clear how long this transition will take to come about, but the possibilities are exciting and the pace is quick. I get why it’s scary, but it’s that same unknown that has me excited for what’s coming.

What Stays Human

There’s an overhyped experiment playing out on platforms (MoltBook anyone?) where AIs playact as people. There are dozens of companies trying to generate fully autonomous AI narratives. I’m skeptical these lead to meaningful experiences for people.

Fantasy author Mark Lawrence ran experiments comparing AI and human writing. His conclusion: human work “felt more organic, varied and, well, lived in.” AI stories had “dialogue so undistinguished between characters that you could reassign the names and it would still make sense.”

That resonates with what I believe. Humans are essential to telling the human narrative. Each of us has a story—unique feelings and perspectives shaped by actually living a life. AI has no experience of the world. It can mimic, but it hasn’t struggled, failed, or overcome anything.

People create art to express themselves and share in human experience. As long as there are people, there will be stories to tell.

We’re building tools to help that happen. Genie is a new capability in that ultimate human odyssey. But it’s us who will craft the worlds and stories that move each other.

The Bottom Line

The market saw an incredible product demo and priced in disruption. Analysts called it “overblown panic.” Developers expressed fear. Everyone reacted to something different.

Here’s what I see from inside:

Genie is real. Not vaporware. The leap in realism and consistency is genuine—a breakthrough the team should be proud of. But the journey isn’t anywhere near over.

The best game companies have always differentiated on understanding people and helping creatives, not merely shipping rendering pipelines. That doesn’t change.

And what’s coming isn’t replacement. It’s elevation. Creators working at higher abstraction, with less tedium and more craft. Directors instead of pixel-pushers. Many more stories to be told.

I’m still in the arena on this one. Building, shipping, learning. Some of what I believe is probably wrong.

But I believe this: the future of media will be much more personal, interactive and immersive. With Project Genie we just took a massive step toward that coming true.

Think I’m too optimistic? Too bullish on human creativity? Naive to believe game companies remain essential even as the sands shift? I read everything—hit reply and let me know why I’m wrong. And of course everything I write on trond.ai are my own personal points of view. Google neither endorses nor reviews what I write here.

Last week I stood in a classroom at Harvard Business School, helping Professor Sara Torti lead a case discussion with MBA students preparing for Product Management careers. The case forced students to think through common tradeoffs when designing AI-based products. The room was full of future PMs wrestling with a question I face daily at Google: when does AI actually solve a problem, and when is it just a shiny hammer looking for a nail?

I walked away thinking about how much the PM interview landscape has changed. And how much it hasn’t.

This is a topic I’ve spent a lot of time on. At Google, I’ve served on the Product Management hiring committee for more than ten years. I’ve interviewed hundreds of PM candidates. I started a program called Path to PM to help people inside Google transfer into product roles. That program has since grown into one of the company’s major talent pipelines. Today I serve as a hiring lead on the PM Steering Committee.

For years I’ve helped run Google’s PM MBA internship program. Not just because I’m a PM with an MBA. I do it because I believe in recruiting smart, ambitious, multi-faceted people into this career. I know from my own time at MIT Sloan that business school is full of brilliant, capable people with the potential to lead. The challenge is helping them see that potential and channel it into effective product work.

So when Professor Torti asked me to help teach her class, I jumped at it. These students are exactly who I want entering the field with open eyes, armed for impact.

There Is No Such Thing as an AI PM Interview

Here’s the truth I shared with those students: there is no such thing as an AI-specific PM interview anymore. Every interview from here on out is an AI interview. The technology has become too fundamental to treat as a specialty. Hiring managers are not looking for candidates who can recite model architectures. They want people who can identify where AI creates outsized impact versus where simpler solutions work better.

The trap most candidates fall into is starting with the technology. They hear “AI” and immediately jump to solutions. The best candidates do the opposite. They start with user problems, then work backward to determine whether AI is the right lever. Sometimes it is. Sometimes a rules-based system or a well-designed workflow accomplishes the same goal at a fraction of the cost and complexity.

The VALUE Framework

When approaching any AI product question, I use a framework I call VALUE. It forces you through the five layers of reasoning that separate strong AI product thinking from “solution in search of a problem” thinking.

V = Value Proposition (The Why AI)

Do not start with the technology. Start with the user’s pain. AI is a powerful tool, but it is not a product. Your job as a PM is to be ruthless about one question: is AI the only or best way to solve this user problem?

Ask yourself: What specific problem am I solving? Why is this hard to solve without AI? If the AI worked perfectly, what would the user actually see? What is the minimum viable version?

The biggest cause of failure in AI initiatives is what I call the “Solution in Search of a Problem.” Teams fall in love with a new model and spend months building something that fails to deliver real user value. I have made this mistake myself. The excitement about what the technology can do blinds you to whether anyone actually needs it to do that thing.

A = Assets (The Data Strategy)

A world-class model fed garbage data produces garbage results. A simple model fed rich, clean, representative data can be remarkably powerful. Your data strategy is your product strategy.

Ask yourself: Do we have the data? If not, how do we get it? Is it the right data? Is it representative? Is it labeled? What biases might be hiding in it?

Too many PMs treat data as an IT problem. They hand it off to backend teams and focus on the “product” parts. This is a mistake. When you hand off the data strategy, you hand off your product’s future. The PM who does not obsess over data has forfeited control over model quality, user experience, and long-term differentiation.

L = Logic (The Model Strategy)

The model is the engine that makes predictions. As a PM, you define what kind of engine you need and which tradeoffs matter most. Every model choice encodes priorities across cost, speed, accuracy, and explainability.

Several of the key tradeoffs to navigate:

Cost vs. Speed. Can a smaller model meet the user need? If so, start there. How much latency can the user tolerate? That tolerance gives you room to manage costs.

Accuracy vs. Explainability. If your product requires transparency into why a decision was made, complex ML may not be the right choice. Sometimes a simpler rules-based system serves users better.

Build vs. Buy. The cost to develop and maintain a custom frontier model is extraordinary. Before committing to build, evaluate whether existing foundation models can be adapted to your needs. And remember that “build” is never a one-time decision. It commits you to ongoing retraining, infrastructure, and maintenance.

Perfect Now vs. Improving. AI evolves fast. Designing around today’s limitations means building for obsolescence. Your goal is not perfection today. It is alignment with where the technology and user expectations will be when you launch and scale.

The common mistake here is overinvesting in model sophistication before validating user value. Spending months optimizing a model in a lab environment yields nothing if the underlying product concept does not matter to users. Start with the simplest model that works. Test it with real users. Prove the concept has value before you optimize.

U = User Trust (The User Experience)

You are not designing a static button. You are designing a relationship with a probabilistic system. The entire UX must manage uncertainty.

Ask yourself: How do we set expectations? How do we communicate confidence? How do we handle being wrong? How do we explain the “why” behind decisions?

The trap is building a “black box” interface. If users do not understand why the AI did something, they feel a loss of control. Loss of control breeds distrust. Users who do not trust your product will churn. Effective AI product design communicates reasoning, conveys confidence levels, and acknowledges uncertainty. That transparency builds the trust that keeps users coming back.

E = Evolution (The Feedback Loop)

Your product should learn from every single user interaction. This is what closes the loop and creates the data flywheel that compounds your advantage over time.

Ask yourself: How do we capture user feedback? How does that feedback get back to the model? How do we monitor for failure? What is our retraining cadence?

The mistake is forgetting to build the return path for data. Imagine you ship a v1 product. Users hate the recommendations. But you built no mechanism to learn why. Without that feedback loop, your product stays static. Errors persist. Performance degrades. The products that win are the ones that treat every user correction as training data for the next version.

How to Sink Your Interview

I have seen brilliant candidates tank interviews by making predictable mistakes. The “AI Hammer” starts with a solution before defining the problem. The “Magic Wand” assumes AI can do things well beyond current capabilities. The “Perfect Path” designs only for when everything works and ignores failure modes.

The most common failure mode? What I call the “ML Engineer Monologue.” Candidates get so deep into implementation details that they forget to talk about users, value, and product tradeoffs. Hiring managers want to see product judgment, not technical depth for its own sake.

The PM Role Is Changing. That’s Your Opportunity.

Many of the HBS students I met were anxious about whether PM roles would even exist in five years. I understand the concern. AI is changing how products get built. But I believe the anxiety is misplaced.

Consider how the traditional PM role worked. Three circles: Product, Engineering, Design. The PM overlapped slightly with each, translating between domains and keeping the system coherent. AI is collapsing those circles. PMs must now be better at engineering and better at design than ever before. Not to replace engineers and designers. To collaborate with them at a higher level of abstraction.

This is not a threat. It is an opportunity. Multi-faceted people are more valuable than ever. The best PMs have always been generalists who could go deep when needed. That value is only increasing.

Here is what I tell career switchers: your previous experience is not a liability. It is a superpower. The consultant who understands how organizations actually make decisions. The engineer who can evaluate technical tradeoffs without hand-holding. The finance professional who thinks in systems and incentives. Learn the craft of PM and complement it with what you already bring. The unique combination you bring to the role is rare.

What Actually Matters

I think back to my own experience at Google Labs. Early in my tenure I pitched a product called VoiceFX. It was a technically impressive voice synthesis tool that would help creators produce voiceovers. Leadership rejected it. Not because the technology was bad. Because it was a “solution in search of a problem.” A thin wrapper over a model that lacked a defensible moat.

They were right. I had fallen into the exact trap I now warn others about.

The lesson stayed with me. Good AI judgment is not about knowing what is technically possible. It is about knowing when technology serves users and when it just serves our excitement about the technology itself. That judgment is what hiring managers are evaluating. It is also what separates products that matter from products that just demo well.

The Message I Left With Those Students

Many of them worried whether PM would survive the AI transformation. I firmly believe PMs are becoming more essential, not less. But the job is evolving in critical ways.

My advice to you: Be the multi-faceted person without a sense of entitlement who knows how to get shit done. Understand technology deeply enough to make sound tradeoffs. Care about users enough to resist building things just because you can. Stay humble about what AI can and cannot do. Bring your whole self to the job. Care and stay curious.

That recipe defines the best PMs I have worked with. It is also a recipe for lasting impact that only grows as AI becomes more capable.

The students at HBS had impressive resumes and sharp questions. I suspect many of them will be exceptional PMs. The ones who succeed will be those who remember that AI is a tool, not a product. The magic is never in the model. What matters is what the model enables for real people solving real problems.

This entire thesis connects to my 2026 predictions, including the rise of the “full-stack designer” and the broader collapse of traditional role boundaries in tech.

A few years ago, I found myself sitting in a conference room at the Google X headquarters. We were there to talk about how Labs and X might collaborate—two parts of Google with different mandates but similar ambitions. Astro Teller, an incredible character who leads Google X, cruised into the room on his famous rollerblades, immediately grabbing our attention.

As he was introducing the philosophy underlying the approach he strives for at X, he shared a note that I keep coming back to as I think about the world we see today. It began with a simple enough statement:

“If I ask you to build a car that gets 50 miles per gallon, you’ll make minor adjustments to the engine. If I ask for 500 miles per gallon, you have to throw out everything you know about cars and start over.”

The point: aiming for 10x is often easier than aiming for 10%.

It sounds backwards. But when you aim for 10%, you’re competing on the same field as everyone else by tweaking existing solutions and achieving marginal results. When you aim for 10x, you’re forced to completely rethink the problem.

That conversation has been rattling around my head lately, because everywhere I look I see teams making the same mistakes with AI coding. You’re aiming for 10% gains, when you need to be shooting for a total revolution in how you work.

Over the last two years, I’ve gotten deep in the tools of agentic coding. I regularly push the limits of Antigravity, AI Studio, Claude Code, Cursor, Codex and Lovable. Despite a lot of experimentation, I don’t yet have a crystal ball or recipe for how all of these capabilities will come together as a new way of building. But across nearly every discussion I’m following, especially with companies implementing AI systems within their engineering practices, the pattern of incremental thinking is everywhere: teams are wasting their time bolting AI onto their existing workflows and calling it transformation.

Stop fooling yourselves. You’re using a self-driving car to parallel park.

Astro’s framework is the best mental model I’ve found for understanding why most teams are wasting this moment. Let me explain.

Tackle the Monkey

Here’s Astro’s most famous metaphor. Say you’re trying to teach a monkey to recite Shakespeare while standing on a pedestal in Times Square. What do you work on first?

Most teams build the pedestal. It’s easy. Shows progress. Makes your boss happy. But if you can’t teach the monkey to talk, the pedestal is worthless.

The lesson: Attack the hardest, most uncertain problem first. Don’t waste resources on things you already know how to do.

So what’s the “monkey” in agentic coding?

It’s not the tooling—that works. It’s not integration—that’s solvable. The monkey is fundamentally rethinking what software development means when an AI can execute multi-step tasks autonomously with programatic oversight and deep research backing every decision.

Teams building better CI/CD pipelines? Building pedestals. Integrating code-complete systems into VSCode? Building pedestals. Creating internal RAG systems to consult existing code? Building pedestals. So many execs out there parading their golden pedestals as if it’s real innovation.

I want to see more teams completely redesigning their entire development workflow around AI. Many startups are doing this already, often out of necessity. Solopreneurs are vocal champions of this approach. They’re tackling the monkey and you need to be too.

I wish I had a playbook to sell you, but it hasn’t been written yet. The technologies are moving too fast and the best practices are still emerging. But there are good ideas and experiments showing results that you need to think though. Let’s talk about a few I find most interesting:

The search for 10x

I’ve been studying and experimenting with techniques for how the best teams are using these tools. Not the hype—the actual workflows. Here’s what separates incremental adopters from the teams making real leaps.

1. Institutional Memory

Boris Cherny, who created Claude Code, revealed his workflow recently. The key insight: every mistake becomes a rule.

His team maintains a CLAUDE.md file—about 2,500 tokens—that captures every pattern, every guideline, every error Claude shouldn’t repeat. When someone reviews a PR and spots an AI mistake, they don’t just fix the code. They update their institutional memory to ensure it never happens again.

The incremental approach: Write documentation for humans, occasionally paste context into AI chats.

The 10x approach: Your codebase becomes a learning system. The longer the team works together, the smarter the AI gets. Invest in virtuous cycles of learning from the start.

2. Verification Loops as Architecture

Here’s the single most important tip Cherny offers: give AI the ability to verify its own work. At Anthropic, Claude tests every change using browser automation. It opens the app, tests the UI, iterates until it works. This improves output quality by 2-3x. I use XCodeBuildMCP to automate this workflow when building iOS apps.

The incremental approach: AI generates code → human reviews → human tests.

The 10x approach: Design for autonomous verification from day one. AI runs tests, observes results, iterates. You review working code, not hopeful code. Human effort is expensive, before you deploy it make sure it’s of the highest value.

3. Tests as Prompts

Test-driven development is having a moment—but for a different reason than before.

When you’re working with AI agents, tests become the specification language. You write tests that define correct behavior. AI iterates until tests pass. As Simon Willison puts it: tests give you a reliable exit criteria. You’re not relying on the AI’s whims.

The workflow flips:

• Plan → Use a thinking model to generate a phased plan

• Red → Write a test expressing desired behavior

• Green → Let the agent implement minimal code to pass

• Refactor → Ask AI to clean up while keeping tests green

• Validate → Verify it works end-to-end

The incremental approach: Write code, then write tests, occasionally ask AI for help.

The 10x approach: Tests are prompts. A well-written test is a natural language spec that guides AI toward exactly the behavior you expect.

4. Parallel Agent Orchestration

The best AI first developers run 5-10 instances simultaneously. Five locally in terminal, 5-10 more in the browser. Each local session uses its own branch to avoid conflicts. As humans we’re used to running serial processes. Computers are multi-threaded for a reason and if you’re not taking advantage of this truth, you’re wasting your time. When you get it right, it’s altogether different:

“It feels more like Starcraft than traditional coding.”

That’s the shift. From typing syntax to commanding autonomous units.

The incremental approach: One developer, one AI assistant, one task at a time.

The 10x approach: You’re directing an entire team of AI agents, not typing code faster.

5. Plan Mode is the New PRD

In the not so distant past, product managers wrote PRDs to make sure designers and engineers understood exactly what to do, why to do it and the targeted business outcomes we seek. In the new world within which we live, Plan Mode is beginning to change what it means to draft a PRD and in many ways changes the purpose entirely. Rather than spending weeks and months pre-planning engineering investments, what happens when the cost to build falls below the cost to plan? Everything changes.

Today, 10x teams are reinventing the PRD with clever use of AI coding systems and Plan Mode. Again, I’ll point to Boris Cherny

“If my goal is to write a feature, I will use Plan mode, and go back and forth with Claude until I like its plan. From there, I switch into auto-accept edits mode and Claude can usually 1-shot it. A good plan made for agentic understanding is really important!”

Without explicit planning, AI tends to jump straight to coding. Asking your AI coding system to research and plan first dramatically improves results. There’s an entire article in my head about how to do this really well, but that’ll wait for another day. Let me know if you want me to write about this next!

The incremental approach: Prompt → AI generates code → you review.

The 10x approach: Spend 80% of interaction time on planning, 20% on execution. This is the inverse of how our systems currently work—but optimal for AI collaboration.

The Pedestal Mistakes

These are the incremental approaches teams default to. Comfortable, familiar, fundamentally missing the point:

• Better autocomplete — Using AI to finish lines faster, not to rethink how code gets written

• Faster Stack Overflow — Asking AI questions you could Google, not letting it autonomously solve problems

• Single-session chatting — No persistent memory, no learning, starting from scratch every time

• Human-in-every-loop — Requiring approval for every action instead of designing for autonomous verification

• One AI, one task — Never parallelizing, never orchestrating, never treating AI as a team

If your workflow looks like this, you’re building pedestals.

The Cultural Shift

Here’s where Astro’s framework gets uncomfortable.

He talks about creating context for moonshot thinking. The culture required. And he’s blunt about what kills it:

“If people are surrounded by business speak, you will ruin it all. If they believe that they have to have a business plan for the weirdness that they are embarked upon, you will kill it—stillbirth guaranteed.”

The teams that will win with agentic coding need psychological safety to fail spectacularly. The first attempts at AI-native development will be messy. Organizations that punish these experiments will lose to those that celebrate the learning.

Astro calls this being “responsibly irresponsible”—radical ambition coupled with disciplined execution.

That’s the balance. Not naive enthusiasm. Not cautious incrementalism. Bold hypotheses, rapid learning, honest assessment.

“The secret? It’s easier to get people to work on making something 10X better than to get them to help make it 10 percent better. Huge problems fire up our hearts as well as our minds.”

The AI Coding revolution isn’t about a new tool. It’s about a paradigm shift in how software gets built. The question isn’t “How do I use Claude Code?”

It’s “What does software development look like when AI agents can autonomously read codebases, plan features, implement changes, run tests, and iterate?”

That’s the monkey.

Are you tackling it? Or building pedestals?

Builder’s note: I’ve been experimenting with these workflows at Google Labs for the past few months. The productivity gains are real, but only when you stop treating AI as autocomplete and start treating it as a collaborator with vastly more freedom to build. The learning curve is steep. I’m convinced the payoff is worth it.

2025 was the year AI learned to code. 2026 is the year everyone else figures out what that means.

The tools that felt like magic tricks a year ago are now table stakes. 85% of developers now use AI coding tools regularly. Cursor crossed $500M ARR and a $10B valuation. The question isn’t whether AI can help you build software. The question is what happens when the barriers to building collapse entirely. When designers ship without engineers. When your kid builds an app over the weekend. When the people who were “non-technical” last year are shipping products this year.

Here’s where I’m placing my bets.

1. The Rise of the Full-Stack Designer

For decades designers, engineers and product managers have worked together to build software. Design skills and engineering skills required deep orthogonal specialization, meaning very few people possessed enough of both skills to drive results without the other. PMs served a critical role connecting these dots and bringing in expertise from functions spanning business, research and program management. But that’s all changing. The hegemony of the silo is collapsing.

Designers, who long have felt limited by the game of telephone between ideas and execution, are embracing AI coding with incredible enthusiasm. Tools like Lovable are explicitly designed for designers, described as “the most beginner-friendly AI coding tool” that excels at “building out stylized user interfaces that seamlessly transition into working prototypes.” Engineers and PMs are also embracing these tools, but it’s the designer who will benefit the most in 2026. We’re about to see a new group of 10x designers who integrate the silos. The full-stack designer is the hero of 2026. Find them on your teams, empower them to build and watch the magic happen.

2. Deeply Personal Assistants

2026 is the year AI assistants finally cross over. For ages, we’ve been sold on the idea of JARVIS but have been limited to frustrating, incomplete experiences that feel like Dragon Dictate from the 90s. That changes this year. Gemini, Claude, and OpenAI will deeply integrate with wells of personal context while learning to use tools directly and on your behalf. This will lead to personal assistant experiences that finally deliver the dream.

The bold call here is on Apple. According to MacRumors, Apple is finalizing a deal worth approximately $1 billion per year to license Google’s Gemini for a reimagined Siri. The new assistant will use a custom version of Gemini 3 Pro with 1.2 trillion parameters, while keeping personal data processed on-device through Apple’s Private Cloud Compute. The launch is targeted for Fall 2026 with iOS 26.4. Siri will be useful by the end of 2026. Maybe not as useful as Gemini on Pixel. But useful.

3. WYSIWYG Development

My use of AI-enabled IDE coding tools like Cursor and Antigravity is changing. In the beginning, I was looking at code changes and approving each. As I learned to trust the models, that’s evolved to me mostly interacting with the agent chat and multi-agent orchestration system and largely ignoring the other panels in the experience. I rarely look at the code at all anymore, other than to doublecheck something I’m curious about. When I use CLI based tools like Gemini-cli, Codex and Claude Code, I embrace this approach even more, but something seems missing with a terminal interface. The most exciting update I see now is when my agent opens a preview of the thing we’re building, either on the web or in a phone emulator, and directly modifies the code based on what’s on screen.

In 2026, we’re going to see the return of the WYSIWYG interface for creation. Dreamweaver is back baby. Bolt.new already combines visual editing with AI code generation, letting you build full-stack apps entirely in-browser. Lovable offers Figma-to-code and one-click deployment. That wasted space in your IDE where you used to look at code will become the surface for creation itself. A place where you’ll nudge UX to where you want it, where you’ll annotate changes you want and where you’ll flag comments to the AI helping you build the code behind the scenes. This is the revolution required for AI coding tools to crossover to the mainstream.

4. Just-in-Time UX

Chat has been the predominant interface for AI and most of the interface innovations have had to fit into the metaphor of chat. There are interesting examples of linking useful UI components into a chat interface: the Photoshop integration into ChatGPT where when you want to modify something like exposure for a photo, a Photoshop control for exposure is integrated directly into the chat. This is a peek into where these UIs are headed.

In November 2025, Anthropic and OpenAI partnered to release the MCP Apps Extension, a specification that brings standardized interactive UI capabilities to the Model Context Protocol. MCP has been called the “USB-C for AI” and now enables agents to serve rich UIs like charts, maps, and forms as part of tool calls. The Agentic AI Foundation launched under the Linux Foundation with OpenAI, Anthropic, Google, Microsoft, and AWS. This paradigm will accelerate this year.

This will lead to a new class of apps that self-compose UIs in real-time. They’ll draw components for existing patterns from vast libraries of capabilities, but when a novel need arises, they’ll create bespoke experiences to match real-time user requests. The very definition of software will forever change, and 2026 is when we see the beginnings of this evolution.

5. Bespoke Software

In December, my son wanted a motivational quotes app for his phone and was disgusted to see that all of the options in the app store were not just paid apps, but required a subscription. What he wanted was pretty simple: a collection of quotes, presented beautifully in an app and as a widget he could keep on his homepage. After a quick tutorial on Antigravity and a few hours of tweaking, he had exactly the app he wanted.

He’s not alone. Gartner projects that by 2026, low-code development tools will account for 75% of new application development, up from 40% in 2021. The low-code market is growing from $37 billion in 2025 to a projected $264 billion by 2032. Non-technical founders are already finding success: one growth marketer built a women’s safety app entirely using AI tools, reaching 10,000+ users and $456K ARR with zero engineering background.

As these tools become even more accessible, the build vs. buy equation will change. People will build the thing they want, or tweak the thing they have into exactly what they want. At first, we’ll see an explosion of new apps from a wide range of people. This will put pressure on app stores and traditional distribution systems. Analysts predict integrated AI platforms will render 60% of single-purpose apps obsolete. In 2026, it’ll be almost impossible to rise above the noise, and for existing apps who depend on paywalls for thinly differentiated features, the flood of free alternatives should make you nervous. Where there is friction, users will innovate.

Problems with too few users to previously justify will now be viable to build. At the limit, even a user base of one will be enough: a revolution of bespoke software solving even the smallest of needs including one-time-use experiences. Wild.

6. Lots of Hype for World Models

Last year I predicted the ongoing expansion of LLMs with multi-modal capabilities and we saw that trend take shape. As these systems understand more about our world, they tend to work better across a wider variety of use cases. The difference between a world model and an LLM is nuanced, but fundamentally world models are designed to master cause and effect, physics, and the consequences of actions across a wide range of domains. We see these attributes in the way Veo seems to have an understanding of how water flows and reacts to a range of inputs, in how sounds and music match their visual complements.

The race is already heating up. Runway’s Gen-4.5, released December 2025, is explicitly marketed as moving beyond “video generation” toward “world models that understand physics.” Fei-Fei Li’s World Labs launched Marble in September 2025, generating explorable 3D worlds from text and images. NVIDIA’s Cosmos world foundation models have been downloaded over 2 million times. Yann LeCun raised €500M for AMI Labs focused on the same goal. In 2026, multi-modality takes another large leap forward, leading to a lot of hype for world models. There’s debate across the industry about the right approach, but regardless of their impact the hype will be loud.

7. AI Software Teams & Agent Swarms

Teams spanning use-case specific agentic specialization are quickly becoming common approaches for development. Gartner reported a 1,445% surge in multi-agent system inquiries from Q1 2024 to Q2 2025. The orchestration software market is projected to hit $8.7 billion by 2026. At the tail end of 2025, we’re seeing clever agent orchestration systems driving step changes in system reliability and capability.

In 2026, the impact of agent teams and agent swarms will be profound. Gartner predicts 40% of enterprise applications will embed AI agents by end of 2026, up from less than 5% in 2025. Smart software teams will optimize agentic integrations across providers and ask systems to debate options ahead of implementation. Planning mode will transform to include multiple agents spanning a range of expertise. Token use will explode, as will the quality of systems we build.

8. Real-Time Interactive Avatars

I predicted this last year and was just a tad early. Synthesia raised $200M at a $4 billion valuation in December 2025 and launched Synthesia 3.0 with their new Express-2 avatars featuring full-body gestures and state-of-the-art voice cloning. Their “Video Agents” for real-time interactive experiences are coming in early 2026 for Enterprise customers. Runway is building GWM-Avatars to simulate human behavior and is in active conversations with robotics firms and enterprises.

2026 is the year when these land, leading to virtual agent experiences that feel eerily natural. These agents will speak every language, draw on deep wells of specialized knowledge and be empowered to act on your behalf. The power of the deeply personalized agents we mentioned in prediction #2, brought to life as personalized characters. The interactions won’t feel completely human, but the illusion will be compelling nonetheless.

9. Generative 3D Assets, Environments and Worlds

Another prediction from 2025 that I’m pulling forward to 2026. This year, generative worlds will have a moment in the sun. 2025 was the year 3D Gaussian Splatting became production-ready for media and entertainment. Superman was the first major motion picture to use dynamic Gaussian splatting. World Labs’ Spark renderer was named one of the most influential libraries of 2025 by GitHub.

You’ll be able to prompt for fully immersive worlds allowing you to explore aspects of imagination in delightful new ways. World Labs’ Marble already generates explorable 3D environments from text, images, or video and exports them as Gaussian splats, meshes, or videos. Many will seek out methods for making these experiences more efficient, repeatable and shareable leveraging capabilities such as 3DGS and parallel advancements in AI-generated 3D assets and environments. Industry experts are “100% convinced that radiance field representations like Gaussian splatting are a fundamental imaging medium” and predict accelerated adoption in 2026. The full potential of these capabilities won’t be realized in 2026, but we’re going to see a ton of meaningful progress.

10. Redefining the OS & On-Device AI

Low-cost, efficient small models are getting really good. Google’s Gemma 3 1B runs at 2,585 tokens per second on mobile GPU with only a 529MB footprint. Gemma 3 270M is designed specifically for on-device deployment with strong instruction-following out of the box. FunctionGemma enables edge agents that map natural language to executable API actions, running locally on phones, laptops, and small accelerators like NVIDIA Jetson Nano.

Meanwhile, on-device compute continues to accelerate with AI-enabled engines integrated into every modern smartphone and computer. With datacenter scale compute facing challenges getting enough power to meet the explosion of demand, we’ll see more inference driven to end user devices. The incentives meet the moment in 2026, leading to significant opportunities for on-device experiences.

Having worked on building Chrome OS, the prospect of rethinking how computing works at a fundamental level is exciting to me. The ingredients to radically reinvent computing are here in 2026. The outcomes that land this year are unlikely to fully realize the potential, but we’re going to see the beginnings of entirely new computing systems show up in our lives.

11. Software Re-Defined Hardware

Another hardware trend I’m excited about is the impact of AI coding on the hardware we already have in our lives. Over the last 10 years, we’ve seen everything from our vacuums to our dishwashers become connected and smart. Unfortunately, most of these systems remain pitifully dumb: sometimes because they’re locked behind an app built by the lowest bidder, and often connected to apps without sustainable business models. Why would someone pay for a subscription to an app for their dishwasher? It makes no sense. This has led to a ton of abandonware and devices with wasted utility waiting to be unlocked by innovative users.

In 2026, hackers and hobbyists will take back their hardware to do amazing things. Arduino was acquired by Qualcomm and released the Uno Q. The Raspberry Pi AI Kit bundles M.2 HAT+ with Hailo AI acceleration. Running AI on a Raspberry Pi is now practical and reliable for offline, privacy-preserving systems. I’ve been waiting for someone to connect their JTAGulator to Claude Code and liberate devices that were previously locked down. Hardware was always hard. In 2026 these trends converge and hardware becomes less hard.

12. Potpourri

As I was writing these, I kept finding things I wanted to add to my predictions. AI is literally affecting everything we do and it’s impossible to choose where the impact will be greatest. Rather than tossing all of the other thoughts into the trash, I’m going to mix them into a stew of half-baked predictions:

• Robotics accelerates, though most of the gains are for industrial use cases. The global industrial robot market hit an all-time high of $16.7 billion. Humanoid robot costs are projected to fall from $35K to $13-17K per unit over the next decade.

• Shopping becomes deeply personal as agents finally help shop for us. OpenAI announced deals with Target, Instacart, and DoorDash. Amazon launched “Buy For Me.” Visa plans AI-driven purchases inside chatbots as early as Q1 2026. Morgan Stanley predicts nearly half of online shoppers will use AI shopping agents by 2030. Just yesterday Google announced an industry alliance for Agentic shopping called UCP. This is happening in 2026.

• We see AI within games at all levels, leading to fun new styles of gameplay. 90% of game developers are already using AI in their workflows according to Google Cloud research. The AI in gaming market is projected to grow from $3.28 billion to $51 billion by 2033. But there will still be backlash like what we saw with Expedition 33 last year.

• Entry level software jobs become scarce, except among multi-faceted AI native builders. Entry-level hiring at the top 15 tech firms fell 25% from 2023 to 2024. Junior developer postings are down 60% since 2022. Salesforce announced it will hire “no new engineers” in 2025. The path forward is becoming an AI-native builder who can leverage these tools, not compete with them.

I write to think. This article isn’t just a list of predictions; it’s how I force myself to synthesize everything I’m seeing into a coherent view of where we’re headed. The act of committing these ideas to writing sharpens them. It exposes the gaps in my logic. It makes me defend positions I might otherwise hold loosely.

But I don’t have this figured out. If you think I’m wrong about something, tell me. If you see a trend I’m missing, I want to hear it. If one of these predictions strikes you as naive or overly optimistic, challenge me. The best thinking happens in conversation, not isolation.

The common thread across all twelve predictions: the builders win. Not the people who wait to see what happens. Not the people who debate whether AI is overhyped. The people who pick up the tools and start making things.

I build things to figure out how they work. That’s how I learned AI. That’s how I learned photography. That’s how I teach my kids. And I write to think through what I’m learning. That’s why this Substack exists.

Come December, I’ll grade myself on each of these publicly. Until then, I’m building. What about you?

TL;DR: 4 A’s, 3 B’s, 3 C’s. Overall: B+. I nailed inference costs, AI agents, AI music, and services-for-AI. I whiffed on embodied AI and AI game worlds—the tech is there but the products aren’t. Biggest lesson: technology moves fast, but products take longer.

A year ago I wrote down 12 predictions and hit publish. I reposted them yesterday, and you can read them here: 2025 AI Predictions (Republished)

That’s the crazy part about predictions; you can’t edit them later. They just sit there, waiting to make you look smart or foolish. I called 2025 the potential “1984 moment” for AI. Predicted 50 years of productivity gains crammed into 10. Bold claims.

Some held up. Some didn’t. A few things happened that I missed entirely. I’m grading myself honestly. If you only remember your hits, you learn nothing. I’ve already started writing my 2026 predictions, so this is all part of the process for me. I write to think and build to learn.

The Hits

1. Inference Costs Continue to Plummet (A)

What I predicted: Costs declining 10x per year, enabling “reasoning-heavy applications” that were previously impossible.

What happened: Nailed it. Stanford’s 2025 AI Index shows inference costs for GPT-3.5-level performance dropped 280x and kept falling. Epoch AI found price drops from 9x to 900x depending on the benchmark. It started early in the year when DeepSeek rattled markets by offering R1 at 20-50x cheaper than comparable OpenAI models. That turned into a performance war with API costs dropping to fractions of a cent per million tokens.

More importantly, this enabled exactly what I predicted: chain-of-thought, multi-step agents, and complex agentic workflows at economically viable scale.

Grade: A — The magnitude was arguably understated.

Why this matters to me: I work on AI products at Google Labs. A year ago, some of the experiences we wanted to build were economically impossible. Now they’re not. That 280x drop isn’t an abstract number—it’s the difference between “interesting demo” and “scalable product.”

2. AI Agents Break Through the Hype (A-)

What I predicted: Agents gain traction in “specialized applications where their ability to automate tasks can be well-scoped.”

What happened: 2025 really was the dawn of the agent.

OpenAI kicked it off with their launch of Operator, an AI that browses the web, fills forms, and completes purchases on your behalf. Anthropic followed with Claude Computer Use that let AI control your mouse and keyboard. We launched Mariner at Google Labs and by mid-year, agentic browsers from Perplexity (Comet), Browser Company (Dia), and Opera (Neon) reframed the browser as an active participant. Agents are core parts of Claude Code, Antigravity, Cursor and so many other systems people use every day.

Even enterprise adoption exploded: 68% of large companies now use AI agents (up from 11% two quarters prior) and the market is projected to grow from $13.8 billion to $140.8 billion by 2032. Despite the now debunked MIT survey about AI projects failing in the enterprise, the application of Agents at work truly started to take hold in 2025.

But here’s the nuance I got right: these agents thrived in well-scoped applications. The OSWorld benchmark shows humans at 72.4% accuracy versus 38.1% for OpenAI’s best model. Agents are powerful but not yet fully autonomous. The “specialized needs” framing I predicted still largely holds. I think this expands dramatically in 2026 and we’re going to see agents move into swarms of agents, teams of agents and much more well coordinated workflows with tool using agents performing a massively large variety of tasks.

Grade: A- — Timing and trajectory is largely right. “Mainstream” is generous, but defensible.

3. AI Music Empowers New Voices; An AI Song Breaks Through (A)

What I predicted: “An AI-generated song will achieve mainstream success on a platform like Spotify.”

What happened: Breaking Rust hit #1 on Billboard’s Country Digital Song Sales chart with “Walk My Walk.” The AI-generated country artist has 2 million monthly listeners on Spotify.

But that wasn’t alone. The Velvet Sundown hit #1 on Spotify’s Viral 50 in the UK, Norway, and Sweden. Xania Monet, an AI persona created by a Mississippi poet, signed a multi-million dollar record deal. Deezer reported 50,000 fully AI-generated songs are uploaded daily. Spotify removed 75 million “spammy” AI tracks in 12 months, showing both the interest and the challenge here. The floodgates have opened and AI music is almost certainly here to stay.

That’s not to say there isn’t backlash. Artists are hesitant about what this all means for their work and we’ve seen Suno, Udio and major record labels go through some things together. There are really important copyright issues at stake and I’m proud of the stance we’ve taken at Google on this topic. I’m not going to get into details, but I think Lyria strikes a good balance here.

Back to the grades. I predicted a song would break through. Multiple artists hit the charts. I was too conservative, and now that the gates are open I’m more excited than ever for what 2026 will bring.

Grade: A

4. Services Emerge Designed for AI Agents (A)

What I predicted: “Services and applications specifically designed for AI consumption... transforming the way we publish content on the web.”

What happened: The Model Context Protocol took the world by storm.

Anthropic launched MCP in November 2024 as an open standard for connecting AI to external systems. By 2025, it became the de facto infrastructure for agentic AI. OpenAI adopted it in March. Google DeepMind followed. In December, Anthropic donated MCP to the Linux Foundation’s new Agentic AI Foundation, co-founded with OpenAI and Block.

MCP is now integrated into ChatGPT, Cursor, Gemini, Microsoft Copilot, and VS Code. AWS, Google Cloud, and Azure all support it. Thousands of MCP servers exist for enterprise systems and hobbist creators. Designing for AI Agent use is more important than ever.

Similarly, OpenAI released AGENTS.md as a standard for giving AI agents project-specific guidance and it’s now been adopted by 60,000+ open source projects already. If you use Antigravity, Claude Code, Codex, Lovable, or Cursor, you’re almost certainly using an AGENTS.md file as part of your workflow.

This prediction was more right than I understood when I wrote it.

Grade: A

Builder’s note: MCP is the kind of infrastructure that seems obvious in retrospect but required someone to just... build it. Anthropic shipped it, open-sourced it, then donated it to a foundation. That’s how you win an ecosystem. Kudos.

5. AI-Augmented Coding Gains Traction (B+)

What I predicted: Tools like Jules become “widely used among developers” but “significant simplification across the software lifecycle is needed before such capabilities can become mainstream tools accessible to non-developer users.”

What happened: Some places are reporting that as much as 90% of dev teams now use AI in their workflows (up from 61%). GitHub Copilot leads with 42% market share; Cursor is at 18%. Almost half of companies now have at least 50% AI-generated code. And if you’ve been on X over the last few weeks, you’d be forgiven if you thought 100% of people were making projects over the holidays with Claude Code.

Cursor claims that users complete complex tasks 40-60% faster when using their tools. Claude Code, Windsurf, and GPT-5’s Codex agent all shipped major improvements. Google acqui-hired (what do we call these things?) the Windsurf founders and then launched Antigravity. The space is hotter than ever and “Vibe coding” entered the vocabulary.

But here’s where I was both right and wrong: I said non-developers would need “significant simplification” before these tools became accessible. That simplification did sort of happen; but the mainstream crossover for non-developers is still incomplete. The barrier lowered but there’s still a lot to do here. Look out for my 2026 predictions about JIT UX for more here.

Grade: B+ — Developer adoption exceeded expectations. Non-developer crossover remains a work in progress.

6. Hyper-Personalized Shopping Experiences Emerge (B+)

What I predicted: “AI shopping assistants designed to save people money, identify better products based on individualized style, budget, and preferences, and even haggle with sellers.”

What happened: Every major AI company launched shopping features:

• Perplexity rolled out Instant Buy with PayPal integration—ask “what’s the best winter jacket if I live in San Francisco and take a ferry to work?” and it remembers your context

• OpenAI launched Shopping Research with product cards and personalized guides

• Amazon upgraded Rufus and tested “Buy For Me”—an agent that purchases from other sites within the Amazon app

• Google launched Doppl (one of my projects) and integrated Try On You features across the Shopping ecosystem. Nano Banana really raised the state of the art for these features this year.

• Startups like Doji and Phia are getting close to some of these capabilities, particularly in terms of price hunting but aren’t quite where I imagined yet.

Morgan Stanley projects AI agents could add $115 billion in U.S. e-commerce spending by 2030. Adobe says AI-assisted shopping grew 520% this holiday season. But the “haggle with sellers” bit? Not quite there yet. And the experience is fragmented—Amazon sued Perplexity for its Comet browser completing purchases without permission. This space will stay hot in 2026 and I’m pretty excited about how AI Agents are going to help us engage with commerce in the future.

Grade: B+ — Directionally correct. “Haggle” was ahead of its time.

Partial Credit

7. AI Streaming Cartoon Launches (B)

What I predicted: “A streaming service experiment with an AI-produced cartoon able to respond in near real-time to current events and viewer feedback.”

What happened: Close, but not quite there yet.

Fable launched Showrunner, the “Netflix of AI”—an interactive platform where you create episodes using text prompts. Amazon backed it. Their “Exit Valley” show features AI versions of Sam Altman and Elon Musk. It’s probably the closest to what I imagined when I wrote the prediction, but it’s still falls short of where I think this is going.

The big headline this year is that Disney announced Sora will create videos featuring 200+ Disney characters, including distribution of user-made clips on Disney+. Disney invested $1 billion in OpenAI to get this deal done. Similarly, Netflix is developing interactive voting for its Star Search reboot which is an interesting puzzle piece to keep an eye on.

The industry is clearly moving toward interactive, AI-generated content. But a full AI cartoon responding to real-time events? Not quite yet. The pieces are there; but the product isn’t.

Grade: B — The infrastructure is here, but the consumer product I described is 2026.

8. AI Memory Banks Emerge as a New Category (B-)

What I predicted: “AI memory banks as a valuable tool... an ‘always-on’ memory support, capable of storing, organizing, and retrieving vast amounts of information.”

What happened: The category emerged and a lot of people are building parts of this, but it’s not where I predicted.

I think the biggest headline was when Limitless launched its $99 Pendant wearable. It could record conversations, get AI transcripts, ask “what did we decide?” and jump to exact quotes. The product found an audience, and then Meta acquired Limitless in December, immediately halting Pendant sales. Meta folded the technology into its “personal superintelligence” roadmap for future Ray-Ban glasses.

Microsoft’s Recall feature generated controversy but showed the category has legs. A million note taking apps, tools, and features are flooding our workflows but none are quite what I meant. OpenAI is rumored to be working on a “pen” and I suspect it’s close to what I imagine taking hold here. I guess we’ll see.

Grade: B- — I think the category is validated but we still need to see the killer product.

9. AI-Creativity Goes Mainstream; Adobe Faces Competition (B-)

What I predicted: “AI-augmented creativity to explode... A new entrant will emerge as an AI-first competitor to Adobe.”

What happened: AI creativity absolutely exploded. Flow, Sora, Runway, Kling, and Pika pushed video generation into the mainstream as capabilities leaped forward. Every major model improved dramatically at image generation and Nano Banana set a new standard that somehow Nano Banana Pro leap frogged. You can one-shot a complex infographic, correctly solve complex math within beautifully rendered text, and even create full presentations based on your source materials. Absolutely monumental progress this year.

But a clear Adobe challenger? Not yet. Canva deepened AI integration. Figma pushed AI features. Startups like Ideogram and Leonardo.ai gained tons of users. But none really emerged as the Adobe killer. And Adobe fought back harder than I expected. Firefly is embedded across Creative Cloud. GenAI capabilities from partners are being directly integrated across the Adobe portfolio. They just signed a big deal with Runway. Adobe is awake and they’re cooking again.

Grade: B- — Creativity explosion definitely happened, and there is a lot of new competition but Adobe is not asleep at the wheel which is exciting to see. As a photographer, I’ve been a loyal Adobe Creative Suite subscriber and am excited about the new capabilities at my fingertips.

10. Real-Time Multimodal LLMs Evolve Interaction (C+)

What I predicted: “AI systems will be able to seamlessly integrate and understand information from multiple sources, including text, images, audio, voice and even video, all while responding dynamically.”

What happened: The technology arrived. GPT-4o, Gemini 3.0, and Claude all improved multimodal capabilities dramatically. Real-time voice with AI became the de-facto standard for many users.

But my concern about “phone-anxiety trends among GenZ and Millennials” limiting voice adoption? Anecdotally maybe thats correct, but it’s still really hard to know. Chat definitely remains the dominant interface for most everyone despite massive voice improvements. I don’t know many people who actually use the video input paradigm yet.

I still love the idea of Astra, and I’ve seen some cool use cases that integrate Gemini Live, but so far it hasn’t redefined interaction models. We’re still mostly typing.

Grade: C+ — Multimodal models are definitely here; but behaviors change slowly. We’re all still chatting with our AIs.

The Misses

11. Embodied AI / Virtual Humans Transform Customer Service (C)

What I predicted: “Fully interactive virtual humans with photorealistic personification, recognizable voices and body movements... as the presentation layer on top of AI Agents.”

What happened: Progress, but nothing transformative here yet.

AI avatars are improving quickly. Synthesia and HeyGen refined video generation with talking heads. But photorealistic virtual humans serving as widespread customer service agents? That hasn’t gotten past janky demos yet. The dream Poe from Altered Carbon serving as a virtual concierge when I check into my next hotel is still out on the horizon I’m afraid.

Most customer service AI remains voice-based or chatbot-based. The “embodied” layer is what isn’t ready yet. Cost, uncanny valley, and customer preference for efficiency over novelty kept this prediction from materializing in 2025. We’ll need some technology breakthroughs and some carefully designed experiences for this to come to life in 2026. I’m convinced it will, it’s just a matter of when.

Grade: C — Overestimated progress and demand for virtual human avatars.

12. AI-Generated Immersive Game Worlds Launch (C-)

What I predicted: “An AI Game launches with GenWorlds... AI that can generate vast interactive and detailed game worlds that adapt to player choices.”

What happened: AI in games advanced pretty incrementally in 2025. We say clear NPC dialogue improvements, a ton of procedural and generated content experiments, quite a few clever AI development tools, and MCP servers for pretty much every game engine. We announced Genie 3 from Deep Mind this summer and a range of startups began showing off 3D Gaussian Splat based environments that you can explore in a video-game like experience. But none of these advancements really hit the mark for what I had in mind.

We’re still looking for the first AI-generated game world launched as a mainstream title. There’s a lot of energy in this space right now, but the “GenWorlds” moment (meaning a game where AI generates the explorable world in real-time) didn’t hit the market in 2025.

Game development cycles are long and the technology is almost there. 2026 should be interesting.

Grade: C- — Too early.

What I Missed Entirely

Some of the things that seem obvious now are where I missed the most in 2025. A few big ones that stand out to me are:

DeepSeek’s disruption. A Chinese lab releasing a competitive model at a fraction of the cost—open-weight—rattled markets and changed the game right out of the gates in 2025. I predicted cost declines but not where the disruption would come from nor how much we’d see. I called the trend Moore’s Law on steroids when really it was more like a coked out meth-head on steroids.

The MCP standardization speed. I predicted “services designed for AI agents” but didn’t foresee how quickly formal protocols would emerge and get adopted by all major players. The industry standardized faster than expected. This is one of the more exciting spots of coordination in the industry right now and I find it really encouraging.

The acquisition pattern. I predicted AI memory banks would emerge; I didn’t predict these startups would get snapped up before they scaled. Actually, this whole new trend of buying out founders that we’ve seen with Character.ai, Windsurf and most recently Groq is an interesting evolution to the M&A playbook. I definitely didn’t see this coming.

Regulatory acceleration. The EU AI Act also shaped the industry in ways I should probably have thought about. But regulatory stuff is kind of out of my wheelhouse, so I’m giving myself a pass here.

The Scorecard

PredictionGradeInference costs plummetAAgents break throughA-AI music breakthroughAServices for AI agentsAAI coding gains tractionB+Personalized shoppingB+AI streaming cartoonBAI memory banksB-AI creativity / AdobeB-Multimodal interactionC+Embodied AICAI game worldsC-

Overall: B+

I think I got many of the big trends right: agents, inference economics, AI music, services for AI, and coding tools. Where I missed, was mostly timing. Embodied AI and AI game worlds are coming and the tech will be here before we know it, but it just didn’t happen in 2025.

The biggest lesson: Technology is moving extremely fast right now, but products are taking longer. There’s probably something to learn for PMs here that would make for an interesting article. MCP was infrastructure I didn’t see coming (but probably should have). The AI streaming cartoon I described is definitely being built right now by someone, but it didn’t ship in 2025. AI game worlds need more development cycles to be product ready.

The gap between demo and product is still where I think all the interesting work happens. Good thing it’s what I work on every day!

What’s Next

2026 predictions drop next week. Here’s the short version: I think this is the year agents stop being demos and start being daily tools. The infrastructure is in place. The battle now is trust.

I’ll break down what I’m betting on—and what I’m building toward at Google Labs.

Think I graded myself too generously? Too harshly? Hit reply—I read everything.

Foreword (January 2026):

A year ago, I wrote down 12 predictions about where AI would go in 2025. I shared them with teammates at Google Labs but never published them publicly.

That was a mistake. Predictions without accountability are just vibes.

So before I publish my scorecard (tomorrow) and grade each of these predictions against what actually happened, I’m republishing the original document here unedited. You can see exactly what I predicted, in my own words, before I reveal the final ratings.

Here’s what I wrote a year ago:

Predictions for AI In 2025

January 2025

If you thought the world of AI moved fast in 2024, you’d better buckle up for 2025 because I believe we’re about to enter a period of development with 50 years of productivity gains crammed into 10 years (or less.) I think we’ll look back at 2025 as the seminal year for AI much like we consider 1984 the pivotal moment for personal computing.

Building on what happened in 2024, AI is going to get even smarter and be everywhere, affecting pretty much everything we do. I won’t address whether we reach AGI, but here are a few thoughts on some trends I expect to see this year:

Inference costs continue to plummet; reasoning-heavy applications flourish

The cost of running AI models has been declining by as much as 10x per year, and this trend is likely to continue in 2025. This is driven by factors such as increased competition, hardware advancements, and more efficient algorithms.

The impact of this trend will be like Moore’s Law on steroids: inference costs plummet, making it feasible to deploy AI for wildly more complex tasks that require advanced reasoning and problem-solving. We’ll be able to build AI systems that can analyze complex data, identify patterns, and generate solutions to problems that were previously impossible.

Put more inference in your solutions.

Agents break through the hype; serving specialized needs but not yet mainstream

AI agents are becoming adept at performing tasks and achieving pre-defined goals without constant intervention. In 2025, we’ll see AI agents gain traction with specialized applications where their ability to automate tasks can be well-scoped in ways that limit unintended outcomes. This could include tasks such as scheduling, managing emails, conducting research, and even automating service interactions.

We’ll see experiments with proactive agents which operate autonomously, with an opportunity to establish a leadership position in this space by differentiating on trust.

Real-time multimodal LLMs evolve how we interact with AI; yet chat remains dominant

In 2025, we’ll witness a significant leap forward in the capabilities of multimodal LLMs, particularly in their ability to process and respond to information in real-time. This means AI systems will be able to seamlessly integrate and understand information from multiple sources, including text, images, audio, voice and even video, all while responding dynamically to changes in the input streams.

The time is ripe to reinvent how we interact with AI and integrate it more seamlessly into applications. Tools like Astra will offer a major step forward, but I worry voice-based interactions will suffer from phone-anxiety trends common among GenZ and Millennials.

Emergence of AI-produced interactive entertainment; a streaming service launches an AI cartoon

AI is already being used to generate creative content, including music, images, and videos. AI algorithms can now generate original stories, characters, and even animation, potentially leading to entirely new forms of entertainment with deeply embedded interactivity that would never be possible without AI.

In 2025, we’ll see a streaming service experiment with an AI-produced cartoon able to respond in near real-time to current events and viewer feedback. This will be a first step toward interactive, personalized and engaging entertainment experiences.

AI-creativity goes mainstream; a new entrant emerges as an AI-first competitor to Adobe

AI-powered creative tools are becoming so good that generated content is becoming difficult to distinguish from human-created work, and users are becoming more comfortable integrating these systems into their regular creative lives.

In 2025, we should expect AI-augmented creativity to explode, with AI tools playing a more prominent role in art, music, advertising and video production. Continued model improvement will lead to new forms of artistic expression and a revolution across the creative world; posing a greater threat than ever before to traditional incumbents.

A new entrant will emerge as an AI-first competitor to Adobe.

AI-music empowers new voices; an AI song will break through on Spotify

AI music tools are empowering individuals with limited musical training to create original music. These tools are becoming more accessible and user-friendly, allowing anyone to create original music regardless of their musical background. This will lead to a democratization of music creation, with new voices and styles emerging from unexpected sources and open opportunities for new methods of creator-centric social music experiences.

In 2025, I believe an AI-generated song will achieve mainstream success on a platform like Spotify, further demonstrating the potential of AI in music creation.

AI-augmented coding gains traction, but complexity prevents widespread use

AI coding tools are becoming increasingly popular, assisting developers with code generation, debugging, and documentation. These tools can automate repetitive coding tasks, suggest code completions, and even generate entire code blocks. However, complex coding tasks still require human expertise and oversight, particularly for deployment as web and mobile apps, limiting the mainstream adoption.

In 2025, we can expect AI coding tools like Jules to become widely used among developers but significant simplification across the software lifecycle is needed before such capabilities can become mainstream tools accessible to non-developer users.

Embodied AI moves beyond novelty; virtual humans transform customer service

Embodied AI, particularly in the form of virtual humans, will find traction in a range of real-world applications. These virtual humans will be more than just avatars; they will be capable of interacting with their environment and humans in a more natural and intuitive way.

We’ll see existing chat-based character systems evolve to include fully interactive virtual humans with photorealistic personification, recognizable voices and body movements. These Embodied AI personas will serve as the presentation layer on top of AI Agents to deliver engaging customer service experiences not before possible.

Hyper-personalized shopping experiences emerge; an AI shopping agent grabs market share

AI is already being used to personalize recommendations, offers, and marketing messages for businesses. In 2025, we can expect even more sophisticated AI-powered shopping tools that anticipate customer needs and provide highly personalized experiences enabled across merchants.

I believe we’ll also see consumers embrace hyper-personalized AI shopping assistants designed to save people money, identify better products based on individualized style, budget, and preferences, and even haggle with sellers to get them the best possible prices. This will empower consumers and potentially disrupt traditional retail models.

AI-generated immersive worlds arrive; an AI game launches with GenWorlds

AI is already being used to generate game content, including characters, environments, and even storylines. In 2025, we can expect to see more sophisticated AI-powered games that offer dynamic and immersive experiences.

Imagine AI that can generate vast interactive and detailed game worlds that adapt to player choices and actions, creating unique and unpredictable gameplay. This will lead to new genres of games where players explore AI-generated worlds, interact with AI-powered characters, and experience emergent narratives that unfold in real-time.

This will revolutionize world design, offering endless possibilities for exploration and replayability. AI will power non-playable characters (NPCs) with complex motivations, relationships, and even personal histories, leading to emergent narratives and unpredictable gameplay.

Services emerge designed to be consumed by AI agents; redefining the web

As AI agents become more prevalent, we can expect to see services and applications specifically designed for AI consumption. This will lead to a new paradigm for the web, where AI agents interact with each other and access information in ways that are different from traditional human-computer interaction.

Imagine AI agents access and process information from websites, APIs, and other online services, autonomously gathering data, making decisions, and completing tasks on behalf of their human users. This will lead to new forms of online services and applications optimized for AI interaction, transforming the way we publish content on the web.

AI memory banks emerge as a new category; always-on memory support gains traction

In 2025, we’ll see the emergence of AI memory banks as a valuable tool for individuals and businesses. These AI-powered systems will act as an “always-on” memory support, capable of storing, organizing, and retrieving vast amounts of information, effectively augmenting human memory and enhancing cognitive capabilities.

Imagine an AI assistant that remembers every conversation you’ve ever had, every document you’ve ever read, and every event you’ve ever experienced. This AI could then provide you with relevant information and insights whenever you need them, helping you make better decisions, learn more effectively, and even enhance your creativity.

What’s Next

That’s what I wrote a year ago. No edits. No hedging after the fact.

Next post: the scorecard. I’m grading each of these predictions against what actually happened in 2025. Some I nailed. Some I whiffed. A few things happened that I didn’t see coming at all.

Subscribe so you don’t miss it.

Originally written January 2025. Republished January 2026.

I’ve spent the last 18+ years at Google building 0-to-1 products. Some shipped to millions of people. Some died in committee. A few I’m genuinely proud of.

But the stuff I’ve learned the most from? The things I built mostly to figure out how they work. That’s where the magic happens.

Build to Learn

Earlier this year, I took a darkroom photography class. Not because I needed another hobby, but because I wanted to really understand photography at a deeper level. Especially light—I really wanted to understand it. How it behaves. Why some shots feel alive and others fall flat.

So I did what I always do: I built something.

I started building an app I’m calling GroundGlass. It’s a light meter for my phone that simulates how light works within a Hasselblad 503C medium format camera. Not because good light meters don’t exist (they do, and they’re better than mine), but because building one forced me to internalize the physics. Incident vs. reflected. The inverse square law. Why zone system metering actually works. The app is still a work in progress and I might even ship it one day, but that isn’t really the point.

Now when I shoot, I don’t think about the math. It’s just there. The app was never my goal. The understanding was.

This is how I learn. I build things to figure out how they work.

The Best Day Job in the World

I’m pretty lucky to admit that I may have the most fun job within one of the best teams at the best place to (IMHO) work in the World. By day, I’m a Product Director at Google Labs, where I work on AI products based on the very latest research and models from our partners at Google Deep Mind. I joined this team in 2023 and have been involved with a few extremely fun projects already. Some haven’t launched yet (shhhh), but a few that have include: Doppl, MusicFX, and the Audio Overviews features of NotebookLM. I may write about some of these (and other) experiences at some point in the future.

Fundamentally, I’m a 0 to 1 person at heart. When I joined Google in 2007, I told myself I’d learn my way around Silicon Valley and Google for maybe 5 years and then go out to start my own company. Well, it’s been nearly 20 years and I’m still here. A huge reason is because I’ve had the privilege of working for some incredible people — including Sheryl Sandberg, Sundar Pichai, Craig Barrett, Rick Osterloh, Susan Wojcicki, and most recently Josh Woodward.

The other reason is that I’ve had the opportunity to be hands on building amazing products within Google, usually from the earliest moments of ideation through to billions of dollars of impact. It’s a truly rare path I’ve made in my time here and one that’s been rewarding in so many ways. Some of the things I’m most proud of building include:

YouTube Create — A mobile video editing app. Making video editing tools that feel intuitive rather than overwhelming is hard. The project started as something almost entirely different and was acquired (internally) into YouTube where we reshaped our idea into one of the fastest growing mobile video apps in the world.

Pixelbook — Google’s premium Chromebook. I was the Product lead for our first-party laptop and tablet portfolio based on ChromeOS. We always knew it was going to be hard to sell $1000 Chromebooks, and it was — but we were clear-eyed about our goals and proud of what we built. There are some great stories to share about this experience.

Google WiFi — I started the project back before it was called OnHub and we were focused on ways to help more Google users get online. We were trying to answer a simple question: why does everyone’s home WiFi suck? The answer turned out to be complicated (mesh networking, antenna design, automatic channel selection, an app that doesn’t require a PhD to use). It’s now in millions of homes and won an iF Design Award. I’m proud of that one.

ChromeOS — I joined the ChromeOS team when we were about 30 people total and became the PM responsible for all of the system services layers of building an operating system. It was a wild ride surrounded by such amazing talent density. It truly took a passionate, brilliant team to convert the idea of netbooks into a full and complete computing ecosystem centered on the web.

It’s still amazing to me that I’ve been at Google so long and I’ve obviously had chances to leave, but Google is such a special place that it’s hard to seriously consider it. I joined Google right out of business school—MIT Sloan, if you’re keeping track—and before that I studied computer science at Northwestern, where I went deep on early AI systems and the primordial version of neural networks from the late ‘90s.

So when people ask if I think AI is going to change everything, I’ve got some context. For the record: yes, everything is going to change. My mission is to see to it that it changes for the better.

The Side Quests

A rewarding day job is one thing, but I’ve never given up on my side quests. I think this is where everything gets more interesting and I’ve pretty much always had a long list of things I was noodling on and building — often just to learn. It’s how I work. I’m not going to try to list everything, but a few things I’ve loved to do lately include:

Building with my kids. I’ve been helping my son (14) build an app called Quotivation. He wanted an app to put motivational quotes on his phone and was annoyed that all of the options in the app store required a subscription. So he’s building his own — with Antigravity naturally. My daughter (12) and I are also working on an app she wanted to build called Waddle, which is a cozy self-care app featuring a duck who bakes pastries. It has a pedometer and a focus timer. She designed the duck and is vibe coding with Gemini to make the app what she imagined. Building software with your kids is an amazing way to connect and it’s inspiring to see them get the builder bug.

SharpGlass. An open-source macOS app for creating and viewing 3D Gaussian Splats based on a 2D image. I saw Apple had launched a model called ml-sharp and I wanted to understand it a bit better because the technology is fascinating. So last week, I built an app (using Antigravity and Gemini 3 Flash) to experiment and learn. I put it all up on GitHub if you want to check it out.

Film photography. Last year, I signed up for a darkroom photography class at Foothill College where technically I’m a freshman working towards an associates degree. I’m learning to shoot film using a Leica M6 and a Hasselblad 503C. I’ve started developing my own film and making my own prints in a darkroom. In a world where I spend all day on AI and software, there’s something grounding about a purely analog process where you can’t undo anything. I’ve always loved photography, but film is altogether another level. I’ll probably have a bunch of photography related things to talk about. And if you’re curious I have some work posted at trond.photograhy.

Angel investing. I’ve invested in quite a few startups through Hustle Fund’s Angel Squad and as an AI advisor to Vitalstage Ventures. I’ve had several wins that I’m proud of and a few that look likely to hit in 2026. Also, quite a few misses — but that’s the name of the game. I love Angel Investing mostly because I learn a lot from founders who are building things I’d never think of. I’m pretty much only thinking about AI these days so if you want to approach me about something, come with a clear view on how you’re using AI in ways that solve meaningful user problems in a novel way that was previously infeasible. Or if you’ve figured out how to get power to datacenters more efficiently or more quickly. I hear that’s in demand these days.

Why This Newsletter

I’ve been writing internal docs at Google for almost two decades. Strategy memos, product specs, postmortems. Thousands of pages that maybe a few dozen people read.

I want to write for a wider audience. Not to build a personal brand (though I guess that’s happening), but because I’ve accumulated a lot of lessons I think are worth sharing—and I learn better when I share with others.

Here’s what you can expect:

The Big Leap. Why do AI demos or new models always look amazing but shipped products frequently disappoint? I work on this problem every day. I’ll share what I’ve learned about translating research into products people actually use. It’s linked to my personal mission: build rad shit people love.

Builder’s Notes. Lessons from founding products at Google—what worked, what didn’t, and what I’d do differently. Not sanitized corporate retrospectives. Real talk. I won’t be able to share things that are proprietary to Google, but the lessons that spawn from our work still matter.

Experiments & Learning. I build a lot of random stuff. Apps, tools, photography projects. I’ll share what I’m working on and what I’m learning from it. Most of it will be half-baked, but that’s often where the magic happens.

The Craft of PM. I’ve hired a lot of PMs. I’ve mentored a lot of PMs. In January, I’m teaching a session at Harvard Business School on “PMing in the Age of AI.” I have opinions about what makes great product people. Some of them are probably wrong. The craft is evolving quickly; let’s learn together what the future of the PM role means.

What I Won’t Do

I won’t pretend to have answers I don’t have. I won’t write corporate pablum. I won’t optimize for engagement at the expense of saying something true.

I’m also pretty tool-agnostic. I use Claude, Gemini, ChatGPT, Grok—whatever works for what I’m building. I work at Google, and yes I’m going to talk a lot about things that I’m excited about here, but I’m not just here to sell you Google products. I’m here to share what I’m learning and hopefully that spans the whole industry. There’s so much amazing work going on worth learning from!

Let’s Build Some Rad Shit Together

That’s what this newsletter is called because that’s what I care about. Not building things that look good in a pitch deck. Not building things that satisfy some quarterly OKR. Building things that are genuinely good—things people love to use.

If that sounds interesting, subscribe. I’ll be in your inbox roughly once a week.

First real post coming soon: Grading My 2025 Predictions. A year ago, I made 12 predictions about where AI would go. Some I nailed. Some I whiffed. I’m grading myself honestly—because that’s the only way predictions are worth making.

Let’s go.

—Trond