I have personal-agent fatigue, so I ran the first How I AI personal-agent benchmark: Grok Bot, Dot, Muse, and Claude Duet across nine real tasks, from a Slack reply and a Sentry bug to a Figma thumbnail, inbox triage, a family newspaper, physics homework for a fourth grader, shoe shopping, and a ChatPRD launch video. I used computer use to operate them: Claude ran Dot, Codex ran the rest and scored the results live. Here’s the scoreboard—and which agent I’d actually trust for work vs. life.

Brought to you by:

WorkOS—Make your app enterprise-ready, with SSO, SCIM, RBAC, and more

Firecrawl—Give your AI agents web data and beyond

In this episode, we cover:

(00:00) Introduction

(02:13) The personal-agent benchmark setup

(05:00) The nine tasks and the prompts I used

(07:20) Scoreboard overview

(10:06) Task 1: Draft a Slack reply as me

(11:39) Task 2: Cut a short-form video from raw Dropbox footage

(14:56) Task 3: Fix a bug from Sentry

(17:30) Task 4: Build a How I AI thumbnail in Figma

(19:25) Task 5: Triage my inbox for to-dos

(21:06) Task 6: Build a family newspaper

(23:30) Task 7: Explain a physics homework question to a fourth grader

(24:54) Task 8: Shop for shoes

(26:46) Task 9: Make a ChatPRD Product Intelligence launch video

(30:01) Final scores

(32:38) My takeaways

Tools referenced:

• Grok Bot: https://x.ai/bot

• Dot: https://chatgpt.com/features/dots/

• Meta Muse: https://ai.meta.com/muse/

• Claude Duet: https://claude.com/product/claude-duet

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

• ElevenLabs: https://elevenlabs.io/

• Figma: https://www.figma.com/

• Sentry: https://sentry.io/

• Linear: https://linear.app/

• Dropbox: https://www.dropbox.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.

Why Reddit built its own AI prototyping tool | Blair Metcalf

Brought to you by:

• Firecrawl—Give your AI agents web data and beyond

Blair Metcalf is the principal UX engineer at Reddit and the creator of Reddit Proto, an internal platform that helps designers and product managers build production-like prototypes without touching GitHub. In this episode, he shows how the system combines real Reddit data, reusable scaffolds, Cursor annotations, and a custom design system MCP to turn ideas into shareable prototypes. He also explains how Reddit’s teams have built about 700 prototypes, reached 100% adoption across UX and product, and developed a Figma-to-PRD workflow that makes engineering handoffs far more precise.

Biggest takeaways:

1. The best prototyping tools hide complexity without limiting capability. Reddit’s desktop app handles repositories, branches, and scaffolding behind the scenes, so designers never touch Git. What remains is a simple path from idea to production-shaped prototype.

2. Mock data makes prototypes less convincing. Reddit lets people sign in to prototypes with their real accounts, filling feeds, searches, and communities with familiar content. Leadership can evaluate the actual experience instead of mentally correcting for placeholders.

3. Annotations become powerful when they include code context. Reddit’s harness attaches each comment to the relevant component, design-system guidance, and the user’s intent before sending it to Cursor. That context turns a short annotation into a accurate working edit instead of a guess.

4. A custom design-system MCP is what turns AI into a reliable builder. Blair’s team mapped Reddit’s tokens, components, and workflows directly to production code. Cursor therefore knows which component to use, how it should look, and where the code belongs.

5. The feature capsule makes design handoffs traceable instead of lossy. A designer submits a Figma link, and the system maps each element to production components, incorporates previous engineering feedback, and generates a structured PRD with acceptance criteria. The result is a handoff with far less room for interpretation.

6. The best AI prototypers are not necessarily the most technical. Reddit’s standout users include a visual designer and an animator with no engineering background. Their advantage is strong product context, a clear vision, and a willingness to experiment without worrying about breaking things.

7. At 700 prototypes, discovery becomes as important as creation. Reddit is building a searchable console with tags, team filters, and platform filters so employees can find related experiments. Keeping prototypes public internally creates visibility that scattered Figma folders never could.

8. Real components and real data create instant alignment. When leaders can open a shareable prototype built with Reddit’s design system and their own account data, implementation questions stop dominating the review. The biggest speed gain comes from removing the uncertainty that once delayed decisions.

Claude Duet is beautiful. I still forgot to use it.

In this solo episode, Claire tests Claude Duet, Anthropic’s beautifully designed new personal agent, to see whether it deserves a place in her increasingly crowded AI stack. She puts it to work on inbox and Slack triage, her sales pipeline, a Google Docs deck, a launch video, and finding Warriors tickets for her kids. She also explains why Duet’s thoughtful task lists, artifacts, and channels are not enough to overcome its slow responses, quiet notifications, and lack of desktop and team support.

Biggest takeaways:

1. Claude Duet is the most polished personal agent launch yet. From onboarding onward, it clearly explains what it can do, what it can access, and how to begin. Claire found even the early TestFlight builds trustworthy and roughly a hundred times more polished than OpenAI’s Dots at launch.

2. Duet is built around thoughtful agent primitives. It inherits Claude plugins and connectors, tracks what the user and the agent are each working on, and brings existing artifacts into the experience. Slack-like channels also keep focused work, such as sales, separate from the main conversation.

3. Duet is designed for the middle of the market. Anthropic is targeting entrepreneurs, small-business owners, PMs, and executives, rather than casual consumers or power users managing dozens of agents. It feels like a proactive, mobile companion to Cowork.

4. A proactive agent has to give people a reason to return. After onboarding and a few tasks, Duet stopped nudging Claire. Its quiet notifications are elegant, but a short morning briefing is not enough to keep an easily forgotten agent in someone’s daily routine.

5. Latency is a product problem, not merely a model problem. Opus 5.5 produced solid work, but parallel tasks routinely took more than 10 minutes with little visible feedback. Claire’s experience suggests that a faster agent with slightly weaker output may feel more useful than a smarter one that disappears while working.

6. Duet’s real-world results were capable but inconsistent. Sales pipeline analysis worked quickly through existing connectors, while inbox and Slack triage missed some priorities and important context. A sales deck was decent but off-brand, and ticket shopping worked without fully closing the loop.

7. Context still does not travel cleanly between AI products. Duet cannot access local Claude skills, so Claire’s launch-video workflow required converting those skills into plugins. The industry still has not solved how a user’s context and workflows should move across surfaces.

8. The lack of desktop and multiplayer support keeps Duet outside Claire’s working stack. Her workday happens primarily on a computer and in shared team tools such as Slack. Even a five-person business needs agents that can operate collaboratively rather than remaining single-player mobile experiences.

9. Duet is worth trying, but it has not earned a permanent place in Claire’s stack. The design, models, connectors, and artifact support create a strong foundation. To win the personal-agent race, it still needs to become faster, more proactive, available on desktop, and shareable with a team.

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.

Blair Metcalf is the principal UX engineer at Reddit and the builder of Reddit Proto, the company’s in-house vibe-coding harness. With a design system MCP that maps Reddit’s product language to production code, Proto has reached 100% adoption across Reddit’s UX and product org, and more than 700 prototypes are live on it.

What you’ll learn:

1. Why Reddit built its own prototyping harness

2. How designers share prototypes with leadership safely

3. Why real Reddit data beats mock data

4. How one annotation becomes a code edit in Cursor

5. What a “feature capsule” is

6. Why Blair built a “Rosetta stone”

7. Blair’s surprising fix when AI goes sideways

8. Who turned out to be Reddit’s best prototypers

This entire episode is brought to you by:

Firecrawl—Give your AI agents web data and beyond

In this episode, we cover:

(00:00) Introduction to Blair

(02:31) Reddit Proto demo

(09:15) Annotations to Cursor: the targeted edit workflow

(11:19) Internal deployment and adoption

(14:14) How leadership reviews and gives feedback

(15:52) Engineering handoff and the feature capsule

(17:50) How the custom MCP was built

(21:41) Quick recap

(24:55) Lightning round and final thoughts

Tools referenced:

• Cursor: https://www.cursor.com/

• Figma: https://www.figma.com/

• Figma MCP (Figma’s Model Context Protocol integration): https://www.figma.com/mcp-catalog/

• Code Connect (Figma’s code mapping tool): https://www.figma.com/developers/code-connect

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

