Simon Willison is a prolific independent software developer, a blogger, and one of the most visible and trusted voices on the impact AI is having on builders. He co-created Django, the web framework that powers Instagram, Pinterest, and tens of thousands of other websites. He coined the term “prompt injection,” popularized the terms “AI slop” and “agentic engineering,” and has built over 100 open source projects, including Datasette, a data analysis tool used by investigative journalists worldwide. What makes Simon unique is that he’s made the leap from traditional software engineering to AI-native development more fully and visibly than almost anyone—and he’s been documenting everything he learns in real time on his blog, SimonWillison.net.

In our in-depth conversation, Simon shares:

1. Why November 2025 was the inflection point when AI coding agents crossed from “mostly works” to “actually works”

2. How Simon writes 95% of his code from his phone now and why he’s mentally exhausted by 11 a.m.

3. Why mid-career engineers (not juniors) are most at risk right now

4. The three agentic engineering patterns Simon uses daily (red/green TDD, templates, hoarding)

5. The next leap: the “dark factory” pattern where nobody writes or reviews code and AI does its own QA

6. Why prompt injection is an unsolved security problem and the “lethal trifecta” that will likely lead to an AI Challenger disaster

7. Why the pelican riding a bicycle became the unofficial benchmark for AI model quality

Brought to you by:

WorkOS—Modern identity platform for B2B SaaS, free up to 1 million MAUs

Vanta—automate compliance, manage risk, and accelerate trust with AI

Where to find Simon Willison:

• X: https://x.com/simonw

• LinkedIn: https://www.linkedin.com/in/simonwillison

• Website: https://simonwillison.net

• Agentic Engineering Patterns: https://simonwillison.net/guides/agentic-engineering-patterns

Referenced:

• It genuinely feels to me like GPT-5.2 and Opus 4.5 in November represent an inflection point: https://x.com/simonw/status/2007904766756880848

• Claude Code: https://code.claude.com

• Codex: https://chatgpt.com/codex

• Head of Claude Code: What happens after coding is solved | Boris Cherny: https://www.lennysnewsletter.com/p/head-of-claude-code-what-happens

• There’s a new kind of coding I call “vibe coding”: https://x.com/karpathy/status/1886192184808149383

• Firefox: https://www.firefox.com

• Naming expert shares the process behind creating billion-dollar brand names like Azure, Vercel, Windsurf, Sonos, Blackberry, and Impossible Burger | David Placek (Lexicon Branding): https://www.lennysnewsletter.com/p/naming-expert-david-placek

• Windsurf: https://windsurf.com

• Thoughtworks: https://www.thoughtworks.com

• Cloudflare: https://www.cloudflare.com

• Shopify: https://www.shopify.com

• Jensen Huang: Nvidia’s Future, Physical AI, Rise of the Agent, Inference Explosion, AI PR Crisis: https://www.youtube.com/watch?v=gwW8GKwHB3I

• Inside Linear: Building with taste, craft, and focus | Karri Saarinen (co-founder, designer, CEO): https://www.lennysnewsletter.com/p/inside-linear-building-with-taste

• Hacker News: https://news.ycombinator.com

• Dario Amodei on X: https://x.com/DarioAmodei

• Lenny’s post on the job market in tech: https://www.lennysnewsletter.com/p/state-of-the-product-job-market-in-ee9

• Claude app: https://apps.apple.com/us/app/claude-by-anthropic/id6473753684

• Gemini: https://gemini.google.com/app

• Import and export your memory from Claude: https://support.claude.com/en/articles/12123587-import-and-export-your-memory-from-claude

• Wispr Flow: https://wisprflow.ai

• The last six months in LLMs, illustrated by pelicans on bicycles: https://simonwillison.net/2025/Jun/6/six-months-in-llms

• Gemini 3.1 Pro: https://simonwillison.net/2026/Feb/19/gemini-31-pro

• Redis: https://redis.io

• Node.js: https://nodejs.org

• Simon’s tools repository: https://github.com/simonw/tools

• Simon’s research repository: https://github.com/simonw/research

• Tesseract: https://github.com/tesseract-ocr/tesseract

• TDD: https://martinfowler.com/bliki/TestDrivenDevelopment.html

• Red/green TDD: https://simonwillison.net/guides/agentic-engineering-patterns/red-green-tdd

• The lethal trifecta for AI agents: private data, untrusted content, and external communication: https://simonwillison.net/2025/Jun/16/the-lethal-trifecta

• Prompt injection: https://simonwillison.net/series/prompt-injection

• The coming AI security crisis (and what to do about it) | Sander Schulhoff: https://www.lennysnewsletter.com/p/the-coming-ai-security-crisis

• AI prompt engineering in 2025: What works and what doesn’t | Sander Schulhoff (Learn Prompting, HackAPrompt): https://www.lennysnewsletter.com/p/ai-prompt-engineering-in-2025-sander-schulhoff

• The Challenger Disaster: Normalisation of Deviance: https://psychsafety.com/normalisation-of-deviance

• Thanksgiving Day Chart—Behind The Net: https://www.blackswanreport.com/blog/2009/11/thanksgiving-day%C2%A0chart-behind-the-net

• CaMeL offers a promising new direction for mitigating prompt injection attacks: https://simonwillison.net/2025/Apr/11/camel

• OpenClaw: https://openclaw.ai

• Introducing ai.com—Your Private, Personal AI Agent: https://www.youtube.com/watch?v=n7I-D4YXbzg

• Tamagotchi: https://en.wikipedia.org/wiki/Tamagotchi

• NanoClaw: https://nanoclaw.dev

• Spider-Man 2: https://www.imdb.com/title/tt0316654

• Alfred Molina: https://en.wikipedia.org/wiki/Alfred_Molina

• AI for Data Journalism: demonstrating what we can do with this stuff right now: https://simonwillison.net/2024/Apr/17/ai-for-data-journalism

• Kākāpō: https://en.wikipedia.org/wiki/K%C4%81k%C4%81p%C5%8D

• Kākāpō Cam: Rakiura the kākāpō—2026 nest: https://www.youtube.com/live/BfGL7A2YgUY

Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email podcast@lennyrachitsky.com.

Lenny may be an investor in the companies discussed.

My biggest takeaways from this conversation:

Read more

Claire Vo went from public OpenClaw skeptic to running nine dedicated AI agents that manage her businesses, write code, close sales deals, and make sure she gets to her kids' basketball games on time. In this episode, she shares her complete power-user's guide to OpenClaw—covering everything from setup and key concepts to practical workflows and building your own team of agents.

In this episode, you’ll learn:

• What OpenClaw is and why it’s more autonomous and powerful than other AI tools

• How to choose the right setup: Mac Mini, VPS, or a hosted option

• Six ready-to-copy workflows you can start using immediately

• How to run multiple agents with specific roles (Claire’s full 9-agent setup)

• The best tools and integrations to connect your agents to the real world

• Key security considerations and how to think about risk

Subscribe now

P.S. Get a full free year of Lovable, Manus, Replit, Gamma, n8n, Canva, ElevenLabs, Amp, Factory, Devin, Bolt, Wispr Flow, Linear, PostHog, Framer, Railway, Granola, Warp, Perplexity, Magic Patterns, Mobbin, ChatPRD, and Stripe Atlas by becoming an Insider subscriber. Yes, this is for real.

“OpenClaw is probably the single most important release of software, probably ever.” —Jensen Huang, Nvidia CEO

Claire Vo has put together the definitive step-by-step guide to getting started with and mastering OpenClaw. Building on our podcast episode, this post covers everything you need from first install to running a full team of AI agents, plus the specific use cases that have changed her life. Whether you’re brand new to OpenClaw or already running one, Claire’s guide will level you up.

A big thank-you to Peter Steinberger, Dave Morin, and Nat Eliason for reviewing drafts of this post. For more from Claire, check out her podcast How I AI and ChatPRD, and find her on X and LinkedIn.

At 6 a.m., before I’ve looked at my phone, an AI agent named Polly has already read my email, checked my calendar, and queued up my day. By the time I sit down for coffee, another agent has reminded my husband about spirit day at school. A third AI is halfway through drafting a sales email, which will land in our prospect’s inbox three minutes after they contact us. One of the agents even helped draft this paragraph (though the rest was lovingly written by my human hands).

None of this existed three months ago.

If you’re paying attention to AI news, you’ve probably heard about OpenClaw. For a while, it seemed like X was nothing but lobster emojis and breathless posts about everything it can do: running your business, buying cars, planning the AI uprising with its friends, and more. You’ve also probably seen some horror stories, like when it started deleting this user’s full Gmail inbox, or that time it completely screwed up my own personal calendar.

You’re interested, and a little scared. I was too. But the idea of a dedicated personal assistant that could help run my life and businesses was so appealing that I had to dig in. The more I play with OpenClaw, the more convinced I am that it is one of the most powerful AI tools for personal use, and a sign of where these tools are going.

Fast-forward two months, I’m chatting 24/7 with my nine (and counting!) OpenClaw agents, which operate my businesses, write code, close sales deals, and make sure I get to my kids’ basketball games on time.

OpenClaw is powerful but a little tricky to set up. After a lot of trial and error, I figured out how to make it work—and make my Claws work for me. Here’s exactly how you can too:

First, what is OpenClaw?

OpenClaw is an open-source personal AI assistant that is more powerful, more autonomous, and more fun to use than anything else I’ve tried. To tell it what needs to be done, you can message it easily on the platforms you already use, like WhatsApp, Telegram, Slack, etc. Then it can control your computer and take care of tasks just as you would, working on its own schedule—even overnight. It’s always on, runs locally, and it can build its own new skills. Teach it once; it handles the rest.

Practically, this means I can text my OpenClaw something like “Let’s make sure our website always has the latest reasons why we’re better than competitors.” It will use web search, our GitHub repo, and public APIs to find the information it needs, and ship PRs with the updates. Every week, it will refresh those pages with new data based on new features or market news.

One text turns into an always-on agent. But how you set it up is important, and understanding a few key concepts will save you tens of hours of frustration.

Key OpenClaw concepts:

• It runs a local gateway that takes in messages. Think of this as a general-purpose inbox that can receive instructions from any channel (e.g. terminal, Telegram, WhatsApp, etc.)

• Behind this gateway are agents, which have their own identities, tools, and workspaces

• Agents work on a scheduled set of cron jobs and a heartbeat that gets checked every 30 minutes

• It can use (and self-install!) skills, APIs, and CLIs to interact with systems and the outside world

• It’s deployed on an owned machine, like a Mac Mini or a VPS on the cloud that you own and operate yourself

I’ve written in detail about the mechanics of OpenClaw here. The docs site is also very helpful, especially these top-level pages on channels, agents, and tools:

But enough theory. Let’s set up your sentient virtual lobster.

Setting up your first OpenClaw

What computer to use, and do you need a Mac Mini?

You have options for where to install your OpenClaw, but most importantly, do not install it on a work or personal computer that’s actively in use. This is very dangerous. OpenClaw can technically have access to all the files on the computer it runs on, and no matter how careful you are, you don’t want to risk deleting everything, or emailing your personal files to an unsavory character.

The OpenClaw team has done a great job of hardening security, but it’s best to start with an isolated box.

You have three safe options for installing OpenClaw:

1. Sign up for a hosted version of OpenClaw. Startups are popping up every week that make this easy to do. Some of the more popular options include StartClaw, MyClaw, SimpleClaw, UniClaw, and Every’s Plus One. I experimented with a few of these, and they are slick, but I always got stuck on something. These products will get better, and I expect this to be how most people will experience OpenClaw over time.

2. Have it run in a virtual private server. This may be the cheapest option, but it’s also the most complicated. Some of the more popular options include Railway, Hostinger, DigitalOcean, Google Cloud, and Render. I didn’t try going this route, but many technical people prefer it, because it’s quick, powerful, and doesn’t require new hardware.

3. Use a laptop or (yes) a Mac Mini. I started with an old MacBook Air and eventually moved to a stack of Mac Minis.

You don’t actually have to run it on a Mac Mini—you can use any computer, even an old laptop—but the Mac Mini is simple, powerful, and compact. And it’s kind of become a meme. This option is the most expensive, at least up front, and time-consuming, but also the most fun, educational, and cute!

If you can swing it, I’d try this. (I got the lowest-end model: M4, 16GB, 256GB, about $600.) Just remember to grab a keyboard, mouse, and a monitor for your initial setup. Use whatever you have lying around; you won’t need it again after everything is running.

Your pre-work

OK, you’ve got your machine booted up. Before we install the Claw, here are a few quick things that will make setup easier (this will take you about 10 minutes):

1. Set up a fresh admin account and password on the computer you’ll be using

2. Sign up for a Gmail address for your agent (later, you can give it read-only access to your calendar)

3. Make sure Chrome is installed, which is OpenClaw’s preferred browser

Installing OpenClaw

Opening the terminal and installing OpenClaw

Open the terminal (Command ⌘ + Space, type “Terminal,” hit Return), and run:

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

This will install everything you need and drop you into the onboarding. If you get stuck, install Claude Code and/or Codex and ask for help!

Onboarding

Once the install is complete, OpenClaw will walk you through a guided onboarding flow step-by-step. The first step is acknowledging a security warning. Read this!

If you’re ready for the adventure, you can continue through the onboarding. Here are my pro tips for the key steps:

Know how to navigate the terminal

If you’re not familiar with working in the terminal, the onboarding process is a little confusing. Use arrow keys to navigate up, down, left, and right, spacebar to select, and enter to submit.

Pick your default model

I recommend Claude Opus 4.6 or Codex 5.4 (or whichever model is the most powerful at the time you’re reading this).

Authenticate your model provider

You have two options for using paid models like Opus or Codex:

1. Use an existing subscription by logging in to your Claude or ChatGPT account.

Note: There are some rumors that Anthropic is banning people who reuse their Claude accounts for OpenClaw. When using any third-party account with OpenClaw, review the terms of service and proceed at your own discretion.

2. Use an API key, which you can get by setting up a developer account at Claude or OpenAI. This is the recommended path, and what I use.

Choose a channel to “talk” to your agent

The best beginner-friendly channel is Telegram. More on this below.

Set up web search

This will give your Claw access to the internet. You can skip and set this up later when you need it.

Install skills from a list of bundled defaults

I recommend the gog skill for Gmail, Google Calendar, and Docs access and summarize to start.

Enable hooks

These are helpful tools that keep your OpenClaw setup optimized. I turned on all four of these, but session memory is the most important. The others are helpful when you want to debug or optimize your agent.

Then your agent will “hatch” in the TUI (Terminal UI). Hello, world!

Setting up Telegram

You’ll want a better chat interface than the terminal, so open up your phone and download Telegram, a messaging app and the simplest way to connect with your OpenClaw. If you ask OpenClaw, it can walk you through the setup steps, including messaging the @BotFather (yes, really).

Your first chat

Setting up your agent is where you should put on your manager hat. Just like an employee, it can’t be good at everything, so think about a specific job for your OpenClaw. Personal assistant? Social media manager? Engineering intern? Start with one idea and you can always add on more later. If you’re unsure where to start, begin with a personal assistant like I did.

This is where things get fun. Once your OpenClaw is hatched, it will start asking you about yourself and itself to build its definitions and operating model.

You should make sure to share:

1. Your name

2. Your role/job

3. Common admin challenges in your life (scheduling, remembering tasks, coordination with your family)

All this gets written down by the agent and stored in the workspace folder you set up in onboarding (usually .openclaw/[agent_name]-workspace) as Markdown files.

Those files become your agent’s identity and operating system. They are read every time your OpenClaw starts up and give your agent everything it needs to do a good job. It’s fun to look at these files; occasionally, you may need to go in and edit them.

• AGENTS.md—OpenClaw’s core set of instructions and memory

• SOUL.md—Your agent’s persona, tone of voice, and clear boundaries

• IDENTITY.md—Your agent’s name, vibe, and personal emoji

• TOOLS.md—Notes on tools and how your agent should use them

• USER.md—All about you, your OpenClaw’s human

Once its identity and role is set, it should ask you to get started on a first task. Time to Claw!

How I AI: my personal OpenClaw setup

OK, so you finally have this bot set up. What do you actually do with it?

Six easy and useful OpenClaw workflows

I do a lot with my OpenClaw agents now, but below are some easy places to start. Just copy and paste these prompts and OpenClaw will do the rest.

1. Coordinate a busy weekend

Every Friday, group message me and my husband to confirm the kids’ weekend activity logistics. If there is a conflict, confirm who will pick up each kid and any adjustments we may need to make to lunch or dinner plans. Ask us to explicitly confirm the plan and update our shared family calendar.

2. Find trending topics and generate memes for social media

Every morning, search for trending Reddit topics (r/funny, r/technology) about product management. Use the MemeLord API to generate one image and one video meme, send it to me for approval, then post to TikTok.

3. Look through PLG sign ups for high value enterprise prospects, enrich and follow up

Every morning, look through the signups for the last 24 hours. Find everyone who signed up with a company domain, and categorize into high-value prospects based on our ideal customer profile. For ones with < 1,000 employees, send a light-touch email based on SALES_PLAYBOOK.md. For companies with > 1,000 employees, enrich their profile with Exa People API and confirm with me before sending.

4. “Just in time” meeting prep

Check all my calendars for any meetings starting in the next 30 minutes. If there is a meeting starting soon, send me a pre-meeting brief on Telegram. Include meeting title and time, who’s attending, and agenda if available from the calendar event description, and our last interaction based on the most recent email thread or meeting notes with this person/company.

5. Write support docs overnight

Every Friday evening, look over our resolved support tickets. If any question has been asked 3+ times this week: (1) flag it as a docs/FAQ candidate, (2) create a Linear issue and assign to @agent to add a docs page to/docs covering the answer, (3) include the standard answer you’ve been giving as a starting point in the issue description.

6. Project manage me

I have a project launching on <date>. Keep a to-do list with everything I tell you I need to do for a successful launch, and break the plan down into daily tasks I can easily get done. At the end of the week, celebrate what I accomplished and flag what I missed. Make sure we do everything possible to make this project successful.

Running multiple agents: my biggest unlock

I love how flexible OpenClaw is; it feels like it can do almost anything. But I’ve found that you shouldn’t try to get one agent to do everything.

Just like me, you can set up many OpenClaw agents on the same machine. Just run openclaw agents add agent_name and you’ll get put through onboarding again for a fresh agent. This agent can have a completely separate identity, set of tools, crons, and workspace, which means you can treat it like a completely different employee.

Multi-agent setup was the unlock for me when using OpenClaw. Instead of trying one bot to do everything, I created a full team of OpenClaws to do different jobs around my work and business. With a narrower identity, the bots did a better job and were more fun to work with.

You can even ask one agent to spawn another. Try something like:

Hey Bob, I just set up Annie the Marketing Intern. Transfer everything in your SOUL, memories, and crons about marketing to her workspace and erase it from yours.

Your Claws can perform brain surgery!

I’m now running a whole team of agents across my life and business. I don’t find it much different than managing a remote team, so I’m able to get a lot of leverage out of my army of Claws. Here’s how they work:

1. Polly, the personal assistant.

   • Has access to: email, calendar, Linear

   • Helps with: scheduling, making sure I don’t forget emails, meeting prep, ad hoc projects

   • Helpful crons: morning digest, evening wrap-up, hourly email sweep

2. Finn, the family manager

   • Has access to: email, calendar, school and sports schedules

   • Helps with: family coordination, kids appointments, household tasks (scheduling repairs!)

   • Helpful crons: afternoon logistics check (who is picking up the kids?), weekend planning (how do we make it to all the birthday parties and soccer games?)

3. Max the marketer

   • Has access to: X API, Buffer API, Linear, marketing website

   • Helps with: scanning social media for trends, drafting content, building out our website

   • Helpful crons: 3x a day PM meme query on X, weekly review of blog content to repurpose for LinkedIn

4. Sam the sales guy

   • Has access to: Attio CRM, email, calendar

   • Helps with: qualifying leads, outbound to promising PLG signups, keeping the CRM clean

   • Helpful crons: morning PLG sweep for high-value signups, end-of-week late-stage pipeline review

5. Holly the helpdesk bot

   • Has access to: support email, Intercom

   • Helps with: answering basic support questions, ensuring tickets don’t get dropped, cleaning up Intercom tickets

   • Helpful crons: hourly check for support emails that come into the wrong inbox

6. Sage the course operator

   • Has access to: GitHub course repo and knowledge base, group chat with my co-instructor

   • Helps with: researching supplemental materials, project managing our course launch, reminding two engineers to do marketing, building out our student portal, researching signed-up students

   • Helpful crons: Monday/Wednesday reminder to post to LinkedIn about the course

7. Howie the How I AI producer

   • Has access to: YouTube studio, email, Linear, Google Docs, buffer

   • Helps with: managing guest pipeline, prepping guest briefs, coming up with thumbnail/title ideas, making sure I post to socials enough

   • Helpful crons: Monday podcast launch check and social drafts, morning recording prep brief

8. Kelly the developer

   • Has access to: GitHub, Claude Code, Codex

   • Helps with: small development tasks and ad-hoc prototyping

   • Helpful crons: looks every morning in Linear for assigned tasks, starts a branch, and opens a PR

9. Q the professor

   • Has access to: web search, kids’ books and workbooks

   • Helps with: answering fun questions from the kids, vibe coding one-off apps to teach math and reading concepts

   • Helpful crons: every morning, shares a word of the day and a math problem of the day for each of my kids

Optimizing your OpenClaw setup

Add tools, skills and integrations to make magic

Without integrations, OpenClaw might feel like a more complicated, harder-to-install Claude Code. But with integrations, magic happens. Some integrations I find very useful:

• Use email, schedule events, and write docs with gog, the CLI tool for integrating with your Gmail, Google Calendar, and Google Drive. You can give your Claw its own email address, read access to your calendar, read access to your email, or, if you’re brave—write access to everything. Just ask OpenClaw, “How do I give you read-only access to my Gmail?” and you’ll be on your way.

• Research and find information through web search with Brave API (comes pre-loaded) or your preferred tool. I use Exa search. You can also use Perplexity or Firecrawl.

• Give access to your GitHub for coding. You can give it a narrowly scoped Personal Access Token and OpenClaw becomes an on-demand developer.

• Use Linear for assigning you tasks. I gave mine a Linear token so it could assign me work or pass things off to our team.

• Try Obsidian for sharing docs with your agent. Because OpenClaw loves writing Markdown, many people are using Obsidian as a shared source of truth and collaboration space with their agents.

You can also have it turn on and off your Eight Sleep system, play music on your Sonos, and manage your lightbulbs. You don’t need a step-by-step tutorial, just ask your Claw to figure it out.

Hey Polly, I have a newborn baby and need some extra sleep. Turn down the bedroom lights and play white noise by 8:30 p.m. and turn off my Eight Sleep alarms for the next 3 months.

When installing these tools, you’ll be asked to authenticate or give an API token (this is where 1Password is helpful). Remember, OpenClaw is fairly autonomous, and when you give it tools it could:

• Send emails

• Overwrite documents

• Delete support tickets

• Fill out web forms

• Deploy code to production