• ChatGPT: https://chatgpt.com/

• Vercel (referenced as inspiration for internal deploy infra): https://vercel.com/

Other references:

• Reddit: https://www.reddit.com/

• Kubernetes: https://kubernetes.io/

Where to find Blair Metcalf:

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

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.

Anthropic's new personal agent, Claude Duet, lives on your phone, inherits all your Claude plugins and connectors, and is pitched at small business owners and busy professionals. It's the most polished agent launch I've seen: thoughtful onboarding, task lists, first-class artifacts, and Slack-style channels. But polish isn't enough when you're competing with every other personal agent for attention. I put it to work on my inbox and Slack, my sales pipeline, a Google Docs sales deck, a launch video, and finding Warriors tickets for my kids, and I'll walk you through what it nails, where it stalls, and what Anthropic needs to fix before it can become anyone's number one agent.

What you’ll learn:

1. What Claude Duet is and who Anthropic built it for

2. The design details that make it far more polished than other personal agent launches

3. How task lists, artifacts, and channels work as agent primitives

4. Why a “proactive” agent that never nudges you is a growth problem

5. How model latency kills your willingness to work with an agent synchronously

6. Where it fell short on real tasks, from inbox triage to sales decks to launch videos

7. Why missing desktop and multiplayer support keeps it out of my working stack

In this episode, we cover:

(00:00) Personal agent fatigue: does Claude Duet make the cut?

(00:40) What Claude Duet is and who it’s for

(01:39) Why the design polish stands out

(03:06) Task lists, artifacts, and channels

(04:53) The icon

(05:27) What I didn’t like: not proactive enough

(07:02) Testing it on email, Slack, and Warriors tickets

(07:41) Why latency matters so much in a personal agent

(10:20) The missing desktop app

(12:12) Sales pipeline and a Google Docs deck

(13:10) Launch videos and the local skills gap

(14:00) Single-player vs. multiplayer agents

(15:05) Final verdict

Tools referenced:

• Claude Duet (Anthropic): https://claude.com/resources/articles/claude-duet

• Claude Duet Waitlist: https://claude.com/product/claude-duet

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

• Meta Muse: https://muse.ai/

• Codex (OpenAI): https://openai.com/codex

• Grok Bot: https://x.ai/bot

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.

Meta’s new Muse Wonder model: good for AI agents, bad for design

Brought to you by:

• DX—Engineering intelligence for the AI era

• Jira Product Discovery—Prioritize with insights, build with confidence

Claire puts Meta’s new Muse Wonder model through nearly 20 real-world tasks covering agentic work, coding, writing, design, and video editing. She explains why its active focus mode made it especially strong at billing support, inbox triage, computer use, and email writing, while its prototypes and visual work consistently fell short. She also shares how Muse compares with Opus 5.5, Astra, and Fable, and why she plans to test it in a few agent workflows without letting it anywhere near her front end.

Biggest takeaways:

1. Muse Wonder is the strongest agentic model Claire has tested at its price tier. It ranked first on billing-ticket resolution, inbox triage, computer use, and email writing. Its advantage was clearest on long-running tasks, where it kept trying different approaches until it reached the goal.

2. Muse Wonder’s “active focus” appears to be a real capability. The model spent more time on complex agentic tasks than on quick requests, and the stronger results reflected that additional effort. Claire saw a clearer connection between time spent and output quality than she did with competing models.

3. The billing-ticket benchmark shows whether an agent can function in a real SaaS environment. Muse corrected an account-linking error, handled duplicate refund logic, changed the customer’s plan, drafted a reply, and closed the ticket. It also resisted a prompt-injection attempt and resolved every planted complication.

4. Claire would trust Muse Wonder to write emails on her behalf. It matched her concise, two-sentence style without becoming formal or verbose. Its voice performance was similarly natural and conversational, landing close to Sonnet’s quality in her testing.

5. Muse Wonder should not be trusted with frontend design. Its work defaults to heavy serif fonts, blurple, rounded corners, and generic SaaS layouts. On the ChatPRD redesign, it ignored the brand guidelines, added emojis, broke image rendering, and produced something disconnected from the original site.

6. Getting 80% of a prototype right is very different from finishing it. Muse often created convincing scaffolding, then failed during interaction testing with broken buttons, incorrect themes, and obstructive overlays. Its biggest weakness wasn’t generating the interface but completing it with visual polish and functional fidelity.

7. Muse Wonder has promising video-editing instincts but weak visual execution. It found the right 40-second segment, chose music Claire liked, and nearly nailed the cut timing. Poor overlays, badly placed captions, and flawed audio treatment kept the result from feeling finished.

8. Muse Wonder’s speed depends heavily on the task. It moves quickly through SVGs, short prototypes, and other one-shot requests but slows considerably during inbox triage, backend implementation, and video editing. That difference likely reflects active focus spending more time on complex goals.

9. Muse Wonder has earned a place in Claire’s experiments, but not as her daily driver. She plans to test it inside a few agent workflows because its multi-step reasoning and natural voice are strong. It is especially promising for personal agents and knowledge-work orchestration, as long as the job does not involve design.

“Claude cuts my TikTok”: How this creator is scaling video with AI | Brooke Lacey

Brought to you by:

• Firecrawl—Give your AI agents web data and beyond

• Auros—The human network behind AI

Brooke Lacey is a longtime technologist and creator who has built an audience of more than 290,000 followers on TikTok. In this episode, she shows how she uses Claude Code, FFmpeg, and Whisper to turn a raw phone recording into a fully edited, captioned video in about 15 seconds, all without uploading the footage or opening a traditional editor. She also explains how she trained Claude on her exact jump-cut cadence, mines audience comments for new scripts, and runs her projects through a personal operating system built inside Claude Code.

Biggest takeaways:

1. Brooke replaced a traditional video editor with a terminal and three simple tools. Her TikTok workflow uses FFmpeg, Whisper, and Python, orchestrated by Claude Code. A raw phone video goes in, and about 15 seconds later, a finished vertical short comes out with captions, jump cuts, and zooms.

2. In Brooke’s workflow, the entire edit lives in a text file. Each row of a TSV defines the start time, end time, shot size, and label for a cut. Once Claude creates that file, the same command can generate 15-, 30-, and 60-second versions, plus a landscape crop, from one raw take.

3. Brooke taught Claude to recognize her comedic timing. Instead of simply cutting silences, it learned the cadence of her voice, the pause before a punchline, the ideal cut point after a word, and which repeated take had the best rhythm. Encoding that style required deliberate instruction and iteration, not one clever prompt.

4. A TikTok comment section can become an ongoing content brief. Brooke connects each video with its comments, then asks Claude Code to identify what viewers questioned, debated, or wanted next. The result is a list of new ideas grounded in signals from her actual audience.

5. Creators need to understand the craft before they can delegate it. Brooke could teach Claude to edit in her style because she already knew what a good cut sounded like, where a zoom should land, and why the timing mattered. AI amplifies that judgment, but it does not replace the experience required to develop it.

6. A personal AI operating system is more useful than a collection of prompts. Brooke’s “lane OS” gives Claude Code separate memory, permissions, and status files for each product. When the system makes a mistake, she traces it back to the relevant instructions and records the correction globally so the mistake doesn’t recur.

7. Experienced technologists bring valuable perspective to new platform shifts. Brooke has lived through Windows 3.1, the rise of the internet, Y2K, and today’s AI transition. That history helps her recognize genuine platform changes without panicking, and she believes more experienced operators should share that perspective instead of watching from the sidelines.

8. Posting once a week can be enough when the foundation is strong. Brooke has built an audience while publishing about weekly, with older videos continuing to resurface. Her Claude Code workflow didn’t help her post more; it removed hours of editing friction so each video no longer consumes an entire day.

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.

Brooke Lacey has been making videos since before Facebook had video, and she built a TikTok audience of more than 290,000 by learning to cut short-form videos herself. With over 25 years in tech, she now builds her own apps, including Zosha, a free mobile app for learning AI. In this episode, Brooke walks me through the Claude Code, FFmpeg, and Whisper workflow that edits her TikToks in about 15 seconds, how she mines her comments for new scripts, and how she runs a weekly short-form operation with no editor.

What you’ll learn:

1. How Claude Code edits a raw phone video on her computer in about 15 seconds