. . . especially if you do not instruct it clearly. The best protection is giving read-only tokens to OpenClaw until you’re ready.

Care and feeding

Your OpenClaw will forget things. Its crons will break. Sometimes you’ll message “hellooooo?” into the void.

Just like with my human team, I find myself asking questions like “Where are we with that project?” and “Did you forget to email so-and-so?” OpenClaw isn’t perfect, but it is pretty good at fixing itself.

Some tips:

• You’ll sometimes need access to the terminal on your main machine. If you’re using a physical device, an easy way to do this is to turn on Screen Sharing and Remote Login on your Mac. Then you can “open” the terminal and computer from your main laptop (as long as you are on the same Wi-Fi) without having to plug in a monitor, keyboard, and mouse.

• Ask it to repair itself. If it’s forgetting something, ask it to inspect and fix its crons. If it’s doing a task wrong, ask what is in TOOLS.md. If it really needs to remember something, tell it to write to its SOUL.

• When in doubt, call in Claude Code. Your OpenClaw is simply a folder of files and JSON configurations. If it gets really broken, open up Claude Code, paste some docs, and ask it to repair.

Some notes on security

The biggest hesitation I hear from people is about security—for good reason. “Will OpenClaw steal my credit cards, delete my computer, and run away with my spouse?” Probably not. But there are some technical and security considerations you should know about.

Security should be an always-on process. Regularly update your OpenClaw to the latest, most secure version (openclaw update) and run security audits regularly (openclaw security audit). I have a scheduled reminder in my agents to run both of these commands regularly and review its workspace against the docs for best practices and security gaps.

Beginners should not share their OpenClaw in a group chat or public channel. Anyone who can chat with your bot can instruct it. While I have put my OC in a group chat with my husband and another with a trusted business partner, OpenClaw is intended to be a personal agent for a single, trusted user.

The outside world can influence your OpenClaw. If it has an email, reads websites, or accesses public content, it is subject to prompt injection. Imagine: your OpenClaw finds a website during search that tells it to share all its API keys. No good! While the OpenClaw framework has done a lot to harden against prompt instruction, it’s a good idea to reinforce these rules in its SOUL.

Your OpenClaw has full access to your computer and can run commands, edit files, and install software. It can access the internet. It shouldn’t do anything harmful, but that doesn’t mean it can’t.

If you give it an email or a public API (e.g. Gmail, Twilio), it can communicate externally (and might even impersonate you). Make sure that its SOUL and TOOLS files are very explicit about how it is allowed to communicate with the outside world.

To use tools, you will be storing API keys and secrets. The simplest way to give your OpenClaw access to environment variables is to put them in .openclaw/.env.

Not all skills are safe. While skills are a helpful way for OpenClaw to learn to do new things, I only install skills from the official OpenClaw bundle or from developers I know personally. Community skills at clawhub.com are worth exploring, but read the SKILL.md before running anything you find online.

You need to think about operational security and worst-case scenarios. Think about what you’re actually sharing: Your calendar has your physical location. Your email has your financials. Your OpenClaw could know your kids’ school schedules. This is all information that could be exploited by a bad actor in a worst-case scenario. Be thoughtful about what you want to share and how you want your Claw to interact with the outside world.

In my experience, OpenClaw isn’t inherently less secure than some other systems; people are just more willing to give it access without understanding the underlying risks. Start small and build your own trust models.

Warning: it can get expensive

Full transparency: I’m on my way to spending $1,000 per month on my OpenClaw setup. I pay directly for API costs, which is the most expensive model but also the most reliable. I’ve just started to optimize spending by switching some agents to my ChatGPT account, which is going well so far. For me, this is a business expense, and much less costly than hiring a full team of humans to do this work (even part-time).

That being said, most people will be fine using their $100 to $200 ChatGPT subscription (which has been blessed by OpenAI). You could also try less expensive models for some tasks (though be warned, some are not as hardened against prompt injection and other risks) or risk using your Claude subscription.

Now it’s your turn

I started this journey unsure if OpenClaw would be another AI toy I’d abandon after a week. What I got instead was something I didn’t expect: a team that shows up when I need them.

Beyond my own personal productivity, it’s the first agentic product I’ve tried that feels like hiring a team. Though I’ve been thinking about the future of agent employees for a while, OpenClaw has made the mechanisms by which we’ll “hire,” onboard, and collaborate with agents much more concrete. I can see the future, and it looks a lot like humans working with Claws.

Is it perfect? No. Polly still occasionally gets confused about time zones. Sam will sometimes draft a sales email I have to rewrite. AI still isn’t very funny. Crons break, and I say “hellooo?” into the void more than I’d like to admit.

But here’s the thing about managing a team—human or AI: I don’t need perfection. I need leverage. OpenClaw, when it’s working well, gives me more leverage than any agent I’ve tried so far. And that leverage is compounding.

So here’s my challenge to you: Set up your OpenClaw and spend one week with it. Start with one or two basic tasks, and end the day by asking it, “Based on what we did today, what can you help me with tomorrow?” Get creative. Have a little fun. Take a small risk or two.

You’ll start to see what I see—an operating system for your life and work that gets better the more you invest in it, and a fast-approaching future where your team includes “people” that aren’t people.

Now stop reading and go build your team! The world is your lobster. 🦞

Thanks, Claire! For more from Claire, check out her podcast How I AI and ChatPRD, and find her on X and LinkedIn. And, don’t miss her upcoming Maven course: Executive Playbook for AI in Engineering, Product, and Design.

Questions for Claire? Leave a comment 👇

Leave a comment

Have a fulfilling and productive week 🙏

If you’re finding this newsletter valuable, share it with a friend, and consider subscribing if you haven’t already. There are group discounts, gift options, and referral bonuses available.

Subscribe now

Sincerely,

Lenny 👋

How Stripe built “minions”—AI coding agents that ship 1,300 PRs weekly from Slack reactions | Steve Kaliski (Stripe engineer)

Brought to you by:

• Optimizely—Your AI agent orchestration platform for marketing and digital teams

• Rippling—Stop wasting time on admin tasks, build your startup faster

Steve Kaliski has spent over six years building developer infrastructure at Stripe. In this conversation with Claire, he breaks down Stripe’s “minions”: AI coding agents that ship about 1,300 pull requests per week, often kicked off with nothing more than a Slack emoji. He explains why the real bottleneck in engineering isn’t coding, how cloud development environments unlock parallel AI workflows, and what it takes to safely review thousands of AI-generated PRs. He also demos AI agents that can spend money, coordinate services, and complete tasks end-to-end without human involvement.

Biggest takeaways:

1. What’s good for human developers is good for AI agents (and vice versa). Stripe’s years of investment in developer experience—comprehensive documentation, blessed paths for common tasks, robust CI/CD, excellent tooling—directly translates to higher AI agent success rates. When you have clear docs on “how to add a new API field,” the agent can follow those same instructions. This creates a virtuous cycle: investments in DX improve agent performance, and investments in agent infrastructure (like cloud environments) benefit human developers too.

2. Activation energy is the real bottleneck, not coding speed. Steve hasn’t started work in a text editor in months. Instead, work begins in Slack threads, Google Docs, or support tickets—the natural places where ideas emerge. By allowing engineers to kick off development with a single emoji reaction, Stripe lowered the friction between “good idea” and “code in production.” This is especially powerful in large organizations, where coordination costs typically kill momentum before coding even begins.

3. Cloud development environments are non-negotiable for multi-threaded AI work. Running multiple AI agents in parallel requires cloud-based dev environments that can spin up in seconds, run isolated workloads, and never fall asleep. This infrastructure investment—which Stripe’s developer productivity team built long before AI agents—now enables engineers to run dozens of agents simultaneously without melting their MacBook Pros.

4. 1,300 AI-written PRs per week requires shifting review capacity, not eliminating it. Stripe still reviews every AI-generated PR, but the review process relies heavily on automated confidence signals: comprehensive test coverage, synthetic end-to-end tests, and blue-green deployments that enable quick rollbacks. The bottleneck shifts from writing code to reviewing it—and eventually to generating enough good ideas in the first place.

5. Machine-to-machine payments unlock ephemeral, API-first businesses. In Steve’s birthday party demo, Claude Code autonomously paid Browser Base, Parallel AI, and Postal Form for single-use services—no human signup, no subscription, no dashboard. Businesses can now optimize for agent consumers rather than human users, focusing on “hyper-useful single APIs” instead of landing pages and admin panels. The economics become transparent: tokens and dollars sit side by side, making the true cost of AI work visible.

6. Treat AI agents like new employees, with progressive trust. Start with limited access, expand permissions as the agent proves reliable, and maintain clear boundaries. Each minion runs in an isolated environment with specific data access—the finance agent can read bank statements but can’t send messages; the scheduling agent can text but has no financial data. This physical partitioning prevents accidental data leakage and creates accountability.

7. The future of software is disposable and hyper-personalized. Steve builds custom iOS apps for his toddler—music players limited to six specific songs—despite having no iOS development experience. He describes this as “the disposability of software”: when AI can build apps in hours, you can create single-purpose tools for incredibly specific use cases and throw them away when they’re no longer needed.

Detailed workflow walkthroughs from this episode:

• How Stripe’s AI ‘Minions’ Ship 1,300 PRs Weekly from a Slack Emoji: https://www.chatprd.ai/how-i-ai/stripes-ai-minions-ship-1300-prs-weekly-from-a-slack-emoji

• How to Build an Autonomous AI Agent That Pays for Services to Complete Tasks: https://www.chatprd.ai/how-i-ai/workflows/how-to-build-an-autonomous-ai-agent-that-pays-for-services-to-complete-tasks

• How to Automate Code Generation from a Slack Message into a Pull Request: https://www.chatprd.ai/how-i-ai/workflows/how-to-automate-code-generation-from-a-slack-message-into-a-pull-request

How to turn Claude Code into your personal life operating system | Hilary Gridley

Brought to you by:

WorkOS—Make your app enterprise-ready today

Lovable—Build apps by simply chatting with AI

Hilary Gridley returns to the podcast to share how her approach to productivity has completely evolved since her last appearance. Now a new mom and entrepreneur, she walks Claire through how she uses Claude Code as a personal operating system, managing everything from daily planning to life admin without complex tools or rigid workflows. Instead of building elaborate systems, Hilary leans into what she calls the “anti-system system”: letting AI observe her behavior, learn her preferences over time, and gradually take work off her plate. Together, Claire and Hilary explore how simple inputs—like capturing tasks with a shortcut or “yapping” to Claude throughout the day—can replace traditional productivity stacks and integrations.

Biggest takeaways:

1. The 10x impact framework: For any task, ask “If I were 10 times better at it, would it have 10 times the impact?” If no, automate it. If yes, keep it human. This applies to both work tasks and life tasks—including whether baking bread will bring you joy or feel like a chore.

2. Complexity has to earn its keep. Hilary only connects APIs and builds complex integrations after testing the “janky version” of a workflow for a week. Her hit rate is only 20% on workflows she actually continues using, so starting simple saves massive time.

3. The yappers API beats OAuth every time. Instead of connecting all your tools in the background, just talk to Claude about what you’re doing throughout the day. Hilary keeps Claude Code open in her terminal and narrates her work, letting Claude observe and take notes without complex integrations.

4. Let AI learn your preferences by observing, not by your defining them. Hilary never sat down to write out her ideal schedule. Claude just watches what she actually does (not what she says she’ll do) and adjusts preferences automatically. Real behavior beats aspirational planning.

5. Calendar management is the ultimate to-do list. You can’t say you take something seriously if you’re not putting time into it. But manually adding tasks to your calendar is tedious—so let Claude do it automatically based on what you say you want to accomplish.

6. Screenshots are your friend for getting started. Don’t wait for API access or permissions at work. Build a janky version with screenshots and voice dictation, prove it’s valuable, and then get the permissions you need. Half-baked ideas don’t deserve full access.

7. You don’t need coding knowledge to build Claude Code skills. Hilary just describes problems to Claude: “I keep forgetting to return things on time.” Claude asks a few questions, then builds the entire workflow—including checking return policies and drop-off locations automatically.

8. Test everything before integrating it into working systems. Hilary refuses to add new workflows to her daily routine until she’s tested them separately for a week. If something breaks, you don’t want it taking down systems that were already working.

9. Build the muscle memory by doing one thing with AI every day. The biggest barrier isn’t technical knowledge—it’s rewiring your brain to think “the alien in my computer could help with this.” Hilary went from “I’ll never use the terminal” to running her life in Claude Code in about a week.

Detailed workflow walkthroughs from this episode:

• How I AI: Hilary Gridley’s “Anti-System” for Automating Life with Claude Code: https://www.chatprd.ai/how-i-ai/gridleys-anti-system-for-automating-life-with-claude-code

• Create a Privacy-Protecting Demo Mode for Your Personal AI: https://www.chatprd.ai/how-i-ai/workflows/create-a-privacy-protecting-demo-mode-for-your-personal-ai

• Build Custom AI Automations by Having a Conversation with Claude: https://www.chatprd.ai/how-i-ai/workflows/build-custom-ai-automations-by-having-a-conversation-with-claude

• Automate Your Daily Planning with Claude Code and an iPhone Shortcut: https://www.chatprd.ai/how-i-ai/workflows/automate-your-daily-planning-with-claude-code-and-an-iphone-shortcut

If you’re enjoying these episodes, reply and let me know what you’d love to learn more about: AI workflows, hiring, growth, product strategy—anything.

Catch you next week,
Lenny

P.S. Want every new episode delivered the moment it drops? Hit “Follow” on your favorite podcast app.

Hilary Gridley is an entrepreneur, former product leader, and new mom who previously appeared on the podcast discussing AI for managers. She returns to share how she's transformed her approach to personal productivity using Claude Code as her primary tool for managing both professional work and life admin. Hilary demonstrates her "anti-system system"—a philosophy that prioritizes simplicity over complex setup, allowing AI to learn preferences through observation rather than upfront configuration.

What you’ll learn:

1. How to capture to-dos instantly using a simple iPhone back-tap shortcut that requires zero app switching

2. The “10x impact framework” for deciding what tasks to automate versus where to invest your human effort

3. How to use Claude Code’s observation capabilities to build a preference file that improves over time without manual setup

4. Why the “yappers API” (talking about what you’re doing while working) eliminates the need for complex OAuth integrations

5. A workflow for breaking down overwhelming tasks into 10-minute first steps that actually get completed

6. How to create Claude Skills by simply describing problems rather than writing code or following tutorials

7. Techniques for using “recording mode” to demo workflows without exposing personal information

Brought to you by:

WorkOS—Make your app Enterprise Ready today

Lovable—Build apps by simply chatting with AI

In this episode, we cover:

(00:00) Introduction to Hilary Gridley

(02:43) The opportunity cost of time as a new mom and entrepreneur

(07:11) Philosophy of the anti-system system

(08:05) Demo: Planning your day with Claude Code

(10:00) Setting up simple iPhone shortcuts for task capture

(11:48) How Claude organizes reminders and learns preferences automatically

(16:19) Breaking down overwhelming tasks into manageable first steps

(23:40) The yappers API: talking to Claude instead of building integrations

(25:28) Daily logging and observation patterns

(27:45) Quick summary

(30:50) The power of screenshots

(32:55) 10x impact framework for automation decisions

(37:51) Applying the framework to different career stages

(39:29) Building a “recording on” skill for anonymizing demos

(44:11) Building a returns tracking skill from scratch

(48:31) Building the muscle memory to reach for AI tools

(50:18) Where to find Hilary

Tools referenced:

• Claude Code: https://claude.ai/code

• Obsidian: https://obsidian.md/

• iPhone Shortcuts: https://support.apple.com/guide/shortcuts/welcome/ios

• Cursor: https://cursor.sh/

Other references:

• Figma file Hilary demo’ed: https://www.writerbuilder.com/howiai

Where to find Hilary Gridley:

Substack: https://hills.substack.com/

Website: https://writerbuilder.com

Where to find Claire Vo:

ChatPRD: https://www.chatprd.ai/

Website: https://clairevo.com/

LinkedIn: https://www.linkedin.com/in/clairevo/

X: https://x.com/clairevo

Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email jordan@penname.co.

Claire Vo is the host of our sister podcast, “How I AI,” a former product executive and engineer, and founder of an AI startup called ChatPRD. Claire now runs her business, podcast, and family life with the help of nine OpenClaw agents running on multiple Mac Minis and old laptops. In this episode, Claire shares her journey from OpenClaw skeptic (it deleted her family calendar the first time she tried it) to true believer, and gives a masterclass in using AI agents in real life.

We discuss:

1. The exact step-by-step process to install and set up OpenClaw (it’s easier than you think)

2. How to avoid the biggest OpenClaw mistakes (don’t install it on your main computer)

3. Actual use cases that have changed Claire’s life (e.g. family scheduling, inbound sales, podcast prep, and course management)

4. Why multiple specialized agents beat one general-purpose agent

5. The security risks everyone worries about—and how to handle them

6. Browser limitations, memory issues, and practical workarounds

Brought to you by:

Mercury—Radically different banking

Omni—AI analytics your customers can trust

Orkes—The enterprise platform for reliable applications and agentic workflows

Where to find Claire Vo:

• X: https://x.com/clairevo

• LinkedIn: https://www.linkedin.com/in/clairevo

• Podcast: https://www.youtube.com/@howiaipodcast

• Website: https://clairevo.com

• ChatPRD: https://www.chatprd.ai

Referenced:

• OpenClaw: https://openclaw.ai

• Claude Cowork: https://claude.com/product/cowork

• Fry’s Electronics: https://en.wikipedia.org/wiki/Fry%27s_Electronics

• Peter Steinberger on LinkedIn: https://www.linkedin.com/in/steipete

• Telegram: https://telegram.org

• WhatsApp: https://www.whatsapp.com

• Fin: https://fin.ai

• Why OpenClaw feels alive even though it’s not (this AI has a heartbeat but not a brain): https://x.com/clairevo/status/2017741569521271175

• 5 OpenClaw agents run my home, finances, and code | Jesse Genet: https://www.youtube.com/watch?v=96Vl8s3EQhk

• Executive Playbook for AI in Engineering, Product, and Design: https://maven.com/clairevo/ai-native-epd-org

• Zach Davis on LinkedIn: https://www.linkedin.com/in/zach-m-davis/

• ChatGPT Atlas: https://chatgpt.com/atlas

• Perplexity Comet: https://www.perplexity.ai/comet

• Browser (OpenClaw-managed): https://docs.openclaw.ai/tools/browser

• Buffer: https://buffer.com

• Brave: https://brave.com/search/api/

• Exa: https://exa.ai

• Hilary Gridley on X: https://x.com/yourgirlhils

• How to become a supermanager with AI: https://www.lennysnewsletter.com/p/how-to-become-a-supermanager-with

• How custom GPTs can make you a better manager | Hilary Gridley (Head of Core Product at Whoop): https://www.youtube.com/watch?v=xDMkkOC-EhI

• How to debug a team that isn’t working: the Waterline Model: https://www.lennysnewsletter.com/p/how-to-debug-a-team-that-isnt-working

• Jensen Huang on LinkedIn: https://www.linkedin.com/in/jenhsunhuang

• How I built a 1M+ subscriber newsletter and top 10 tech podcast | Lenny Rachitsky: https://www.lennysnewsletter.com/p/how-i-built-a-1m-subscriber-newsletter

• Age of Attraction on Netflix: https://www.netflix.com/title/81779095

• Oura Ring: https://ouraring.com/

• Eight Sleep: https://www.eightsleep.com

• Hoopsalytics: https://hoopsalytics.com

• DJI Osmo smartphone gimbal: https://www.amazon.com/DJI-Stabilizer-Tracking-Extension-Stabilization/dp/B0FJ2L67HJ?ref_=ast_sto_dp

• Silent basketball: https://www.amazon.com/Rzkipdy-Silent-Basketball-Size-27-5/dp/B0FHFSQWPP/ref=sr_1_9

• Marc Andreessen: The real AI boom hasn’t even started yet: https://www.lennysnewsletter.com/p/marc-andreessen-the-real-ai-boom

Recommended books:

• Treasure Island: https://www.amazon.com/Treasure-Island-Robert-Louis-Stevenson/dp/1505297400

• Alice’s Adventures in Wonderland: https://www.amazon.com/Alices-Adventures-Wonderland-Illustrated-Illustrations/dp/991673268X

• Charts for Babies: A Picture Book: https://www.amazon.com/Charts-Babies-Picture-Book/dp/1419785184

Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email podcast@lennyrachitsky.com.

Lenny may be an investor in the companies discussed.

My biggest takeaways from this conversation:

Read more

Read more

Steve Kaliski is a software engineer at Stripe who has spent the past six and a half years building developer tools and payment infrastructure. He’s part of the team that created “minions”—Stripe’s internal AI coding agents, which now ship approximately 1,300 pull requests per week with minimal human intervention beyond code review. In this episode, Steve demonstrates how Stripe engineers activate development work from Slack and leverage cloud-based development environments for parallel agent workflows, and demos machine-to-machine payments where AI agents transact autonomously with third-party services.

What you’ll learn:

1. How Stripe’s “minions” write 1,300 pull requests per week with minimal human intervention

2. Why a good developer experience for humans creates better outcomes for AI agents

3. The critical role of cloud development environments in unlocking AI-powered engineering velocity

4. The machine payment protocol that lets AI agents spend money to accomplish tasks

5. The code review strategy for handling thousands of agent-written PRs

6. Why non-engineers at Stripe are starting to use minions to ship code

7. The future of software businesses built primarily for agent consumers

Brought to you by:

Optimizely—Your AI agent orchestration platform for marketing and digital teams

Rippling—Stop wasting time on admin tasks, build your startup faster

In this episode, we cover:

(00:00) Introduction to Steve

(02:39) Stripe’s minions and their effect on Stripe as a whole

(04:42) Why activation energy matters more than execution

(05:44) What is a minion? The technical architecture

(06:52) Demo: Activating a minion from Slack with an emoji

(09:04) Why good developer experience benefits both humans and agents

(11:22) Walking through the agent loop and system prompts

(13:42) Why Stripe chose Goose as their agent harness

(16:00) The role of Stripe’s developer productivity team

(17:15) Why cloud environments unlock multi-threaded AI engineering

(21:14) One-shot prompting: from Slack to shipped PR

(22:04) How Stripe handles code review for 1,300 AI-written PRs weekly

(23:44) Non-engineers using minions across the company

(24:53) Demo: Planning a birthday party with Claude and machine payments

(32:15) Quick recap

(35:08) The future of ephemeral, API-first businesses for agents

(36:36) Lightning round and final thoughts

Tools referenced:

• Goose (AI agent harness): https://github.com/block/goose

• Claude Code: https://claude.ai/code

• Cursor: https://cursor.sh/

• VS Code: https://code.visualstudio.com/

• Slack: https://slack.com/

• Browserbase: https://browserbase.com/

• Parallel AI: https://www.parallel.ai/

• PostalForm: https://postalform.com/

• Stripe Climate: https://stripe.com/climate

Other references:

• Stripe machine payments: https://docs.stripe.com/payments/machine