2. How she taught Claude her jump-cut cadence

3. Why her TikTok comments became her content brief

4. How she keeps growing her audience while posting just once a week—and what’s next

5. What over 25 years in tech taught her about this AI moment

Brought to you by:

Firecrawl—Give your AI agents web data and beyond

Auros—The human network behind AI

In this episode, we cover:

(00:00) Intro and guest welcome

(02:30) Brooke’s background in video

(06:56) Her first session cutting videos with Claude Code

(08:51) Live demo: Claude edits a video in real time

(11:05) Walking through the edit chain

(15:58) How she taught Claude her cadence, her hooks, and what funny sounds like

(25:36) Quick recap

(26:20) Posting frequency, live streaming plans, and TikTok ads

(28:00) Lightning round: Gen X, wisened experience, and YOLO energy

(32:43) When Claude disappoints: the lane OS, status files, and how she prompts it back

(34:50) Where to find Brooke and the Zosha app

Tools referenced:

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

• FFmpeg: https://ffmpeg.org

• Whisper (OpenAI): https://openai.com/research/whisper

Other reference:

• How I AI episode with John Blackman (91-year-old vibe coder): https://www.lennysnewsletter.com/p/how-a-91-year-old-vibe-coded-a-complex?utm_source=publication-search

Where to find Brooke:

TikTok: https://www.tiktok.com/@brookejlacey

X: https://x.com/brookejlacey

Zosha app: http://zosha.app/

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.

I put Meta’s new Muse Wonder (and Wonder Full) frontier models through the How I AI bench, which covers nearly 20 tasks across prototyping, agentic workflows, coding, writing, and creative work. I scored everything with an LLM-as-a-judge pass and my own voice notes, then pulled together the first-look results you see here.

What you’ll learn:

1. Why Meta’s “personal and professional agent” framing mostly holds up, and where it doesn’t

2. What active focus mode actually does on long-running tasks, and whether it’s real

3. The three agentic tasks where Muse ranked first, and why those categories matter

4. What Muse’s design output actually looks like (it’s not good)

5. How it compares to Sonnet on voice assistant tasks

6. Where Muse lands on SVG and short-form video versus Opus 5.5, Astra, and Fable

7. Whether I’m actually putting Muse into any of my agent workflows

Brought to you by:

DX—Engineering intelligence for the AI era

Jira Product Discovery—Prioritize with insights, build with confidence

In this episode, we cover:

(00:00) Intro and what Muse Wonder is

(01:19) Meta’s frontier capability claims

(04:36) Muse code

(06:06) Benchmark overview and how the How I AI bench works

(07:51) Overall results and TL;DR verdict

(11:53) Agentic tasks

(13:36) Email writing and voice assistant performance

(14:35) Where Muse falls short

(18:28) SVG illustration results

(19:33) Short-form video editing

(21:18) Fast on one-shot work, slow on agent tasks

(22:15) Final verdict and where I’ll use Muse Wonder next

Tools referenced:

• Meta Muse Wonder / Muse Wonder Full: https://research.meta.ai/blog/muse-wonder

• Muse Code: https://developer.meta.com/ai/lp/muse-code

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.

How Meta designed Muse: an AI agent people actually want to talk to | Alex Cornell (Design Director)

Brought to you by:

• WorkOS—Make your app enterprise-ready, with SSO, SCIM, RBAC, and more

Alex Cornell is a design director at Meta, where he leads design for Muse. In this episode, he explains how progressive disclosure makes Muse approachable for casual users without limiting technical ones, why its main chat is designed as a single persistent relationship, and how generative UI can feel personal without constantly changing the interface. He also shares how he uses Muse to turn years of Instagram saves into a shopping catalog, analyze his golf and chess games, and transform a 20-year-old blog into a daily podcast.

Biggest takeaways:

1. AI agents should be designed for conversations with people, not interactions with software. Alex’s guiding question for Muse was “How would this work if you were talking to another human?” That principle shaped everything from removing traditional message bubbles to placing the agent at the top of the screen instead of inside a standard chat window.

2. Progressive disclosure is one of the most useful principles in AI product design. Muse represents the same activity at three levels: a simple emoji for casual users, a task list for anyone who wants more detail, and raw logs for engineers. Each person gets the transparency they need without adding clutter for everyone else.

3. Visible chain-of-thought is often a workaround for latency, not a valuable feature. Many AI products display reasoning steps to reassure users while a slow model works. Muse is fast enough to operate quietly, showing that agents do not need to perform their thinking when they can simply deliver the result.

4. Generative UI works best when the structure stays fixed and the content changes. Muse’s avatar, feed items, and idea cards are deliberately designed surfaces. The dynamic elements are the agent’s status emoji, personalized suggestions, and small animations, allowing the experience to feel alive without rebuilding the interface every session.

5. Instagram saves may be one of the most overlooked data sources for consumer AI. Alex connected years of saved posts to Muse, asked it to organize them, and turned the results into shopping recommendations styled like a SkyMall catalog. It gave forgotten personal data a practical new use without requiring technical setup.

6. Designing non-deterministic systems requires a different relationship with craft. Alex has spent his career controlling exactly how interfaces appeared, but Muse looks different for every person and cannot guarantee pixel-perfect outputs. Learning to judge the results by usefulness rather than visual precision has been one of the most liberating shifts in his career.

7. Muse’s single persistent chat is a meaningful product bet. Instead of dividing every interaction into separate threads, it treats the main conversation as an ongoing relationship with the agent. Side chats handle scoped tasks, but the central thread preserves continuous context in a way Alex believes the industry has not fully explored.

8. Polite prompting may be an effective strategy, not merely good manners. Alex responds to frustrating results with calm, specific feedback rather than anger. He’s also seen agents change their responses when users express frustration more sharply. His conclusion is that clear, respectful direction may produce better results.

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.

Alex Cornell is a design director at Meta, where he leads design on Muse, Meta’s consumer AI agent. He came to the role with a long background in software product design, including time as a founder, and has spent the past year building one of the most thoughtful agent interfaces in the consumer AI space. Muse ships with a custom avatar, a three-layer status display, a personalized ideas surface, and a generative feed. Alex has been sharing the reasoning behind each of those design decisions publicly on Threads.

What you’ll learn:

1. Why Alex built Muse to feel like messaging, not an AI app

2. How Muse’s three-layer status system accommodates different levels of technical expertise

3. What generative UI actually means in a shipped consumer product

4. How Alex turned years of forgotten Instagram saves into a daily shopping catalog

5. Why his mom apologized to her Muse, and what it means for AI design

6. How he uses Muse to track his golf game, shot by shot, as he works toward a single-digit handicap

7. The mindset shift designers need when the output is never pixel-perfect

8. When to use the main chat versus a side chat, and where the architecture still falls short

Brought to you by:

WorkOS—Make your app enterprise-ready, with SSO, SCIM, RBAC, and more

In this episode, we cover:

(00:00) Welcome and guest intro

(02:50) Designing Muse

(05:33) Choosing which primitives to surface: characters, ideas, feed

(08:50) Speed of model and response times

(11:01) Generative UI and personalization

(14:25) SkyMall demo: Instagram saves turned into a shopping catalog

(17:16) Shopping, monitoring, and price alerts with Muse

(19:07) Instagram and Pinterest connectors for visual data

(21:40) Golf use case: round recaps, shot data, practice breakdowns

(25:28) Main chat versus side chats

(27:56) Old blog turned morning podcast: 20 years of posts via the Wayback Machine

(29:39) Chess dashboard: game analysis with a snarky coach

(30:59) What designers need to learn for AI, and what still works

(34:33) Prompting strategy when Muse is being obstinate

(36:31) Where to find Alex

Tools referenced:

• Meta Muse: https://muse.ai

Other references:

• The Wayback Machine: https://web.archive.org

• Instagram: https://www.instagram.com

• Pinterest: https://www.pinterest.com

• Chess.com: https://www.chess.com

• SkyMall/Sharper Image aesthetic: https://www.skymall.com

Where to find Alex Cornell:

LinkedIn: linkedin.com/in/alex-cornell-5449a99

X: https://x.com/alexcornell

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.

Jev: 8 real use cases for the fastest, cheapest model I’ve ever used | John Lindquist

Brought to you by:

Vanta—Automate compliance and simplify security

John Lindquist is an educator and developer who created egghead.io and now runs mega.dev, a hands-on program for developers building with AI agents. In this episode, he walks through eight Jev demos, including a real-time voice assistant, data deduplication, app routing, chess analysis, multi-agent coordination, and a live presentation coach. He also explains why Jev is better understood as a fast, inexpensive decision engine than a chatbot, how layering multiple classifications improves accuracy, and when a traditional LLM is still the better tool.

Biggest takeaways:

1. Jev outputs decisions instead of text, and that constraint is its defining feature. It turns unstructured input into structured results such as scores, classifications, probabilities, and function calls. Once developers stop treating it like a chatbot and identify the decisions their applications need to make, many previously impractical use cases become obvious.

2. Jev’s speed and cost unlock a different class of applications. Across eight demos, John shows what becomes possible when decisions cost almost nothing and return nearly instantly. He spent just 73 cents across 23 development runs, while Claire processed five gigabytes of JSON for 40 cents.

3. The right mental model for Jev is an if/else statement, not prompt engineering. John recommends using it wherever a traditional program would contain a condition, switch statement, or branching decision. Developers define the available paths, and Jev uses natural language to select the right one.

4. Routing is one of Jev’s most immediately useful patterns. A single natural-language input can identify the right tool, infer the intended action, and trigger the appropriate function. John’s to-do and omnibar demos show the kind of fast, flexible command layer that voice assistants have long promised but rarely delivered.

5. Layered classification often works better than relying on one perfect decision. John frequently runs one classification, feeds its result into another, and combines the steps later as real usage data accumulates. Because each call costs so little, adding another pass can meaningfully improve accuracy without making the workflow expensive.

6. The chess benchmark makes Jev’s advantage concrete. It analyzed a full game in under a second, running ten times faster and costing four times less than the low-reasoning LLM without sacrificing accuracy. When the possible actions are finite, a decision model can outperform a generative model on the metrics that matter.

7. Jev makes “efficient inefficiency” a viable strategy. Evaluating every chess move, mapping every route through Wikipedia, or checking every agent’s path for collisions may sound wasteful. But when each decision is fast and inexpensive, brute-force analysis can be simpler and more effective than carefully narrowing the search space.

8. Knowing when not to use Jev matters just as much. Jev works best when the action space is defined and natural language must be routed into it. Creative reasoning, open-ended analysis, brainstorming, and image interpretation still belong to LLMs. The biggest gains come from intentionally combining both types of models.

How OpenAI uses ChatGPT Sites (live at DevDay!) | Kath Korevec (Product Lead)

Brought to you by:

• Merge—Connective infrastructure for production AI

• Vanta—Automate compliance and simplify security

Kath Korevec is a member of the Product staff at OpenAI who has been building and using ChatGPT Sites internally for more than a year. In this episode, she demonstrates how OpenAI uses Sites to turn live Slack, Notion, and calendar data into personalized internal tools, including an incident command center that adapts to each visitor. She also shows how she automated music discovery with Reddit and Spotify and built a community dungeon crawler through shared skills, and explains why fast models are changing how people create personal software.

Biggest takeaways:

1. Plugin Insights lets one site automatically personalize itself for every visitor. Kath connected an incident command site to Slack and Notion, allowing it to infer someone’s team from their channel access and display only the relevant incidents and runbooks. Connector authentication handles the personalization without requiring custom logic.

2. Developers do not have to write the connector logic themselves. Codex can infer the appropriate plugins when a prompt mentions collaboration, Notion, calendars, or other connected tools. Kath often uses the phrase “use Plugin Insights to build this site,” but says Codex frequently reaches for the right connectors without being explicitly told.

3. Sites is infrastructure, not simply a hosting layer. It includes D1 storage, an R2 bucket, MCP plugin hosting, and support for co-editors. Kath’s team uses it for production work, including the slides used during the OpenAI DevDay keynote, while many others still treat it as a prototyping tool.

4. Software can now be temporary and still worth building. Kath might create a personalized site for one business trip, use it for a week, and discard it afterward. When development overhead falls far enough, even a tool with a seven-day lifespan can deliver meaningful value.

5. Kath’s automated music discovery workflow shows what personal software can already do. Her site uses computer control to find popular Reddit playlists every Monday, creates a fresh Spotify playlist, and plays it automatically. During the demo, it surfaced a song she had never heard and genuinely liked.

6. Skills let a community extend an application without accessing its codebase. Kath published a dungeon-building skill that defines the room dimensions, controls, and structure. Anyone can install it, create a themed room with Astra, and add the result to her shared dungeon crawler.

7. Faster models can make builders more creative. Kath and Claire both found that slow generation breaks the creative thread, while immediate results encourage continued experimentation. During one Astra ultrafast session, Claire’s kids called out requests like “jellyfish belly” and “add a chicken,” and she kept building without losing momentum.

8. Kath draws a clear boundary around AI acting in her name. She uses Codex for research, thinking, and drafting, but will not let it email or message people without her approval. Her rule is simple: AI can help prepare the communication, but the send button remains hers.

OpenAI Dev Day 2026: The releases that actually matter

In this solo episode, Claire breaks down the biggest announcements from OpenAI DevDay and shares what happened when she tested several of them early. She explores how Dots, Spaces, and Sites could change the way people and agents work together, then uses the Decisions API to select better podcast thumbnails and Astra ultrafast to build a collaborative sketchpad and an interactive 3D world. She also shares what feels promising, what still needs work, and which new tools are worth trying first.

Biggest takeaways:

1. Dots are more capable than they look, but the product still needs time to mature. Claire’s Dot shopped, wrote code, and proactively noticed a conflict in her kids’ swim schedule. The results were strong, but the relationship between Dot threads, ChatGPT conversations, and Codex remains confusing, so she is waiting to understand where Dots fit before giving a final verdict.

2. ChatGPT Spaces may be the most underrated announcement from DevDay. It gives humans and agents a shared workspace for documents, slides, and other artifacts, with proper permissions and data controls. Claire had recently built a similar tool called Claire’s Notebook because she believed this workflow was missing, and sees OpenAI’s version as a serious challenge to Google.

3. Sites with bundled plugins offers an enterprise answer to the flood of AI-generated internal tools. Teams can package a connector such as Snowflake inside a shareable app while preserving each user’s existing data permissions. Authorized employees see the relevant information, while everyone else remains blocked automatically.

4. GPT-6.1 Sol is a compelling workhorse for cost-conscious teams. It costs $2 per million input tokens and $10 per million output tokens, compared with Astra’s $10 and $50. Claire still pays the premium for Astra because she loves using it, but believes Sol deserves serious consideration for everyday work.

5. Adding vision to the Decisions API unlocks an entirely new category of workflows. Claire used it to scan 100 video frames and identify usable thumbnail shots in about ten seconds. Combining fast, inexpensive classification with visual understanding turns a previously tedious production task into a largely solved problem.

6. Astra Ultrafast is expensive, but it gave Claire a glimpse of the future. An interactive session with her kids cost roughly $97, yet its real-time SVG sketchpad and natural-language 3D game showed what near-instant code generation can feel like inside a product. If the price falls, this level of speed could dramatically expand what people build.

7. The platform primitives may matter more than the flashy demos. Computer use in the Agents API, Codex developer tools, planned plugin monetization, and the new Pro 500 plan create infrastructure developers can build on over time. The ability to use the same foundations powering Codex is especially significant.

8. Claire is still using Grok Bots for daily work, and she is not rushing to switch. She prefers assigning narrow agents to specific jobs rather than relying on one agent for everything. Her advice is to try Dots and watch for where their proactive model earns a place in the workflow, not abandon a system that already works.

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.

Kath Korevec is a member of the Product staff at OpenAI working on Codex, and she spent over a year building and using ChatGPT Sites internally before its public launch. She’s been on the front lines of shipping Plugin Insights, MCP plugin hosting, and the connector ecosystem, which now includes around 60 integrations.

What you’ll learn:

1. What Plugin Insights actually does, and why it changes who can use a site

2. The incident command site Kath built for her OpenAI team, and how it uses live Slack and Notion connectors

3. The one phrase that tells Codex to wire up connectors for you

4. The infrastructure layer inside Sites that most people haven’t touched yet

5. How Kath fixed her Spotify after her kids wrecked it, using Reddit and computer use

6. The skill distribution model behind her community dungeon crawler, and why it’s a new way to think about collaboration

7. Why model speed is what actually determines how creative you get

8. Where Kath draws a hard line on AI acting in her name

Brought to you by:

Merge—Connective infrastructure for production AI

Vanta—Automate compliance and simplify security

In this episode, we cover:

(00:00) Welcome and intro

(01:00) Sites: internal testing and use cases

(05:53) Sites infrastructure

(09:00) Kath’s favorite connectors

(11:10) Unique ways to use Sites

(12:28) Curating a custom Spotify playlist

(15:50) Game design and development

(25:42) Bringing inference into Sites: the widget experiment

(30:00) Awesome Sites gallery

(31:57) Kath’s prompting strategy

(34:20) Wrap-up and how to find Kath

Tools referenced:

• ChatGPT Sites: https://chatgpt.com/sites

• OpenAI Codex: https://openai.com/codex

Other references:

• OpenAI DevDay: https://openai.com/devday

• Awesome Sites: https://awesomesites.ai

Where to find Kath Korevec:

LinkedIn: https://www.linkedin.com/in/kathleensimpson/?isSelfProfile=false

X: https://x.com/simpsoka

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.

I spent the day at OpenAI’s DevDay in San Francisco, and I have good news and bad news: OpenAI released a lot of stuff.

In this episode, I break down the announcements worth paying attention to - and show you what happened when I tested some of them early. We’ll meet my Dot, explore why Spaces and Sites could matter for how teams work, and get into the model and API updates I’m most excited about as a developer.

I use the Decisions API to find podcast thumbnails where nobody looks awkward, build a collaborative sketchpad with Astra ultrafast, and let my kids redesign a 3D world in real time. That last experiment cost about $97. My wallet has thoughts.

These are my early impressions: what’s promising, what still feels rough, and what I think you should try first.

What you’ll learn:

1. What OpenAI’s Dots can do, how I’ve been using mine, and why I’m waiting to give a full verdict

2. Why Spaces might be one of the most underhyped announcements for collaboration between humans and agents

3. How Sites with connectors and plugins could help teams share internal tools with the right data permissions

4. Where GPT-6.1 Sol fits in my model stack—and why speed and cost matter

5. What vision adds to the Decisions API, including my thumbnail-selection and hot dog demos

6. What Astra ultrafast makes possible for interactive AI apps, from collaborative drawing to a changing 3D game

7. Where the speed feels magical, where the experience still needs work, and what it costs

In this episode, we cover:

(00:00) OpenAI DevDay recap—and pressing the Codex reset button

(00:58) Dots: early impressions and rough edges

(06:57) Spaces: working with humans and agents

(10:37) Sites, connectors, and sharing internal tools

(13:06) Models and platform: GPT-6.1 Sol

(14:36) Decisions API: fast decisions with vision

(15:27) Finding better podcast thumbnails with AI

(16:29) Hot dog or not hot dog?

(17:17) Astra ultrafast: speed, pricing, and possibilities

(18:50) The Other Pencil: drawing alongside AI

(19:45) Little Starship: a 3D world you can change with a prompt

(21:24) The $97 AI game—and what it makes possible

(22:25) Agents API, computer use, plugins, and plan updates

(23:03) What I’d try first

Tools referenced:

• ChatGPT: Dots, Spaces, and Sites: https://chatgpt.com/

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

• OpenAI API — GPT-6.1 Sol, Decisions API, and Astra ultrafast: https://platform.openai.com/

• Jev: https://typesafe.ai/

Other references:

• OpenAI DevDay 2026: https://devday.openai.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.

John Lindquist created egghead.io, a developer education platform used by hundreds of thousands of working engineers. These days he’s building mega.dev, a hands-on program specifically for developers who want to do real work with AI agents, not just prototype them.

What you’ll learn:

1. Why Jev is a decision engine, not a chatbot, and what that distinction actually changes about how you build

2. How John built a real-time voice to-do app that classifies and executes commands with no visible pause

3. The data deduplication pattern that merges messy records in milliseconds using confidence scores

4. Why Jev works best as a router, and how a single text input can navigate users deep into an app

5. What a chess match between Jev and a low-reasoning LLM reveals about speed, cost, and when to use which

6. The multi-step classification pattern John reaches for when one Jev pass isn’t enough

7. Where Jev falls short, and when you should still reach for a full generative model

Brought to you by:

Vanta—Automate compliance and simplify security

In this episode, we cover:

(00:00) John Lindquist returns for Jev week

(04:32) What Jev actually outputs

(06:15) Demo: real-time voice to-do app

(08:17) How sequential Jev calls chain together

(10:38) Demo: plain English to function name (grocery cart)

(11:50) Demo: data deduplication and record merging

(13:45) Confidence scores and multi-model validation

(15:06) Demo: Jev as a multi-level app router

(18:23) Architecting around Jev

(19:35) Demo: Jev vs. traditional LLM at chess (speed and cost benchmarks)

(24:29) DOM interactions as a decision set, not an infinite canvas

(28:21) Demo: Wikipedia “path to philosophy” route mapper

(30:28) Demo: multi-agent coordination and collision avoidance

(33:36) Demo: real-time presentation coach

(36:56) Quick recap

(39:54) Lightning round and final thoughts

Tools referenced:

• Jev (TypeSafe AI decision model): https://typesafe.ai/blog/introducing-system-one-models-and-jev

• Vercel AI Gateway: https://vercel.com/docs/ai-gateway

• OpenRouter: https://openrouter.ai

• Opus 5.5 (mentioned in context of iterative demo building): https://www.anthropic.com/claude-opus-5-5

Where to find John Lindquist:

LinkedIn: linkedin.com/in/john-lindquist-84230766

X: https://x.com/johnlindquist

Mega.dev: https://mega.dev/

Egghead.io: https://egghead.io/

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.

Jev for beginners: how to use it and what to build

Brought to you by:

• OpenArt—An all-in-one AI creation platform for images, videos, music, audio, and more

In this solo episode, Claire tests Jev, TypeSafe AI’s new decision model that returns structured choices, scores, and probabilities instead of generated text. She uses it to analyze 1,700 pull requests for 9 cents, map her Claude and Codex usage, triage email, search 4,500 YouTube comments, and process 200,000 classifications for about $4. She also explains why Jev works best alongside a frontier model and how its speed and pricing make entirely new kinds of real-time apps and large-scale analysis practical.

Biggest takeaways:

1. Jev is a decision model, not a language model, and that distinction can make many tasks dramatically cheaper. Instead of generating text, it returns predefined values such as a category, score, or probability. Claire believes this covers roughly 90% of what many software workflows actually need, at 4 cents per million input tokens with no output-token fee.

2. It cost Claire 9 cents to understand where two years of engineering work went. She used Jev to compare 1,700 ChatPRD pull requests across 17,000 pairs, then had Gemini Flash Lite label the resulting clusters. In about two minutes, she learned that nearly 30% of the company’s engineering work had gone toward platform, security, and infrastructure.

3. Some of the most useful analysis is already sitting on a local computer. Claude Code and Codex store past sessions locally, allowing Jev to classify them in minutes. Claire discovered that engineering had fallen from nearly 100% of her AI usage in January to less than 40% by September, with agents and media publishing filling the gap.

4. Jev becomes far more powerful when paired with a frontier model. Claire uses Jev to classify, cluster, filter, and route large datasets, then sends only the most important groups to GPT-6 Astra for deeper reasoning. For ChatPRD’s product insights graph, this approach processed 1,100 signals and completed 200,000 operations for about $4 on the Jev side.

5. Jev’s pricing changes which ideas are worth building. Because it returns small predefined values instead of generating long responses, TypeSafe charges nothing for output tokens. Claire spent less than $10 on Jev during the week, making classification workloads that would normally be expensive at scale feel almost free.

6. Jev makes real-time AI loops practical. Claire built a voice app that turns a spoken phrase into a color, matches it with a quote based on sentiment, and displays everything almost instantly. Jev made its decisions so quickly that the quote API became the slowest part of the workflow.