• Blue-Green Deployment: https://martinfowler.com/bliki/BlueGreenDeployment.html

• Git worktrees: https://git-scm.com/docs/git-worktree

Where to find Steve Kaliski:

Twitter: https://twitter.com/stevekaliski

LinkedIn: https://www.linkedin.com/in/steve-kaliski-079a7710/

Where to find Claire Vo:

ChatPRD: https://www.chatprd.ai/

Website: https://clairevo.com/

LinkedIn: https://www.linkedin.com/in/clairevo/

X: https://x.com/clairevo

Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email jordan@penname.co.

Subscribe now

P.S. Get a full free year of Lovable, Manus, Replit, Gamma, n8n, Canva, ElevenLabs, Amp, Factory, Devin, Bolt, Wispr Flow, Linear, PostHog, Framer, Railway, Granola, Warp, Perplexity, Magic Patterns, Mobbin, ChatPRD, and Stripe Atlas by becoming an Insider subscriber. Yes, this is for real.

Welcome to our biannual State of the Product Job Market—our fourth and, very surprisingly, the most optimistic. In spite of the headlines about layoffs and AI taking jobs, we’re actually seeing a lot of promising signs in tech hiring, and some interesting new trends:

1. PM openings are at the highest levels we’ve seen in over three years

2. AI hasn’t slowed the demand for software engineers (at least not yet)

3. AI roles in general are absolutely exploding

4. Design roles have plateaued

5. The Bay Area is increasing in importance

6. Remote work opportunities continue to decline

7. Despite ongoing layoffs, the overall number of tech jobs continues to grow

While these numbers are promising, I know a lot of people are having a hard time finding a job right now. And more openings doesn’t automatically mean people are finding jobs more quickly. For anyone in that situation, first of all, I’m sorry. Second, I’m working on ways to help. Until then, check out the end of this post for a bunch of resources I’ve collected that’ll improve your odds of landing a gig.

Let’s get into it.

This analysis is based on data from TrueUp, one of my favorite collaborators and sources of data. They track job openings at tech companies and top startups around the world (over 9,000 companies) and make it easy to browse open gigs. Their data looks at roles at tech companies—the most sought-after and lucrative jobs. (It doesn’t include roles at non-tech companies and consulting agencies.)

1. PM openings are at the highest levels we’ve seen in over 3 years

There are over 7,300 open PM roles at tech companies globally, and trending up. This is 75% above the low we saw in early 2023, and already up nearly 20% since the start of this year. Today we have the most open PM roles we’ve seen since 2022. (You can see all of these open roles here.)

The same trend is true for engineering roles . . .

2. AI hasn’t slowed the demand for software engineers (at least not yet)

There are over 67,000 (!!!) eng openings at tech companies globally right now, with 26,000 just in the U.S. We don’t know if there would have been more open roles if not for AI or if AI is actually leading to more open roles, but since the start of this year, the increase in open eng roles is accelerating even more.

If you’re skeptical that this growth is real and likely to be sustained, we’re also seeing a surge in demand for tech recruiters. The number of open recruiter roles is almost back to 2022 peak levels. This role got hit the hardest post-Covid, and also recovered the quickest. By definition, recruiting headcount expands and contracts with hiring demand, so it’s likely a leading indication that we’re tracking toward sustained highs in hiring demand in tech.

3. AI jobs in general are absolutely exploding

AI roles were already growing fast in our last update mid-last year, but they are now hockey-sticking:

“AI roles” includes (1) all open roles at AI-driven companies, like OpenAI, Anthropic, Cursor, and Lovable, and (2) AI-specific roles at non-AI companies, like an AI PM at Figma. Browse them here.

Demand for AI engineers and AI PMs is similarly exploding.

Whether this is simply the number of AI companies being created or the headcount at top AI companies growing, it’s a good time to be in AI.

4. Design roles have plateaued

Unlike PM and engineering, open design jobs have been relatively flat since early 2023, and there are also fewer of these roles than PMs and engineers in absolute terms (about 5,700 globally).

I don’t know exactly what’s going on here, but it does feel AI-related. Unlike PM and eng, which started growing in 2024 (two years post-ChatGPT), design didn’t. If I had to venture a theory, I’d say that because AI is allowing engineers to move so quickly, there’s less opportunity—and less desire—to involve the traditional design process. A recent tweet commented on this same trend. That said, you’d think design would become a differentiator as more products compete for attention. Something to think about for your company! We’ll keep watching this trend and AI’s impact on org design more generally.

One interesting observation we made when we went a level deeper: the ratio of demand for PMs vs. designers has flipped. In mid-2023, we went from more open designer roles to more open PM roles. And ever since, PM demand has been pulling away (currently 1.27x). This will be another trend to monitor, in terms of how AI is reshaping org design.

5. The Bay Area continues increasing in importance

The Bay Area has long had the highest share of tech roles, but that share is still growing. Over 20% of all eng and designer roles are now in the Bay Area, and over 23% (!!!) of open PM roles are too (up 50% since 2022!). And all three are still going up.

A whopping third of open AI roles are based in the Bay Area, but, interestingly, this number has stayed relatively flat in the past few years. That tells me that the Bay Area unquestionably continues to be the center of AI (the next city is New York, with 10.2%), but at the same time, AI roles outside the Bay Area continue to grow at the same rate.

One more interesting data point: NYC has established itself as the #2 tech jobs location in the world, despite not being the headquarters of any of the leading tech companies. Bengaluru (formerly Bangalore), London, Tel Aviv, and Singapore continue to be the top international hubs for tech.

6. Remote work opportunities continue to decline

Read more

Contrary to what the headlines might be telling you, PM job openings are at their highest point in over three years, AI roles are hockey-sticking, and tech headcount is growing. Today’s episode is our fourth biannual update on the tech job market (the most optimistic yet) and breaks down seven key trends shaping the job landscape right now.

In this episode, you’ll learn:

• Why PMs have reason to be optimistic

• How the influx of new AI roles is shaping the industry

• The unexpected sign of tech growth

• What current job openings look like for design and software engineering roles

• Surprising trends across remote job opportunities

References:

• AI Practice Copilot for PM Interviews

• Analytical thinking interviews guide

• Google Career Dreamer

• How to pass any first-round interview

• How to use AI for your job interview

• The definitive guide to mastering product sense interviews

• TrueUp

Read the post

Read more

How Microsoft’s AI VP automates everything with Warp | Marco Casalaina

Brought to you by:

• Rovo—AI that knows your business

• Lovable—Build apps by simply chatting with AI

Marco Casalaina, VP of Core AI Products at Microsoft, walks through how he uses Warp, Microsoft 365 Copilot, and ChatGPT to spin up lightweight “micro-agents” on the fly that handle everything from Azure admin to document scanning to video compression.

Biggest takeaways:

1. Automation frees you to focus on higher-value activities. As Marco puts it: “I do something else while these agents are doing whatever it is I need them to do.” When scanning his daughter’s homework, he was able to help her with math problems instead of fighting with scanner software.

2. Hardware automation is an underappreciated AI use case. Marco demonstrates how Warp can control his scanner through NAPS2, a CLI tool for scanners. This allows him to scan documents, flip pages, and combine PDFs without ever touching the scanner software.

3. File manipulation is a powerful AI capability. When Marco needed to compress a 1.7GB video file, he simply asked Warp to analyze why it was so large and re-encode it with FFmpeg. The AI identified the issue (excessive bitrate and resolution) and compressed it to 13MB while maintaining quality.

4. Ad hoc agents are changing how we approach automation. Marco defines these as “unnamed agents created on the fly to do something for me.” Rather than building complex, permanent workflows, these micro-agents handle specific tasks when needed and then disappear. This approach is becoming a trend across general-purpose AI tools, blurring the line between consuming and building agents.

5. CLI tools with AI create better interfaces than traditional GUIs. Marco points out that designing graphical interfaces for complex systems like Azure permissions is extremely difficult. AI with access to command-line tools can abstract away these design challenges.

Detailed workflow walkthroughs from this episode:

• How Microsoft’s AI VP Automates Everything with 5 Micro-Agent Workflows: https://www.chatprd.ai/how-i-ai/microsofts-ai-vp-automates-everything-with-5-micro-agent-workflows

• How to Create an Automated Meeting Scheduler with Microsoft 365 Copilot: https://www.chatprd.ai/how-i-ai/workflows/how-to-create-an-automated-meeting-scheduler-with-microsoft-365-copilot

• How to Scan and Merge Two-Sided Documents into a Single PDF with AI: https://www.chatprd.ai/how-i-ai/workflows/how-to-scan-and-merge-two-sided-documents-into-a-single-pdf-with-ai

• How to Automate Azure User Role Management with AI in the Terminal: https://www.chatprd.ai/how-i-ai/workflows/how-to-automate-azure-user-role-management-with-ai-in-the-terminal

If you’re enjoying these episodes, reply and let me know what you’d love to learn more about: AI workflows, hiring, growth, product strategy—anything.

Catch you next week,
Lenny

P.S. Want every new episode delivered the moment it drops? Hit “Follow” on your favorite podcast app.

Marco Casalaina, VP of Core AI Products and AI Futurist at Microsoft, demonstrates how he uses AI tools to automate administrative tasks that typically consume valuable time. Rather than using Warp as a coding assistant (its primary marketed purpose), Marco leverages it to manage Azure resources, scan documents, compress videos, and more. He shows how these “micro-agents” can reduce friction in everyday workflows, allowing him to focus on higher-value activities. Marco also demonstrates how Microsoft 365 Copilot and ChatGPT can create triggered workflows that respond to emails or check for information on a schedule, highlighting how the line between consuming and building AI agents is blurring.

What you’ll learn:

1. How to use Warp to manage Azure resources and assign permissions without navigating complex web interfaces

2. Techniques for automating document scanning and processing directly from the terminal

3. Methods for analyzing and compressing video files using AI-generated FFmpeg commands

4. How to create simple rules that dramatically improve AI performance for specialized tasks

5. Ways to build triggered workflows in Microsoft 365 Copilot that automatically respond to emails

6. How to configure ChatGPT to perform scheduled tasks like checking for new content

7. Strategies for creating consistent AI interactions using AutoHotkey shortcuts

Brought to you by:

Rovo—AI that knows your business

Lovable—Build apps by simply chatting with AI

In this episode, we cover:

(00:00) Introduction to Marco Casalaina

(02:14) Why Marco chose Warp for administrative tasks

(03:57) Demo: Using Warp to manage Azure resources and permissions

(06:00) How CLI tools eliminate GUI friction for complex tasks

(07:18) Creating rules to improve AI performance for specialized tasks

(10:28) Demo: Document scanning automation

(13:00) Combining odd and even pages using a Python automation

(15:04) The value of ephemeral AI solutions vs. permanent tools

(17:12) Video compression using FFmpeg commands

(20:22) The concept of “ad hoc agents” for specific tasks

(22:31) Demo: Creating triggered workflows in Microsoft 365 Copilot

(25:51) Demo: Setting up scheduled tasks in ChatGPT

(27:17) How AI automation changes time management

(29:14) Teaching AI skills to the next generation

(30:30) Strategies for improving AI performance with AutoHotkey

Tools referenced:

• Warp: https://www.warp.dev/

• Microsoft Azure: https://azure.microsoft.com/en-us

• Azure CLI: https://learn.microsoft.com/en-us/cli/azure/

• Microsoft 365 Copilot: https://www.microsoft.com/en-us/microsoft-365/copilot

• ChatGPT: https://chat.openai.com/

Other references:

• NAPS2: https://www.naps2.com/

• PyPDF2: https://pypdf2.readthedocs.io/

• FFmpeg: https://ffmpeg.org/

Where to find Marco Casalaina:

LinkedIn: https://www.linkedin.com/in/marcocasalaina/

Where to find Claire Vo:

ChatPRD: https://www.chatprd.ai/

Website: https://clairevo.com/

LinkedIn: https://www.linkedin.com/in/clairevo/

X: https://x.com/clairevo

Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email jordan@penname.co.

Jessica Fain is a product leader at Webflow and former Chief of Staff to the CPO at Slack, where she worked alongside April Underwood and many past podcast guests including Stewart Butterfield, Annie Pearl, Tamar Yehoshua, and Noah Weiss. She’s spent her career learning how executives actually make decisions—and why most people completely misunderstand the process.

We discuss:

1. Why great ideas often don’t get buy-in

2. Why executive calendars are “like strobe lights” and why the first 30 seconds of a meeting matter so much

3. Why executives are usually optimizing for a global maximum while you are often optimizing locally

4. The best question Jessica uses when a leader says something that seems wrong: “That’s so interesting. What led you to believe that?”

5. Why you should go in to learn, not to convince

6. Why showing only one option is a mistake

7. Why AI will make influence more important, not less

Brought to you by:

Omni—AI analytics your customers can trust

Lovable—Build apps by simply chatting with AI

Vanta—Automate compliance, manage risk, and accelerate trust with AI

Where to find Jessica Fain:

• LinkedIn: https://www.linkedin.com/in/jessica-fain-79b8989

Referenced:

• Box: https://www.box.com

• Slack: https://slack.com

• Brightwheel: https://mybrightwheel.com

• Webflow: https://webflow.com

• April Underwood on LinkedIn: https://www.linkedin.com/in/aprilunderwood

• Lessons in product leadership and AI strategy from Glean, Google, Amazon, and Slack | Tamar Yehoshua (Product at Glean, ex-Google and Slack): https://www.lennysnewsletter.com/p/you-dont-need-to-be-a-well-run-company-to-win-tamar-yehoshua

• Atlassian: https://www.atlassian.com

• Behind the scenes of Calendly’s rapid growth | Annie Pearl (CPO): https://www.lennysnewsletter.com/p/behind-the-scenes-of-calendlys-rapid

• Calendly: https://calendly.com

• Glassdoor: https://www.glassdoor.co.in/index.htm

• The 10 traits of great PMs, how AI will impact your product, and Slack’s product development process | Noah Weiss (Slack, Foursquare, Google): https://www.lennysnewsletter.com/p/the-10-traits-of-great-pms-how-ai

• Ethan Eismann on X: https://x.com/eeismann

• Slack founder: Mental models for building products people love ft. Stewart Butterfield: https://www.lennysnewsletter.com/p/slack-founder-stewart-butterfield

• Ilan Frank on LinkedIn: https://www.linkedin.com/in/ilanfrank

• Checkr: https://checkr.com

• Ali Rayl on LinkedIn: https://www.linkedin.com/in/alirayl

• Rachel Wolan on LinkedIn: https://www.linkedin.com/in/rachelwolan

• How Webflow’s CPO built an AI chief of staff to manage her calendar, prep for meetings, and drive AI adoption | Rachel Wolan: https://www.lennysnewsletter.com/p/how-webflows-cpo-built-an-ai-chief

• Barbara Minto’s website: https://www.barbaraminto.com

• How Slack invests in big little details through Customer Love Sprints: https://slack.design/articles/sweating-the-small-stuff

• Building product at Stripe: craft, metrics, and customer obsession | Jeff Weinstein (Product lead): https://www.lennysnewsletter.com/p/building-product-at-stripe-jeff-weinstein

• The Enneagram Institute: https://www.enneagraminstitute.com/type-descriptions

• The Pitt on Prime Video: https://www.amazon.com/The-Pitt-Season-1/dp/B0DNRR8QWD

• Towel warmer: https://www.amazon.com/FLYHIT-Large-Towel-Warmer-Bathroom/dp/B0CB5K34L2

• Casa: https://getcasa.com

• Jimi Hendrix: https://en.wikipedia.org/wiki/Jimi_Hendrix

• Greek Theatre: https://en.wikipedia.org/wiki/Greek_Theatre_(Los_Angeles)

Recommended books:

• Pachinko: https://www.amazon.com/Pachinko-National-Book-Award-Finalist/dp/1455563927

• Homegoing: https://www.amazon.com/Homegoing-Yaa-Gyasi/dp/1101971061

• A History of Burning: https://www.amazon.com/History-Burning-Janika-Oza/dp/1538724243

• The Overstory: https://www.amazon.com/Overstory-Novel-Richard-Powers/dp/039335668X

Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email podcast@lennyrachitsky.com.

Lenny may be an investor in the companies discussed.

My biggest takeaways from this conversation:

Read more

Read more

When I released my full podcast transcript archive, Ben Shih, a non-technical designer at Miro, built LennyRPG: a Pokémon-style RPG where you battle podcast guests with product trivia. In this episode, Ben walks through the exact six-step workflow he used to go from sketch to shipped game, including the tools, prompts, and decisions at every stage, along with the broader lessons he learnt along the way.

In this episode, you’ll learn:

• How to have AI interview you instead of writing the PRD yourself

• When to pivot your framework, rather than force the wrong tool

• How to systematically process 300+ transcripts into game data

• Three core lessons Ben learned from building LennyRPG

References

• Ben Shih

• Brian Balfour

• Claude Code Awesome Skills marketplace

• LennysData.com

• LennyRPG

• Lenny’s Product Pass

• OpenGameArt.org

• Phaser 3

• RPG-JS

• Supabase

• Wispr Flow

Read the post

Read more

Subscribe now

P.S. Get a full free year of Lovable, Manus, Replit, Gamma, n8n, Canva, ElevenLabs, Amp, Factory, Devin, Bolt, Wispr Flow, Linear, PostHog, Framer, Railway, Granola, Warp, Perplexity, Magic Patterns, Mobbin, ChatPRD, and Stripe Atlas by becoming an Insider subscriber. Yes, this is for real.

A few months ago, I shared all of my podcast transcripts on socials on a whim, and holy sh*t, y’all found such incredibly creative ways to use this data: parenting wisdom rooted in PM advice, user research scripts, antimemes, an infographic for every episode, a “Learn from Lenny” Twitter bot, and at least 50 other amazing projects.

But my favorite project of all was by Ben Shih, a non-technical product designer at Miro, who created LennyRPG. I asked Ben to share the step-by-step journey behind this wildly fun, video-game-inspired project—how he built it and what he learned.

To let a thousand more flowers bloom, today I’m releasing my entire newsletter archive (and my podcast transcripts) in AI-friendly Markdown files. Also, an MCP server and a handy GitHub repo. Paid subscribers get all of the data (some 350 posts and 300 transcripts); free subscribers can access a subset. Grab the data here: LennysData.com.

I don’t think anyone’s ever done anything like this before, and I’m excited to give you this excuse to start playing with the latest and greatest AI tools.

Here’s my challenge to you: build something, and let me know about it. I’ll pick my favorite and give you a free 1-year subscription to the newsletter. Just post a link to your project in the comments below. If you’ve already built something, slurp in this new data and submit it, too. I’ll pick a winner on April 15th. Here’s the data. Let’s go.

Ben is a designer and product builder who enjoys creating small, fun, and thoughtful products that make the world a little better. He’s currently a growth designer at Miro. You can explore more of his work on his website or LinkedIn.

Also, a big thank-you to Tal Raviv, Claire Vo, and Este Lopez for helping me beta-test and improve LennysData.com (which I proudly “agentically engineered” with Codex and Claude Code 👌).

A couple months back, Lenny dropped something special. He made transcripts from all his more than 300 podcast episodes structured and publicly available. As someone who’s listened to the podcast for years, I couldn’t stop thinking about what I could actually build with this.

Brian Balfour talks a lot about building at the right moment: if you get the timing right, you’ll find a real window of opportunity. This felt like one of those windows.

The first idea that popped into my mind was to make a Lenny interview app where you can practice job interviews with Lenny’s Podcast guests. However, the more I thought about that idea, the less excited I felt. Interview practice tools by nature feel stressful, and that’s the last type of product I wanted to create. I wanted to make something fun.

What if I turned Lenny’s Podcast into a small role-playing game (RPG)? A game where you explore a pixel world, meet guests from Lenny’s Podcast, compete with them to test your product knowledge, and even capture them like Pokémon when you win. That’s how LennyRPG was born.

Here’s how I built it

When I build apps with AI, I usually follow a very simple flow:

1. Define the core idea: I start by clarifying what the app is. For visually heavy products, I sketch it out so the AI can better understand the requirements.

2. Create a product requirement document (PRD): I turn the core idea into a proper PRD with the AI. This becomes the single source of truth for the build.

3. Create a proof of concept: I use the PRD to plan implementation and build the core functionalities first.

4. Add remaining features: I finish the end-to-end flow, such as connecting the database and building out settings, profile pages, and other non-core features.

5. Polish: I go through the app end-to-end, fix UX/UI details, and do final code reviews to make sure everything is stable.

6. Ship it: I deploy, get feedback, and get it out into the world.

The process isn’t that different from before the AI era. But now I really make sure that I spend enough time on the first two steps to ensure that the AI gets all the context of what I want. In my experience, nailing the core idea and PRD determines 80% of how smooth the rest of the build will be.

Here are the main tools and technologies I used throughout the build:

• Ideation and planning: Miro, ChatGPT

• Coding: Claude Code, Codex, Cursor

• Image generation: GPT Image Gen (gpt-image-1.5)

• Quiz generation: GPT-4o

• Game engine: Phaser 3

• Database: Supabase

• Deployment: Vercel

Now let’s walk through how I used this process to build my RPG game. I’ll share the exact prompts, tools, and decisions at each step so you can apply the same workflow to your own projects.

1. Define the core idea

The core idea was simple: turn Lenny’s Podcast into a Pokémon-style RPG where players encounter podcast guests in the wild and battle them through product questions.

For many apps, text and a clear idea are enough to get started with. But for highly visual products like this game, spending some time on visualization can help you get a solid sense of how you want the game to look and feel. That makes a big difference later on when you ask the AI to build the UI and interactions.

For this game, I dropped a few Pokémon screenshots into a Miro board and put together a rough concept directly on the board. Nothing fancy, mostly text and boxes on top of screenshots. But it was enough to show how I imagined the map, the battle screen, and how the characters might look.

The goal was not to design the game exactly but to give the AI something concrete to read and reason about. Once the core idea was roughly visualized, the AI could read the visuals alongside the text, which led to a much stronger PRD in the next step.

Creating a sample set of avatars

As part of the visualization, I also created a few test avatars with ChatGPT to validate the content generation workflow. This helped me understand the prompt engineering needed for consistent pixel art style avatars.

The process was very simple. I dragged in images of the RPG characters I wanted the style to match, then added Lenny’s photo into ChatGPT to create a similar one.

Once I was happy with it, I asked ChatGPT to describe the tone, style, and design in detail so that I could reuse that as a prompt later.

Prompt I used:

Study and think through the styling, design, colors, proportions, and overall look in detail, then return only a polished image-generation prompt that will create a similar front-facing character based on the provided person’s photo, with a transparent background and no additional elements.

2. Create a PRD (in a lazy way)

In my experience, the PRD is the most important document if you want the AI to execute your vision correctly. As a PRD does well with human teammates, it gives the AI the base understanding of your app’s goal, problem statement, and core idea. Whenever the AI hits a wall or the context window runs out, you can refer it back to the PRD to realign. No matter what stage you’re at, the PRD makes sure everything the AI generates stays true to what you’re actually trying to build. That’s why I always invest time here.