7. YouTube comment analysis is an immediate use case for any podcast team. Claire classified 4,500 How I AI comments by sentiment, identified 58 containing episode ideas, and built a keyword search that scans the full dataset in under a second. The results showed strong demand for a Grok versus Muse comparison and an 80% positive response to the “Claude Code for product managers” episode.

8. The real skill is recognizing where a pipeline only needs a decision. Jev will not write documentation or design an interface, but it can sort, route, rank, and filter enormous datasets quickly and cheaply. Claire now asks one question before every build: Where does this workflow simply need to make a decision? That is where Jev belongs.

I left Claude for months. Opus 5.5 is why I’m back.

Claire tests Claude Opus 5.5 after months of leaving Claude out of her daily workflow. She puts it through long-running agentic tasks, frontend prototyping, writing, SVG illustration, computer use, and video editing to see where it earns a place back in her stack. She also shares why she is pairing it with Codex for cross-model code review, where Claude’s safety limits still get in the way, and which tasks remain firmly in Codex territory.

Biggest takeaways:

1. A model’s personality can matter just as much as its intelligence. Claire stopped using Claude for months because its rambling, preachy, and overly verbose replies made it unpleasant to work with. Opus 5.5 is the first model in the family that no longer makes her blood boil, which is a meaningful improvement even if no benchmark captures it.

2. Opus 5.5’s lower price and faster performance make long-running agent work more practical. It is 40% cheaper than Opus 5, and Claire found it noticeably faster. It successfully completed four complex tasks spanning inbox triage, backend development, research, and computer use, including runs of up to 82 steps from a single prompt.

3. Silence during long-running tasks creates its own user experience problem. Opus 5.5 sometimes remains quiet for eight or nine minutes, leaving users unsure whether it is still working. It is a reminder that perceived latency matters alongside actual latency, especially when agents run for extended periods.

4. Opus 5.5 is the strongest frontend designer Claire has tested so far. Its ChatPRD homepage redesign was bold and polished enough that she plans to ship it. The model handles hierarchy, white space, and visual rhythm exceptionally well, though it still struggles with consumer-app aesthetics and defaults to “Claude orange” without direction.

5. SVG illustration is an unexpected strength of Opus 5.5. It was the only model Claire tested that produced clean, charming, and animatable character SVGs with consistent styling across multiple expressions. The characters remained visually coherent, and their anatomy mostly made sense.

6. Opus 5.5 has a clear safety posture, and sometimes that means saying no. It refused when Claire asked it to skip testing and push directly to production, and it may route cybersecurity work to Opus 4.8. Whether that feels reassuring or frustrating depends on the workflow, but its boundaries are consistent.

7. The best use of Opus 5.5 may be as an adversarial reviewer for another model. Claire now has Codex and Opus review each other’s work rather than using one to replace the other. This cross-model loop catches issues either model might miss alone, making the additional cost worthwhile when quality matters.

8. Computer use and video editing still belong to Codex in Claire’s workflow. Opus 5.5’s ElevenLabs MCP video test produced weak color grading, too few jump cuts, and sloppy overlays. Codex also remains stronger at computer use in her current setup, giving her no reason to shift either category to Claude.

9. Claude is back, but it has not replaced Codex as Claire’s daily driver. Opus 5.5 has earned a role in pull-request reviews, architecture questions, and frontend development. Codex’s desktop experience, computer use, and workflow integration still keep it in the primary position.

Opus 5.5 vs. GPT-6 Sol: which model won my blind taste test?

Claire takes the How I AI bench live to compare GPT-6 Astra, GPT-6 Sol, Claude Opus 5.5, and more across the work she actually does. She blind-scores writing, frontend prototypes, agent personality, and SVG illustrations, with an AI judge helping evaluate backend work, long-running agents, and computer use. She also checks video edits and a 3D Barbie game build. Along the way, she explains why Astra won her heart, Opus 5.5 won her week, and Sol delivered mixed results while remaining a favorite for everyday work.

Biggest takeaways:

1. Expanding the benchmark from two categories to eight changed what Claire could see. The original How I AI Vibe Review focused on PRDs and frontend prototypes. Adding personal productivity tasks like inbox triage, along with backend development, long-running agent tasks, computer use, SVGs, and video editing exposed clear differences between the models Claire preferred for design and those she enjoyed interacting with.

2. Opus 5.5 returned to Claire’s workflow because of ergonomics, not benchmarks. After repeatedly asking Claude to communicate like a normal person, she found Opus 5.5 concise, clear, and far less irritating. At one point, Claire thought the old frustration had returned, then realized she had accidentally selected Opus 5. The difference was that obvious.

3. Making Opus 5.5 quieter also made it feel slower, even when it was not. Long stretches of silence can make users wonder whether the model is still working. GPT-6 Sol found a better balance in Claire’s testing, narrating enough to feel responsive without creating additional noise.

4. GPT-6 Sol’s lower price changes how teams should think about model selection. Learning that Sol costs roughly half as much as Opus 5.5 immediately changed how Claire thought about routing work. She also believes teams should optimize caching before obsessing over model choice, since ChatPRD has seen significant savings when its caches are configured properly.

5. Dash-heavy writing is an immediate warning sign in Claire’s benchmark. Two models received a 1 out of 5 for agent personality because nearly every message contained an em dash. It may sound overly specific, but Claire sees it as a reliable signal that a customer-facing agent will sound like generic AI writing instead of a natural collaborator.

6. Claire and the AI judge disagree, which makes the benchmark more useful. The judge favored Fable and rated Sol lower, while Claire preferred Astra. The difference reflects two definitions of quality: the judge rewards correctness and structure, while Claire measures how much she actually wants to use the model.

7. The blind SVG comparison changed Claire’s earlier verdict. In her standalone Opus 5.5 review, Claire favored its character illustrations. But in this live blind comparison, Astra and Sol came out ahead on character SVGs, surprising her after she had predicted a Claude win.

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.

Jev is TypeSafe AI’s new decision model. It returns type-safe structured values (a choice, a score, a probability) instead of generated text, at 4 cents per million input tokens with no output charge. This week I ran it on five real projects: PR categorization, a meta-analysis of my own Claude and Codex sessions, Gmail triage, the ChatPRD product insights graph, and a live audience dashboard built from 4,500 YouTube comments.

What you’ll learn:

1. What makes Jev fundamentally different from every other model I’ve used

2. How I analyzed 1,700 PRs for 9 cents and what I found out about where my engineering effort actually went

3. The personal meta-analysis you can run on your own Claude and Codex sessions right now

4. Why I stopped using Jev alone, and what I pair it with now

5. How I turned 4,500 YouTube comments into a searchable audience dashboard for almost nothing

6. The real-time app I built in an afternoon that shows something surprising about Jev’s speed

7. Why Jev’s pricing model is different from any LLM I’ve used, and what it makes practical to build

8. The ChatPRD product insights project: 1,100 signals, 200,000 classifications, and what it cost me

Brought to you by:

OpenArt—An all-in-one AI creation platform for images, videos, music, audio, and more

In this episode, we cover:

(00:00) Jev launch and what makes it different from every other model

(02:49) Type-safe values explained

(05:28) Understanding Jev outputs

(07:39) Use case 1: PR categorization and pairwise clustering

(11:12) Use case 2: analyzing your own local Claude Code and Codex sessions

(13:00) Use case 3: Gmail triage with Jev scoring and LLM follow-up

(14:30) Use case 4: ChatPRD’s product insights graph

(18:17) Demo: How I AI audience signal dashboard

(22:14) Demo: voice-to-color emotion-mapping app

(25:16) Jev week recap and what’s coming in episode 2

Tools referenced:

• Jev (TypeSafe AI): https://typesafe.ai

• Vercel: https://vercel.com/ai

• GitHub API: https://docs.github.com/en/rest

• YouTube Data API v3: https://developers.google.com/youtube/v3

• OpenAI Realtime Voice API: https://platform.openai.com/docs/guides/realtime

• Gemini 3.5 Flash-Lite: https://ai.google.dev/gemini-api/docs/models/gemini-3.5-flash-lite

• API Ninjas Quotes API: https://api-ninjas.com/api/quotes

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.