That said, writing PRDs can sometimes drive you crazy. So instead of writing the PRD myself from scratch, I let the AI interview me. I pasted my core idea along with the visuals into ChatGPT and then asked it to ask me questions so that I could answer them one by one.

Prompt I used:

Ask me questions to help you put together a brief PRD for the following web game: I want to create a mini game that takes all the podcast episodes from Lenny’s Podcast, generates questions from each episode, and make it like a Pokémon RPG game, with similar visuals. What I am expecting is, for example, you found Elena in the wild, and you can compete with Elena on product questions, you get 5 questions, and you lose HP [hit points] when you lose the answer etc. We can randomly pick 50 guests from the podcast and get challenged. The entire theme/design of the game needs to be very Pokémon RPG style in the old day.

With the prompt, ChatGPT came back with 17 questions. I moved them into Miro to visualize them better and used Wispr Flow to quickly dictate my answers verbally.

Answering these questions also forced me to think through gaps and assumptions in my idea, while giving the AI much better context than a one-page description ever could.

Once I answered all of the questions the AI had for me, I chained the answers together with all the available artifacts in Miro and asked the AI to generate a comprehensive PRD.

3. Create a proof of concept

With the PRD in place, I moved it over to Cursor as a Markdown file so I could start working on the POC.

For the actual development, my setup uses three tools: Claude Code, Codex, and Cursor’s Composer.

I treat Claude Code as my lead engineer. It helps draft the implementation plan, think through architecture, and reason about product and design constraints. I’ve also found it to be great at searching for solutions and open source libraries. Codex is mainly for executing tasks from the implementation plan. It’s very good at following instructions accurately, and comes with a more generous token limit. Composer is mostly for smaller tasks like formatting documents, JSON files, or writing simple scripts.

Using the PRD as input, I first asked Claude Code to search for any open source projects that could help me move faster. This is something I always do early on. Very often, people have already built something similar and made it open source on GitHub, which can help you set things up much faster.

One of the first libraries I landed on was RPG-JS. Thanks to the library, it took me around five minutes to get something running. I was able to quickly build out the essential game flow. The overworld map handled basic player movement, encounter zones, and simple UI elements.

But very quickly, I started hitting challenges.

Challenge #1: Hitting the limits of RPG-JS and pivoting

After a few iterations, it became clear that RPG-JS was not the right foundation. The framework is heavily designed around inventory systems and weapon-based combat. That worked against me, since my battles were quiz-based and logic-driven. The more I tried to bend it, the harder it became for the AI to reason about the system cleanly.

After talking it through with Claude Code, I decided to stop forcing it and pivot. The new framework that I decided to use is Phaser, a 2D game framework used for making HTML5 games for desktop and mobile.

Challenge #2: Getting the map running in Phaser

After switching to Phaser, things became much more flexible in terms of scenes, maps, and game logic. However, because everything is more customizable, even setting up a basic map took a lot more work.

Fortunately, using Claude Code, I found a Medium article from a while ago that included an open source, reusable map template. That helped me speed things up significantly and get back to focusing on the game itself.

Challenge #3: Polishing the details in Phaser

Phaser is a powerful but complex library with a lot of different features. Claude Code took some time to actually understand how it works, and I had to go through many iterations to get the details right. Things like importing the right fonts, making sure UI elements were positioned correctly, and editing everything within Phaser’s open canvas all required a lot of back and forth.

One tip for complicated tasks like this is to ask Claude Code to create a simple Markdown file to log everything it tries, so it can keep referring back and updating what works and what doesn’t.

This helps a lot for Claude Code and AI in general to understand the codebase and framework better. It’s especially useful as your codebase grows larger, where even small things like font changes can become difficult for an AI to handle.

After working through all these challenges, the game finally reached a playable state. The starting screen, map, and battle screen were all working end-to-end.

Once the POC was ready, I shared it internally in the office to get a few people to try it out. At this stage, I wasn’t looking for polished feedback or detailed bug reports. I mostly wanted to see how people reacted when they opened the game for the first time. Did they immediately understand what to do? Did the core loop make sense? Most importantly—did it feel fun, or did it feel like work?

This kind of lightweight, informal testing gave me confidence that the core idea worked, and that it was worth investing more time to turn the POC into something more complete.

4. Add remaining features

Once I got the app running correctly with the basics and got great feedback from folks in the office, I started following the plan to scale my POC into a proper game.

But the process was less straightforward than expected, mainly because there were a lot of podcast episodes to process. Scaling from a working POC to a full game turned out to be mostly about figuring out how to handle things systematically instead of manually.

Here are the main tools and decisions that helped me get there:

Processing 300+ transcripts systematically

The transcript file provided by Lenny contained only raw text. To make it usable in the game, I first had to enrich the data with things like episode title, episode URL, and podcast cover.

To do this, I pulled in the podcast RSS feed with Cursor’s Composer and used it to attach the missing metadata to each transcript. This gave me a much more complete dataset that the game could actually use.

Then, using Claude Code, I asked it to create a simple CLI tool that could systematically generate quiz questions for each episode using the OpenAI API. Instead of doing this episode by episode, the tool processed everything in one go.

This step was as simple as typing in a prompt: “Create a CLI command tool that creates a simple way to read through all the transcripts in /transcript folder one by one, and for each, generate 5 questions following the requirements and JSON format: {Your requirements and JSON format}”

It took around 20 minutes to finish, and the output was a structured JSON file that I could plug directly into the game.

The potential nightmare of creating 250+ RPG avatars

One of the hardest parts of building the game was creating over 250 RPG avatars in a consistent way. Each avatar needed a photo of the guest as input. Doing this manually by searching and downloading guest photos one by one would have taken forever.

Fortunately, every Lenny’s episode already includes an episode cover that contains the guest’s avatar. For this, I triggered Cursor’s Composer to pull RSS feed again to pull the image URLs, downloaded them locally, and used those as inputs for avatar generation.

That solved the sourcing problem but introduced another one: How do I make sure every avatar looks consistent in quality and style?

This is where I used OpenAI Playground to repeatedly test and refine my prompt, as well as testing which models work the best for the task. I kept adjusting it until every generated avatar followed the same style and looked like it belonged to the same game.

Once the prompt was stable, I used Claude Code again to write another CLI tool that could systematically generate all the RPG avatars from the episode covers. That turned a very painful manual task into a one-click process.

And of course, for each output, I had to check one by one to make sure the sizes and styling were similar and matched how the guests looked in the podcast cover. This was one of the most interesting steps because there were a few fun edge cases. For example, I didn’t know Adam Grenier really has rabbit ears on top of his profile image in the original podcast cover—I almost deleted them. Or there are episodes with two people in the cover image, like Jake Knapp and John Zeratsky’s episode, so I had to tell AI to generate a single separate image for each person.

Claude Code’s magic with background music

Audio is a huge part of any game. Many successful gamified apps, like Duolingo, invest a lot of effort in sound design because it makes everything feel more alive.

At the same time, searching for the right background music and wiring it into the game usually takes a lot of time. So I went to Claude Code and simply said: “Search for me background music for each phase, with mute control.”

To my surprise, it was able to find OpenGameArt.org, an open source audio library for games, and wire it into the game correctly. When I wrote the prompt, I actually just wanted to add background music for when players are on the map, but it automatically added music for battle screens, victory screens, and defeat screens as well. I still had to adjust the timing and volume, but most of the heavy lifting was done automatically. That part genuinely felt like magic.

Defining the gaming mechanics

Defining the gaming mechanics was the most interesting part of the process, as I wanted the game to be fun and low-stress but still competitive enough that people felt progression and stakes. I’ve studied game theory in the past, but for this project, most of it came down to common sense, play testing, and iteration.

I started with a very simple rule set: Each opponent has three questions. Every correct answer gives XP (experience points). If you answer all three correctly, that counts as a perfect kill.

To keep things interesting, I added small variations. Occasionally, one of the three questions becomes a bonus question, which gives extra XP and a small HP boost. This introduces a bit of randomness without breaking balance.

Stage progression is based on XP thresholds. Once you reach the required XP, a new map unlocks with a new batch of guests. Defeated opponents disappear and get added to your collection, so you can’t farm the same ones repeatedly.

I worked through most of this logic on my own first and then verified with the AI to make sure there were no obvious bugs or edge cases. The AI sanity-checked numbers and flows, but the final calls on balance, pacing, and stress level were all manual.

Connecting Supabase using MCP (leaderboard)

The last step of the game is the leaderboard. It is the competition aspect of the game, where people can see their ranking and compete with each other.

I knew I had to set up a database for this, so I started by setting up Supabase MCP in Claude Code. That means instead of manually setting up tables, APIs, and connections, all I had to do was describe to Claude Code that I wanted a leaderboard synced with Supabase.

Once I did that, it triggered Supabase MCP, which called tools like create_project and apply_migration to set up the project and tables automatically, including the database structure and the connection between the game and Supabase. This made the whole process much faster and removed a lot of setup work that would normally take much longer.

The result was a working leaderboard that synced player progress in real time, without my having to touch much backend code at all.

5. Polish

Before shipping, I focused on final polish to make sure the app was stable, usable, and presentable enough for public launch. At this stage, the core gameplay was already working, so the goal was not to add new features but to reduce friction and obvious issues.

QA check with Claude Skills

For this step, I downloaded the review skill from the Claude Code Awesome Skills marketplace and used it to review the entire codebase comprehensively.

This was especially helpful for catching things I would normally miss, such as state issues between scenes, missing error handling, and small logic bugs that only show up after multiple rounds of gameplay. I did not blindly accept everything it suggested, but it gave me a solid checklist to go through before shipping.

UI polish

I went through the game end-to-end and logged all UI and UX inconsistencies in a Markdown file—things like spacing issues, text overflow, unclear labels, alignment problems, and visual hierarchy issues.

Once everything was written down, I let AI pick up the list one by one and fix them. This worked surprisingly well, especially when the issues were clearly described. It also made the process much more systematic compared with fixing things ad hoc while clicking around the app.

SEO

For SEO, I used Claude Code to help figure out the basics: page title, meta description, social preview, and basic indexing setup.

Since this was a game and not a content-heavy site, I did not go deep into SEO optimization. The main goal was to make sure the site was indexable, shareable, and looked good when people posted it on social media.

6. Ship it

Once the game was deployed smoothly on Vercel, I reached out to Lenny in the community Slack to get a quick sanity check. I honestly wasn’t even expecting a direct reply given how busy he is—but to my surprise, I got a very kind and encouraging response from him.

That was the nudge I needed to just ship it.

Read more

From Figma to Claude Code and back

Brought to you by Optimizely—Your AI agent orchestration platform for marketing and digital teams

Gui Seiz (designer) and Alex Kern (engineer) from Figma show how to pull a live interface from production, staging, or localhost into Figma, turn it into editable design frames, explore variations collaboratively, and push changes back into code using Claude Code and MCPs—creating a continuous design ↔ code loop.

Biggest takeaways:

1. The design handoff is dead—replaced by continuous sync. Instead of designers creating comprehensive design packages with every state documented, AI enables bidirectional flow between Figma and code. Pull production code into Figma to see what actually exists, make changes in Figma, then push those changes directly back to code. No more version-final-final-v3.

2. Direct manipulation still beats prompting for precision. While AI can generate designs from prompts, dragging elements around in Figma remains the gold standard for fine-tuning. As Gui notes, “No one wants to prompt for the exact hex code or shade of yellow”—it’s just easier to use the color picker and eyeball it.

3. Use Figma’s MCP to keep design files current with production. The biggest problem in design-code workflows is drift—production gets ahead of Figma, or Figma contains dreams that never shipped. With MCP, you can programmatically pull any production state into Figma, ensuring that designers always work from what actually exists.