I got up early to record an Opus 5.5 review. Then Anthropic and OpenAI dropped new models on the same morning, and I decided to do something I’d never done before: take the How I AI bench live. I put GPT-6 Astra, GPT-6 Sol, Claude Opus 5.5, and more through the work I actually care about: emails, PRDs, frontend prototypes, backend work, long-running agents, SVGs, and video editing. I scored the outputs without knowing which model made them, so you get to watch me make predictions, change my mind, and reveal my own very inconsistent taste. Astra won my heart. Opus 5.5 won my week. Sol still has me split. There’s a creative result I got completely wrong, an LLM judge that disagreed with me, and a return to Barbie Bench: the 3D fashion game that keeps reminding me how far we have to go. The hands are tragic. AGI has not arrived.

What you’ll learn:

1. How I run the How I AI bench blind, and what gets an output a bad score before I even know which model made it

2. Why Astra won my heart while Opus 5.5 might be overall strongest, especially for long-running agents and B2B frontend

3. Where Sol still wins me over on clear writing, readable PRDs, and price

4. The character SVG results that completely overturned my prediction about Anthropic

5. What happened when I asked these models to edit video, and why I think skills explain part of the disappointment

6. Why an LLM judge disagreed with my rankings, and what it was rewarding that I wasn’t

In this episode, we cover:

(00:00) LIVE setup and new model launches

(01:30) What’s new in Opus 5.5, Sol, and Luna

(04:11) Guardrails, personality, and speed

(09:00) The How I AI bench and blind evaluation process

(11:31) Email and personal-productivity results

(13:50) Frontend prototype vibe checks

(24:10) Backend, agent personality, and long-running tasks

(28:25) SVG illustration test

(29:48) AI video-editing results

(30:43) Predictions before the reveal

(31:20) Barbie Bench: the 3D fashion-game test

(34:17) Results: Astra, Sol, and Opus 5.5

(35:04) Writing clarity and creative surprises

(36:51) Why the LLM judge disagreed with me

(37:24) What each model is actually best for

Tools referenced:

• Claude Opus 5.5: https://www.anthropic.com/claude-opus-5-5

• GPT-6 Sol and Luna: https://openai.com/index/introducing-gpt-6-sol-and-luna/

• Codex (OpenAI): https://openai.com/codex

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.

I’ve been off Claude for months. Not because it got dumb, but because it got annoying. The rambling, the hedging, the preachy little disclaimers on tasks that didn’t need them. I moved most of my daily work to Codex and I didn’t miss it. Then Anthropic shipped Opus 5.5: 40% cheaper than Opus 5, faster, and with what they’re calling a fundamentally different alignment approach. I ran it for a week across real work, including four long-running agentic tasks, a full ChatPRD homepage redesign, an SVG benchmark, and one very firm refusal, and I’m ready to give you the honest verdict. There’s a lot to like. There are still two things that drive me a little crazy. And there’s one capability I genuinely wasn’t expecting.

What you’ll learn:

1. Why I walked away from Claude entirely, and what it took for me to come back

2. The real cost math on Opus 5.5 and why pricing matters more for agentic work than single prompts

3. What happened when I ran four long-running agentic tasks, including one that tried to manipulate Claude mid-run

4. Why Opus 5.5 is now my go-to for frontend prototyping, and where it still lets me down

5. The one capability I genuinely didn’t see coming, and no other model in my stack can match it

6. The moment Opus 5.5 told me flat-out no, and what that says about where Anthropic’s safety posture actually lands in practice

7. Where Codex still wins, and how I’m splitting my model stack after a full week of testing

In this episode:

(00:00) Why I stopped using Claude

(01:02) What Anthropic says Opus 5.5 is

(01:54) Cost, speed, and benchmark overview

(03:20) Safety, alignment, and the cybersecurity limits

(05:02) How I AI bench

(05:39) Voice test: is it actually not annoying?

(07:54) Long-running agentic task results

(10:50) Frontend prototyping

(17:23) Writing voice and email

(19:41) SVG illustrations

(20:46) Video editing

(21:42) My verdict: what it’s good at, what it still isn’t

Tools referenced:

• Claude Opus 5.5: https://www.anthropic.com/claude-opus-5-5

• ElevenLabs MCP connector: https://elevenlabs.io/mcp

• Codex (OpenAI): https://openai.com/codex

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.

Muse review: The personal AI agent that gets consumer UX right

Brought to you by:

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

OpenArt—An all-in-one AI creation platform for images, videos, music, audio, and more

In this solo episode, Claire tests Meta’s Muse, a personal AI agent designed for everyday users. She walks through how it manages her family calendar, creates a polished morning newsletter, tracks personal goals, and asks for permission before acting on sensitive information. She also explores the thoughtful details that make Muse feel trustworthy, where its browser use still falls short, and what its approach could mean for the future of consumer AI.

Biggest takeaways:

1. Meta’s consumer design expertise makes Muse feel different from other agents on the market. The teams behind Facebook and Instagram understand how to build trust with nontechnical users, and that experience shows up throughout Muse. It never exposed Claire to a terminal, surfaced a confusing error, or requested permission at an awkward moment. She tested onboarding, calendar management, email ingestion, goal setting, and browser-based purchasing in one session without encountering a single moment of friction that broke the experience.

2. Muse created the best version of Claire’s family morning brief on its first attempt. Claire has tested generating family newsletters with OpenClaw and Codex, but Muse produced a more beautiful and thoughtfully structured PDF without requiring any follow-up prompting. It even added a “Talk at the Table” section with kid-friendly questions about the news and proactively identified scheduling conflicts. That is the standard personal agents should aim for: not simply completing the request but noticing useful things the user did not think to ask about.

3. How an agent requests permission matters as much as what it can do once permission is granted. Muse does not default to unlimited access or interrupt the user with constant approval requests. It asks at the moment access becomes relevant, confirms what it found, and checks again before taking action. After reading Claire’s email to build a family profile, for example, Muse summarized what it had learned and asked whether it could use that information. Anyone building an agent that handles personal data should pay attention to that interaction pattern.

4. Muse’s activity feed provides the kind of agent transparency Claire wants everywhere. Every task includes a detailed record of the tool calls, scripts, searches, and individual steps Muse completed. Most consumers will probably ignore it, but developers and power users will find it invaluable. Claire immediately wanted the same interface in Codex and Claude Code. Seeing exactly how an agent arrived at an outcome builds a different level of trust than receiving a polished result with no visibility into the process.

5. Personal goals require a different product model than tasks or chat. Helping someone gently sleep-train an eight-and-a-half-month-old while room-sharing in a small house is not a request that can be completed in one sitting. Muse gathered context across multiple turns, established a reminder, and treated the situation as an ongoing goal whose progress should be tracked. Its tone was warm and specific without becoming overly agreeable. Claire said she felt “zero percent annoyed” with it, which she described as a miracle.

6. Browser use remains the weak link for consumer agents. Muse struggled to shop for New Balance 9060s in a specific colorway, returning incorrect results and failing to complete the purchase. It performed better while buying tickets for The Odyssey, but initially opened the wrong movie. These failures are not unique to Muse. They are a reminder that browser-based shopping remains unreliable across the entire agent category.

7. Muse’s animated avatar shows what it means to design specifically for AI. Instead of displaying a generic spinner while it works, Muse generates an animation in which its avatar picks up a tiny laptop when completing tasks and an orb when creating media. Nobody asked for this feature, but it makes the agent’s state immediately understandable. For Claire, this is what operating at the top of the craft looks like. It is not just polished corners and clean icons. It is using capabilities like image generation and animation to solve experience problems that could not have been solved before.

8. Muse is introducing a new vocabulary for consumer AI. It avoids technical terms such as crons, tools, artifacts, plugins, and connectors. Instead, it organizes the product around a feed, ideas, goals, and a library. That language is a deliberate design decision. The words a product uses determine who feels comfortable using it, and Muse is clearly designed for a much broader audience than today’s coding and productivity agents are.

How Warp ships 2,000 PRs a month with AI factories | Zach Lloyd (CEO, Warp)

Brought to you by:

DX—Engineering intelligence for the AI era

OpenArt—An all-in-one AI creation platform for images, videos, music, audio, and more

Zach Lloyd is the co-founder and CEO of Warp, an agentic development platform for software teams. In this episode, he demonstrates how Warp Factories turns a request in Slack into a tracked, tested, and merged pull request, with the first PR ready in as little as 35 minutes. He also explains how the team measures human involvement, scores every agent run, replays real tasks to compare models, and uses failed runs to continuously improve the factory itself.