4. Turn your engineering wiki into executable skills. Every team has that onboarding page: “This is what you do before pushing a PR.” Alex built a /ship skill that automatically runs pre-flight checks, pushes to Git, monitors CI, and even fixes minor lint issues—up to five times with a one-hour timeout. Take every SOP and make it a skill.

5. Structure your codebase for AI assistance. Alex spends 20% to 30% of his time optimizing code structure so AI can accomplish more with less. This isn’t about writing better code for humans; it’s about making your codebase more legible to AI agents so each prompt delivers better results.

Detailed workflow walkthroughs from this episode:

1. How Figma’s Team Syncs Design and Code with Claude Code and Codex: https://www.chatprd.ai/how-i-ai/how-figma-team-syncs-design-and-code-with-claude-code-and-codex

2. Automate Your Pre-Merge PR Checklist with a Custom AI `/ship` Skill: https://www.chatprd.ai/how-i-ai/workflows/automate-your-pre-merge-pr-checklist-with-a-custom-ai-ship-skill

3. Automate Design Documentation by Exporting All Component States from Code to Figma: https://www.chatprd.ai/how-i-ai/workflows/automate-design-documentation-by-exporting-all-component-states-from-code-to-figma

4. Create a Bidirectional Sync Between Production Code and Figma Designs with AI: https://www.chatprd.ai/how-i-ai/workflows/create-a-bidirectional-sync-between-production-code-and-figma-designs-with-ai

From journalist to iOS developer: How LinkedIn’s editor builds with Claude Code

Brought to you by:

• WorkOS—Make your app enterprise-ready today

• Vanta—Automate compliance and simplify security

Daniel Roth (Editor in Chief and VP of Content Development at LinkedIn) shares how he builds and ships iOS apps to the App Store without writing code. He walks through the workflow he uses with Claude Code—including a dual-agent system where one AI writes code and another reviews it—along with how he plans features, manages development with branches, and turns ideas into working apps.

Biggest takeaways:

1. Create dueling AI agents to build better code. Daniel uses “Bob the Builder” to generate code and “Ray the Reviewer” to critique it for security and architecture issues. This two-agent system creates checks and balances similar to how engineering teams work, with Bob focusing on implementation and Ray ensuring quality. The friction between copying plans between agents also helps Daniel learn more about the code being generated.

2. Use AI to prevent dropping the ball at work. Daniel’s most valuable AI workflow isn’t for coding—it’s for managing his responsibilities as a leader of 400 people. He ends each day by asking Copilot, “What did I drop the ball on?” The AI scans his emails, Teams messages, and documents to identify unanswered messages and pending tasks. This 30-minute evening routine helps him wrap up loose ends before leaving work.

3. Build personalized apps that solve your own problems first. Daniel created “Commutely” to solve his specific problem of knowing whether to run for the New York subway. As he explains, “It was a perfect product-market fit because I was the entire product.”

4. Keep a running feature tracker with AI-powered prioritization. Daniel maintains a Claude chat that tracks all feature ideas with estimated build time and potential impact. His prompt instructs Claude to “keep track of ideas and offer guidance: time estimate to build, estimated back-and-forth hours, potential impact score on 1–3 scales for customer happiness and growth impact.” This creates a prioritized backlog he can pull from whenever he has time to build.

5. Document everything in Markdown files. Daniel saves all AI conversations as Markdown files, explaining, “Every time I’m working with Claude, I’m saying, ‘Write it into a file. Log everything.’” This solves two problems: Claude’s limited context window and his own memory limitations when returning to projects after breaks. This documentation habit creates a knowledge repository he can reference later.

Detailed workflow walkthroughs from this episode:

1. How I AI: Daniel Roth’s Dueling Agent Workflow for Building iOS Apps: https://www.chatprd.ai/how-i-ai/daniel-roth-dueling-agent-workflow-for-building-ios-apps

2. Build iOS Apps with a Dueling AI Agent Workflow: https://www.chatprd.ai/how-i-ai/workflows/build-ios-apps-with-a-dueling-ai-agent-workflow

3. How to Use Claude for AI-Powered Feature Prioritization: https://www.chatprd.ai/how-i-ai/workflows/how-to-use-claude-for-ai-powered-feature-prioritization

4. How to Use a Simple Copilot Prompt to Never Drop the Ball Again: https://www.chatprd.ai/how-i-ai/workflows/how-to-use-a-simple-copilot-prompt-to-never-drop-the-ball-again

If you’re enjoying these episodes, reply and let me know what you’d love to learn more about: AI workflows, hiring, growth, product strategy—anything.

Catch you next week,
Lenny

P.S. Want every new episode delivered the moment it drops? Hit “Follow” on your favorite podcast app.

Daniel Roth, editor in chief at LinkedIn, went from business writer to iOS app developer, without ever learning how to code. Using Claude Code, Daniel built and shipped multiple production-ready iOS apps to the App Store, including Commutely, a personalized train-tracking app for New York commuters.

What you’ll learn:

1. How to set up a dual-agent Claude Code system (builder + reviewer)

2. Why being a “picky customer” is the right mindset for non-technical builders

3. How Daniel prioritizes features using AI-ranked impact vs. build time

4. Why saving everything as Markdown files creates long-term context

5. The importance of branch-based development—even when AI writes the code

6. How Daniel ships to the App Store without formal engineering experience

7. His end-of-day “What did I drop the ball on?” Copilot workflow

Brought to you by:

WorkOS—Make your app enterprise-ready today

Vanta—Automate compliance and simplify security

In this episode, we cover:

(00:00) Introduction to Daniel Roth

(02:46) Daniel’s AI development workflow overview

(05:56) Using Claude to prioritize feature ideas

(08:58) Building vs. marketing

(09:47) Creating a retention plan for his app

(10:38) Introducing Bob the Builder and Ray the Reviewer

(13:50) How Bob and Ray work together to build features

(14:37) Why Daniel focuses on learning the process

(16:34) The importance of using branches for development

(17:39) Managing AI agents like managing a team

(21:12) Navigating the App Store

(23:06) Being a “picky customer” rather than a PM

(25:00) Testing in Xcode and shipping to the App Store

(28:14) Quick recap

(30:00) Creating terminal aliases with Claude

(31:38) Demo of his Commutely app

(32:10) Using Copilot to manage work responsibilities

(35:05) How Daniel talks to AI without personifying it

Tools referenced:

• Claude: https://claude.ai/

• Claude Code: https://claude.ai/code

• Cursor: https://cursor.sh/

• Xcode: https://developer.apple.com/xcode/

• Canva: https://www.canva.com/

• Microsoft Copilot: https://copilot.microsoft.com/

• Terminal: https://support.apple.com/guide/terminal/welcome/mac

• Obsidian: https://obsidian.md/

Other reference:

• Commutely (iOS app): https://apps.apple.com/us/app/commutely/id6755789873

Where to find Daniel Roth:

LinkedIn: https://www.linkedin.com/in/danielroth1/

Newsletter: https://www.linkedin.com/newsletters/forward-deployed-editor-7378272989982683137/

Where to find Claire Vo:

ChatPRD: https://www.chatprd.ai/

Website: https://clairevo.com/

LinkedIn: https://www.linkedin.com/in/clairevo/

X: https://x.com/clairevo

Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email jordan@penname.co.

Jacob Warwick is an executive negotiation coach who helps senior operators negotiate better salary, equity, titles, and severance packages. He has worked with leaders across tech and Hollywood, was previously a founder and CEO himself, and has helped clients secure millions in additional compensation. His approach focuses on collaboration over confrontation, understanding motivations, and treating job searches like enterprise sales processes.

We discuss:

1. Why a simple “What’s the chance there’s a little more here?” often unlocks a 20% bump

2. Why Jacob sees 40% average movement when negotiations are run well

3. When negotiation actually starts (hint: it’s much earlier than you think)

4. Why information + timing create power

5. The biggest mistakes people make when negotiating

6. How to navigate the important “What’s your comp expectation?” question without anchoring too low

7. Why the best interviews feel more like discovery calls than interrogations

Brought to you by:

Orkes—The enterprise platform for reliable applications and agentic workflows

Mercury—Radically different banking

Omni—AI analytics your customers can trust

Where to find Jacob Warwick:

• Substack: https://www.execsandthecity.com

• YouTube: https://www.youtube.com/@ExecsandtheCity

• Website: https://www.thinkwarwick.com

• Complete Job Search Course: https://www.execsandthecity.com/p/complete-job-search-course

Referenced:

• The ultimate guide to negotiating your comp: https://www.lennysnewsletter.com/p/the-ultimate-guide-to-negotiating

• Sam Altman on X: https://x.com/sama

• Tom Brady on X: https://x.com/TomBrady

• Career Huddle: Interview & Negotiation Master Class with Jacob Warwick: https://www.youtube.com/watch?v=TgjWTiSj8E8

• Salesforce: https://www.salesforce.com

• Julia Roberts: https://en.wikipedia.org/wiki/Julia_Roberts

• Matt Damon: https://en.wikipedia.org/wiki/Matt_Damon

• Steven Spielberg: https://en.wikipedia.org/wiki/Steven_Spielberg

• Marc Andreessen: The real AI boom hasn’t even started yet: https://www.lennysnewsletter.com/p/marc-andreessen-the-real-ai-boom

• Chris Voss’s quote: https://www.goodreads.com/quotes/10181396-remember-never-be-so-sure-of-what-you-want-that

• Chris Voss on X: https://x.com/fbinegotiator

• Werewolf: https://playwerewolf.co

• Modes of persuasion: https://en.wikipedia.org/wiki/Modes_of_persuasion

• How to use tactical empathy: https://www.linkedin.com/posts/christophervoss_tacticalempathy-negotiation-customerexperience-activity-7361004118808670212-oeRy

• ZOPA, BATNA and Win-Win in Negotiation: https://www.parallelprojecttraining.com/blog/zopa-batna-and-win-win-in-negotiation

• Marvel: https://www.marvel.com

• Negotiation Made Simple podcast: https://www.buzzsprout.com/2227030

• Luca on Disney+: https://www.disneyplus.com/browse/entity-f28b825f-c207-406b-923a-67f85e6d90e0

• Minuscule: https://www.youtube.com/user/Minuscule

• Claude Cowork: https://claude.com/product/cowork

• Macrofactor: https://macrofactor.com

• Whoop: https://www.whoop.com

• Gemini: https://gemini.google.com/app

• The Cody Dieruf Foundation: https://breathinisbelievin.org

• Cystic Fibrosis Foundation: https://www.cff.org

Recommended books:

• Negotiation Games: https://www.amazon.com/Negotiation-Games-Routledge-Advances-Theory/dp/0415308941

• Influence: The Psychology of Persuasion: https://www.amazon.com/Influence-Psychology-Persuasion-Robert-Cialdini/dp/006124189X

• You Can Negotiate Anything: How to Get What You Want: https://www.amazon.com/You-Negotiate-Anything-Herb-Cohen/dp/0806541229

• Negotiation Made Simple: A Practical Guide for Solving Problems, Building Relationships, and Delivering the Deal: https://www.amazon.com/Negotiation-Made-Simple-Relationships-Delivering/dp/1400336325

• Radical Candor: Be a Kick-Ass Boss Without Losing Your Humanity: https://www.amazon.com/Radical-Candor-Kick-Ass-Without-Humanity/dp/1250103509

• High Output Management: https://www.amazon.com/High-Output-Management-Andrew-Grove/dp/0679762884

• How to Win Friends and Influence People: https://www.amazon.com/How-Win-Friends-Influence-People/dp/0671027034

Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email podcast@lennyrachitsky.com.

Lenny may be an investor in the companies discussed.

My biggest takeaways from this conversation:

Read more

Read more