Biggest takeaways:

1. A software factory is not just a faster coding agent. It is the entire development lifecycle running in the cloud. Warp’s factory, Wilson, can take a request from Slack through triage, Linear ticket creation, implementation, pull-request creation, computer-use QA, and merge without a human touching the keyboard. The difference between a factory and a coding agent is the difference between an assembly line and a single machinist. One completes a task. The other coordinates the entire production process.

2. “Human interactions per pull request” may be the clearest measure of factory efficiency. Every follow-up prompt in Slack, clarification on a Linear ticket, and correction during code review represents additional human effort. Zach believes that the more steering an agent requires, the lower the factory’s true throughput becomes. It does not matter how quickly the agent writes code if a human remains the rate limiter, yet most teams are not measuring this.

3. Humans in code review are now the biggest bottleneck in Warp’s engineering process. Wilson takes an average of 35 minutes to move from kickoff to pull request. The first human review arrives 3.5 hours later. Warp has already removed one source of delay by allowing the person who prompted the agent to review its work instead of requiring a separate reviewer. The company has not eliminated human review entirely, but Zach expects that accumulated trust will eventually make it possible for selected changes to merge without human review.

4. A company’s own past work provides a better model benchmark than a public leaderboard. Benchmarks such as SWE-bench and Terminal-Bench measure performance on generic tasks. Warp instead replays real factory jobs using different model configurations, evaluates them with the same judging system used in production, and maps the cost-quality tradeoff on a Pareto chart. For Warp’s workload, model selection is the largest cost lever by far, with context management a distant second.

5. Software factories can improve themselves when their configuration lives in code. Warp’s improvement loop collects failed runs until there is enough evidence to identify a pattern, typically around 20 to 25 examples. An observer agent analyzes what went wrong and proposes changes to the factory’s agent definitions. Because those definitions are stored as code, the same agents that complete the work can also update the instructions governing how they operate.

6. The scoring layer is what separates a reliable factory from a vibe-coded pipeline. Warp uses an AI judge to score every agent run across multiple dimensions, including whether it created redundant tests. Agents often write tests that merely confirm current behavior instead of protecting against future regressions. The judging model is intentionally mid-tier so evaluation costs do not erase the factory’s savings, and Warp can adjust the sampling rate depending on how much oversight a workflow needs.

7. AI becomes far more valuable outside engineering when it connects to real business data. During the conversation, Zach ran three tasks in parallel: redesigning a slide through Figma, extracting the 10 most common sales questions from four weeks of Granola transcripts, and creating a cold-lead re-engagement list in Google Sheets. The redesigned slide was useful, but the Granola analysis was more consequential. It identified “buy versus build” as the top customer question and backed that conclusion with evidence, giving Warp a clear signal about what its website and sales deck should address next.

8. Working with agents in public can spread expertise without a formal training program. Every Wilson task runs in a shared Slack channel, allowing junior employees to watch experienced users prompt, steer, and correct the system in real time. Zach sees a power-law effect in agent usage: a small number of people become dramatically better than everyone else. Making their workflows visible allows those skills to spread quietly across the organization.

9. Building faster does not help if the team builds the wrong thing. Warp still relies on user interviews, design sessions, and direct observation of how people use the product. The factory dramatically accelerates implementation, but it does not decide what deserves to be built or why. Those decisions still depend on human taste, customer understanding, and product judgment. The build phase may be changing quickly, but the work that comes before it remains remarkably traditional.

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.

Zach Lloyd is the co-founder and CEO of Warp, an AI-powered terminal and software factory platform used by tens of thousands of engineers. Before Warp, he spent nearly a decade at Google, including time as a principal engineer on Google Sheets. He built Warp from the ground up as a modern, AI-native alternative to legacy terminals, and the team has since expanded into software factories: a full cloud-based system that takes an idea in Slack all the way through to a merged PR.

In this episode:

1. Why a software factory is more than a coding agent

2. The public Slack → Linear → GitHub → QA workflow

3. Human interactions per PR as a signal of automation and throughput

4. Why human review is still the bottleneck

5. Scoring agent runs, finding failure modes, and self-improving agent workflows

6. Replaying real tasks to choose model cost and quality tradeoffs

7. CEO workflows with Figma MCP, Granola, and research agents

Brought to you by:

DX—Engineering intelligence for the AI era

OpenArt—An all-in-one AI creation platform for images, videos, music, audio, and more

In this episode, we cover:

(00:00) Intro

(02:35) Warp’s AI software factory, Wilson

(09:23) Automatic factory triggers

(11:12) The engineering leader dashboard Zach wishes he’d had

(15:18) How code review is changing in an AI factory

(17:08) Tracking cost per PR across model configs

(18:47) Using LLM-as-a-judge to score every agent run

(20:02) Catching redundant tests

(22:19) How the factory self-improves from failed runs

(26:03) Quick recap

(28:33) Building a cost-quality Pareto chart for model selection

(31:35) How Zach uses AI for non-technical CEO work

(32:10) Figma MCP demo

(35:43) Granola MCP demo

(36:41) GOG CLI demo

(38:20) Thinking in parallel tasks instead of sequential ones

(40:42) Zach’s prompting strategy for factory tasks

(44:48) Where to find Zach

Tools referenced:

• Warp (AI terminal and software factories): https://warp.dev

• Warp Factories: https://warp.dev/factories

• Linear (project and issue tracking): https://linear.app

• GitHub (version control and PR management): https://github.com

• Slack (team communication and factory input layer): https://slack.com

• Sentry (crash reporting and automated issue triggers): https://sentry.io

• Figma (design, used via Figma MCP): https://figma.com

• Granola (AI meeting notes and MCP integration): https://granola.so

• Grok Bot (fast inference, cost/quality trade-off): https://x.ai/bot/guides/grok-bot-101

Where to find Zach:

X: https://x.com/ZachLloydTweets

Where to find Claire:

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.

I spent a few hours putting Meta’s Muse, its new personal AI agent, through a real first-pass test: onboarding, calendar management, goal setting, a one-shot family morning newsletter, browser-based shopping, and the animated avatar that honestly surprised me.

What you’ll learn:

1. Why Muse is the best-designed personal agent I’ve tested, and what specifically made it feel that way

2. The one-shot family PDF Muse produced that Claude and Codex never quite nailed

3. How Muse’s permission model works, and why it’s different from every other agent I’ve used

4. Why I set up a sleep training goal in Muse, and what it revealed about agent tone

5. The activity feed feature I immediately wished Codex and Claude Code had

6. Where Muse failed, and what it says about the limits of this category right now

7. The animated avatar decision that showed me what top-of-craft AI product design actually looks like

Brought to you by:

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

OpenArt—An all-in-one AI creation platform for images, videos, music, audio, and more

In this episode, we cover:

(00:00) What Muse is and who it’s actually built for

(04:41) Signing in and the onboarding flow

(07:16) The activity feed and its task lineage

(08:24) First real task: managing the family calendar and deleting soccer practice

(09:48) Requesting a morning newsletter PDF

(14:29) The personalized news feed and how I set it up

(16:05) The “Ideas” feature as an out-of-the-box prompt library

(17:10) Setting up personal goals (water, shoes, and sleep training)

(21:40) Library: documents, websites, images, videos, and podcasts

(23:11) Quick recap and what I love

(23:56) Activity feed design deep dive: tool calls and step-by-step lineage

(25:18) How Muse handles permissions

(26:12) The animated avatar: Polly becomes Slime, the teal dragon

(29:34) Browser use test: shopping for New Balance 9060s (not great)

(31:15) Browser use test 2: buying IMAX tickets for The Odyssey (much better)

(33:34) TL;DR and what I’ll actually use Muse for going forward

Tools referenced:

• Muse: https://muse.ai/

• Stripe Link (payment method featured in Muse): https://link.com

• 1Password (future Muse integration mentioned): https://1password.com

• OpenClaw (Claire’s previous personal agent setup): https://openclaw.ai/

• Grok Bot (Grok-based agent from prior stack): https://x.ai/news/introducing-grok-bot

• Codex (OpenAI coding agent, comparison point): https://openai.com/codex

• NotebookLM (Google, comparison to Muse’s podcast generation): https://notebooklm.google.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.