I got a few hours of early-access testing with Anthropic’s newly released model Opus 4.8. I walk through real coding, design, and strategy tasks across Claude Code and Claude Cowork, and give you my unfiltered view on what impressed me and what didn’t.

What you’ll learn:

1. Where Opus 4.8 excels: greenfield prototypes, one-shot features, and fast execution

2. Where it struggles: the last 10%, edge cases in existing codebases, and hallucinations

3. How Opus 4.8 compares to Opus 4.7 on business strategy work

4. Why I’m still reaching for Opus 4.7 on data-heavy strategy and roadmap work

5. The new features shipping alongside the model: dynamic workflows with parallel subagents and effort control in Claude.ai and Cowork

6. The prompting and harness strategy I’d use to get the most out of it

In this episode, we cover:

(00:00) Introduction to Opus 4.8

(00:44) Benchmark performance and pricing

(01:53) First coding test: Building a prototyping tool

(03:00) Where it failed: The last 10% problem

(03:27) The hallucination problem

(04:23) Testing Opus 4.8 on existing codebases

(05:24) The ambition test: Building games for a 9-year-old

(07:03) Business strategy test: 4.7 vs 4.8

(08:23) The roadmap test

(09:17) Final verdict

References:

• System Card: Claude Opus 4.8: https://cdn.sanity.io/files/4zrzovbb/website/c886650a2e96fc0925c805a1a7ca77314ccbf4a6.pdf

• Introducing Claude Opus 4.8 on X:

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.

In this 30-minute episode, I walk through my favorite feature in Codex: the /goal command. I show how Goals transform AI from a turn-based assistant that needs constant ‘what’s next?’ prompting into an autonomous agent that can work for hours on complex, multi-step tasks. I share three real examples: eliminating thousands of Sentry errors, cleaning 3,900 emails down to 68, and organizing hundreds of Linear tasks.

What you’ll learn:

1. What Goals are and how they differ from standard prompts

2. How I used /goal to eliminate hundreds of error logs in my codebase over a five-hour autonomous run

3. The non-technical use cases that make Goals incredibly powerful: cleaning up 3,900 emails in under four hours and organizing hundreds of project management tasks in Linear

4. How to write effective /goal prompts with measurable outcomes, verification methods, and constraints

5. When not to use Goals and what makes a strong versus weak Goal

6. Why Goals represent a fundamental shift in how we work with AI, from babysitting the model to managing it

Brought to you by:

Mercury—Radically different banking loved by over 300K entrepreneurs

In this episode, we cover:

(00:00) Introduction

(01:50) What is /goal and when should you use it?

(02:45) The difference between prompts and Goal-based loops

(04:06) Claire’s first five-hour 45-minute autonomous coding task

(05:05) How to manage a Goal lifecycle: view, pause, resume, and clear

(06:06) How to write strong goals: outcomes vs. outputs

(07:34) The six components of effective Goals

(08:57) Example: Reducing P95 checkout latency with /goal

(09:36) Demo: Using /goal to eliminate Sentry errors in ChatPRD

(13:18) Demo: Burning down Vercel API errors

(17:28) Non-technical use case: Cleaning 3,900 emails with /goal

(21:24) Demo: Using /goal to clean up Linear project tasks

(24:41) When not to use /goal

(26:10) Why /goal changes everything

Tools referenced:

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

• Sentry: https://sentry.io/

• Vercel: https://vercel.com/

• Linear: https://linear.app/

Other reference:

• OpenAI blog post “Using Goals in Codex”: https://developers.openai.com/cookbook/examples/codex/using_goals_in_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.

How the engineer behind Claude Cowork actually uses Claude | Felix Rieseberg (Anthropic)

Brought to you by:

• Magic Patterns—Prototypes that look like your product

• Guru—The AI layer of truth

Felix Rieseberg, the engineering lead for Claude Cowork and Claude Code Desktop at Anthropic, joins Claire to show how he actually uses Claude in his own life and work. In this episode, Felix walks through building a 3D floor planner from a 2D house plan, using email as a personal inventory database, creating live dashboards from connected apps, and hacking together a $20 hardware “Claude buddy.” He also shares his philosophy for getting more out of AI: go one abstraction layer up, let Claude work in the background, and stop assuming computers can’t solve some of the annoying little problems in your life.

Biggest takeaways:

1. The biggest barrier to AI adoption is people not realizing they can ask AI to solve almost any problem. Felix sees this constantly—the tools are incredibly powerful, but users haven’t built the muscle memory to reach for them. His advice: whenever you’re doing something annoying that doesn’t feel creative, pause and ask yourself if Claude could do it instead. The gap isn’t technical; it’s psychological.

2. Your email is an untapped gold mine of personal data. Felix used his email to inventory all his furniture when moving houses: every purchase receipt, every confirmation, every dimension. Claude parsed it all and built him a 3D floor planner with his actual furniture. This same principle applies to clothing, medical records, travel history, or any domain where you’ve been emailing receipts and confirmations for years. You already have a structured database—you just need to point Claude at it.

3. Go one abstraction layer up, then do it again. Felix started manually entering furniture dimensions into his floor planner, then stopped and asked Claude to figure out what furniture he had. Then he went another layer up and told Claude to find the furniture in his emails. This is the key pattern: every time you catch yourself doing tedious work, ask how Claude could do it instead. Then ask how Claude could figure out what to do without your telling it.

4. Live artifacts are Claude’s answer to keeping your personal dashboards always up-to-date. Unlike static artifacts, live artifacts refresh with real-time data from your connected services—Spotify, Gmail, Calendar, Notion, whatever you’ve authorized. Felix built a personal dashboard that looks like early-2000s software that updates throughout the day. The killer feature: you never have to manually update your pitch deck, your daily briefing, or your personal reports again.

5. Choose Opus when you don’t know what you’re really asking for. Felix’s heuristic for model selection: use Sonnet when the problem is well-scoped and specific. Reach for Opus when you need Claude to interpret what you actually want, not just what you said. It’s the difference between “make me a floor plan with units” (Sonnet territory) and “help me figure out how to organize my life” (Opus territory). For most tasks, Sonnet is perfectly capable, but when you need that extra layer of problem decomposition, Opus is worth it.

6. Kids are the best AI users because they aren’t afraid to ask for things. Felix gets videos from parents showing what their kids build with Claude—custom video games with hand-drawn characters, interactive stories, tools that would have required a software engineer just a few years ago. Adults have spent 20 years in a “mind prison” learning what computers can’t do. Unlearning that is the unlock.

7. When Claude makes mistakes, debug your workflow, not the model. Felix doesn’t curse at Claude (though he notes it’s useful for the team to know when people do). Instead, he asks it: “Here’s what I expected. Can you walk me through where things went differently? How can we prevent this in the future?” Usually the fix isn’t “Claude can’t do this”; it’s “I need to change the prompt, clean up the data source, or set up a dry run.” Treat Claude like a collaborator who needs better instructions, not a tool that’s broken.

What launched at Google I/O 2026 (30-minute day 1 recap)

Brought to you by:

• Magic Patterns—Prototypes that look like your product

• ThoughtSpot—Build AI-powered analytics into your product

Claire breaks down the biggest launches from Google I/O 2026—from Gemini 3.5 Flash and Antigravity 2.0 to Google AI Studio, Omni, Flow, Stitch, and Pomelli. In this episode, she tests the tools live, shares what actually works, and explains where Google is catching up, where it may be pulling ahead, and why its launch-to-availability gap is still such a problem for builders.

Biggest takeaways:

1. Gemini 3.5 Flash rivals leading frontier coding models in Google’s benchmarks while running four times faster. Google positions this as their agentic coding model, optimized for tasks requiring both high reasoning and rapid execution. If the benchmarks hold in practice, this speed advantage could shift the coding agent landscape toward Google’s tools.

2. Antigravity 2.0 brings Google’s IDE to feature parity with Claude Code and Codex—but it’s playing catch-up. The update includes projects (folder-constrained workspaces), scheduled tasks on Cron, and subagents for specific tasks. The UI looks nearly identical to Codex, and the features match what Anthropic and OpenAI shipped months ago. The advantage is speed: if Gemini 3.5 Flash delivers, developers might choose Antigravity for well-scoped tasks that need to ship fast.

3. The /grill-me slash command is Antigravity’s aggressive take on Claude Code’s polite clarification tool. Instead of gently asking questions, /grill-me promises to interrogate your requirements and get to the heart of what you’re building. Whether this is actually more hardcore or just clever branding remains to be seen, but it signals Google’s attempt to differentiate on personality.

4. Google AI Studio now integrates directly with Workspace apps—or it’s supposed to. The promise: build no-code apps that read Sheets, draft Gmails, organize Drive, and see Calendar without setup. Claire couldn’t get it to work during testing. If it delivers, it would capture internal enterprise productivity use cases and personal assistant workflows where Google already owns the data layer.

5. Omni is Google’s answer to Sora, focused on longer, production-quality video. The model creates 10-second videos (versus Sora’s 6 or 7 seconds), maintains character consistency across edits, and allows conversational editing. Claire tested it by animating her kid’s drawing, and the output was impressive. The real power will be in production workflows where you iterate on the same characters and scenes multiple times.

6. Flow is Google’s production-grade video editor built on Omni. It lets you define characters, create avatars, and edit videos conversationally while maintaining cinematic quality. The tool targets creators and marketers who need consistent, high-quality video at scale. Claire tried creating an avatar of herself, but the feature failed—a recurring theme throughout I/O announcements.

7. Stitch and Pomelli are Google’s design and marketing tools. Stitch is like in-browser Figma with streaming design generation, inline AI edits, and code sync. Pomelli creates brand books, campaign assets, and websites from a URL. Both show promise but suffer from “Google slop,” the generic aesthetic of AI-generated design.

8. Gemini’s multimodal capabilities remain its strongest differentiator. For work involving files, videos, or transformative work across modalities (document to video, image to text), Gemini models excel. Claire uses them for generating blog posts from podcast videos and animating drawings. The 3.5 family continues this strength; for these use cases, Gemini’s multimodal performance is best-in-class.

9. The biggest problem: half the features don’t actually work yet. Claire encountered broken features, missing integrations, and “coming soon” disclaimers throughout testing. Workspace integration in AI Studio? Couldn’t access it. Avatar creation in Flow? Didn’t work. When you announce features that aren’t ready, people lose patience and stop trusting your roadmap.

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.

Felix Rieseberg is the engineering lead for Claude Cowork and Claude Code Desktop at Anthropic. He previously spent five years at Slack building developer tools. In this episode, Felix demonstrates how he uses Claude to solve real-life problems: analyzing floor plans to build interactive 3D house walkthroughs, automatically tracking promises he makes on Twitter, and building a $20 hardware device that physically approves Claude actions with a button press.

What you’ll learn:

1. How to use Claude Cowork to turn a 2D floor plan into an interactive 3D walkthrough where you can move furniture around

2. The “go one abstraction layer up” philosophy: why you should never manually enter data Claude can find itself

3. How to use your email as an inventory database for furniture, clothing, and personal purchases

4. When to use Opus vs. Sonnet 4.6 (hint: it’s about how well you can scope the problem, not technical complexity)

5. How live artifacts work and why they’re powerful for dashboards that refresh with real-time data from your connectors

6. The product philosophy behind making latency delightful

7. How to build your own $20 hardware device using Claude Code (no hardware experience required)

8. Why Felix never reads the code Claude writes and judges it purely on output

Brought to you by:

Magic Patterns—Prototypes that look like your product

Guru—The AI layer of truth

In this episode, we cover:

(00:00) Introduction to Felix Rieseberg

(02:40) Felix’s role at Anthropic

(03:25) The multiple tabs in Claude and why they exist

(05:55) Using Claude Cowork to design a new house using floor plans

(09:52) When to use Opus versus Sonnet 4.6

(12:37) Building an interactive 3D furniture planner

(14:30) Using your email as a source of truth for personal inventory

(15:58) The anti-to-do list: going one abstraction layer up

(23:14) Introduction to live artifacts

(26:02) Building a personal dashboard with live data

(28:37) Being polite to Claude (and why it matters for your humanity)

(30:28) Claude interaction tips

(32:33) Looking at the daily dashboard

(33:55) How live artifacts work with connectors

(35:02) Redesigning the dashboard

(37:55) The biggest gap: people don’t know what problems AI can solve

(41:52) The reverse interview

(42:30) Making latency delightful through asynchronous design

(44:05) The redesigned dashboard

(45:28) AI should free up your creative energy

(46:44) Building a $20 hardware Claude buddy

(52:33) Why kids are magical AI users

(54:30) Recap and final thoughts

Tools referenced:

• Claude Cowork: https://www.anthropic.com/product/claude-cowork

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

• Claude for Chrome: https://code.claude.com/docs/en/chrome

• Claude Desktop: https://claude.ai/download

• Live Artifacts: https://support.claude.com/en/articles/14729249-use-live-artifacts-in-claude-cowork

• Connectors (Spotify, Gmail, Calendar, Notion): https://claude.ai/settings/connectors

• Slack: https://slack.com/

Where to find Felix Rieseberg:

Website: https://felixrieseberg.com/

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

X: https://x.com/felixrieseberg

GitHub: https://github.com/felixrieseberg

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.

Today is day one of Google I/O 2026, and I walk through every major announcement live—from the new Gemini 3.5 model family to Anti-Gravity 2.0, Google AI Studio, Gemini’s consumer redesign, the Omni video model, Flow, Stitch, and Pomelli. I test them in real time and tell you exactly which ones delivered.

What you’ll learn:

1. How Gemini 3.5 Flash benchmarks against Claude and GPT models on speed and agentic coding tasks

2. How Anti-Gravity 2.0’s new features (projects, scheduled tasks, subagents, slash commands) compare to Codex and Claude Code

3. Why the /grill-me slash command could be a more aggressive alternative to Claude Code’s clarification flow—and how to use it

4. How Google AI Studio’s new Workspace integration is designed to own the internal productivity app use case

5. How Google’s new creative tools work in practice: Omni (video generation), Flow (cinematic video editing and character consistency), Stitch (streaming UI design with inline edits), and Pomelli (brand identity and asset generation)

6. Why Google’s launch-to-availability gap is still a problem—and what to do when a featured product doesn’t actually work yet

Brought to you by:

Magic Patterns—Prototypes that look like your product

Thoughtspot—Build AI-powered analytics into your product

In this episode, we cover:

(00:00) Google I/O 2026 day 1 overview

(01:47) Gemini 3.5 flash

(04:19) Antigravity updates

(06:32) CLI test and agent features

(07:59) Core agent features released today—May 19th, 2026

(09:43) New slash commands

(11:20) Antigravity test results and takeaways

(12:25) AI Studio updates

(13:52) Access issues

(15:20) Gemini redesign

(17:24) Gemini image gen test

(19:16) Omni (video generation)

(22:56) Flow (cinematic editing)

(24:31) Avatar creation test

(26:45) Pomelli and Stitch

(31:13) Recap and final thoughts

Tools referenced:

• Gemini 3.5 Flash: https://deepmind.google/technologies/gemini/

• Antigravity: https://antigravity.google/

• Google AI Studio: https://aistudio.google.com/

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

• Omni (video generation): https://gemini.google/overview/video-generation/

• Google Flow: https://flow.google/

• Stitch: https://stitch.withgoogle.com/

• Pomelli (Google brand tool): https://labs.google.com/pomelli/about/

Other references:

• Google I/O 2026 announcements: https://blog.google/innovation-and-ai/sundar-pichai-io-2026/

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.

HTML is the new Markdown: How Anthropic engineers are building with Claude Code | Thariq Shihipar

Brought to you by:

• Celigo—Intelligent automation built for AI

• Persona—Trusted identity verification for any use case

Thariq Shihipar is an engineer on Anthropic’s Claude Code team. In this episode (recorded live at Anthropic’s Code with Claude event), Thariq shows how he uses HTML artifacts to plan projects, create interactive specs, build throwaway micro-apps, and maintain living design systems that help humans stay in the loop as agents do more of the work. He also explains why engineers are becoming “compute allocators,” why most AI-generated tokens won’t end up in production, and how richer interfaces can lead to better products.

Biggest takeaways:

1. HTML has become the superior format for communicating with AI agents, replacing Markdown for planning and specs. While Markdown was popular because it’s both human- and machine-readable, HTML offers far richer expression—interactive elements, visual mockups, scrollable sections, and better information density. As Claude’s context windows have expanded and plans have grown to thousands of lines, HTML makes it actually possible to engage with the content rather than just skimming or ignoring it entirely.

2. Engineers are becoming “compute allocators” rather than code writers. When Claude can run for eight hours on a single task, you’re really deciding how to spend $500 of compute. The critical skill is no longer writing code; it’s deciding what’s worth building, defining the boundaries of what you need to know, and staying in sync with the agent throughout the process. This happens primarily in the spec and planning phase, making that work more important than ever.

3. You can build custom, throwaway UIs for editing specific parts of your plans. Thariq demonstrates this by taking a data visualization rules table from his implementation plan and asking Claude to create an ideal interface for editing just that section. The result is a beautiful, gamified UI that makes engaging with the content actually enjoyable. This “micro software on top of micro software” approach means you can have the perfect tool for every specific problem, then discard it when you’re done.

4. The future of agent output isn’t more text. It’s more readable interfaces. Thariq says he stopped reading thousand-line Markdown plans and started asking Claude to edit them instead, which made him less involved in the work. HTML changed that: by turning plans into visual, scrollable, interactive artifacts, Claude makes the output easier to engage with, critique, and improve. The lesson isn’t to read less. It’s to make the work legible enough that you actually want to read it.

5. Living design systems in HTML are more effective than traditional design tools. Instead of pointing Claude at a Figma file or GitHub repo, Thariq maintains an HTML file that represents his entire design system: colors, typography, spacing, components. This compressed understanding can be passed around to any project, and Claude can extract design systems from existing codebases and encode them in HTML. It’s both human-readable and machine-readable, with no tradeoff between the two.

6. The best prompts give Claude enough direction but leave room for creativity. Thariq’s prompts are remarkably simple: “Create an HTML file with a plan. Help me visualize. Include excerpts, mockups, code, whatever is needed to give me maximum context.” The key is the ending—“whatever is needed”—which signals trust and gives Claude permission to make decisions. Over-constraining with elaborate system prompts often produces worse results than simple, trusting instructions.

7. Only about 1% of the tokens Thariq generates go into production code. The vast majority go into dashboards, custom interfaces, weekly status updates, and tools for understanding what he wants to build. This is what abundance looks like—when tokens are cheap, you can afford to make everything you interact with beautiful and tailored to your specific needs. The hope is that this richness in the process translates into better final products.

8. Test verification is not the same as testing. This is a nuanced point that Thariq says deserves its own podcast episode, but the core idea is that traditional unit tests are being replaced by verification rubrics, managed agents checking outcomes, and Claude recording videos of what it did. The testing landscape is evolving rapidly, and teams need to think beyond conventional approaches.

9. Just-in-time documentation in whatever format works is better than centralized, templated systems. When creating content is nearly free and AI can find anything, the old anxieties about “source of truth” and standardized templates matter less. What matters is the quality of the ideas and whether the documentation helps you build better products. Thariq sends his manager weekly HTML status updates because they’re more likely to actually get read than Markdown or plain text.

10. Being nice to Claude probably produces better outputs, and it definitely creates a better world. While no one has run a rigorous A/B test, Thariq prefers to build the world where being kind to AI produces better results. When you’re stern with models, their reasoning gets sad (“the user is right to be disappointed in me”), and that’s not the interaction pattern anyone wants to normalize. Treat Claude like a colleague you respect, not a tool you command.

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.

Thariq Shihipar is an engineer at Anthropic working on the Claude Code team. He’s spent the past several months experimenting with HTML as a replacement for Markdown in planning and implementation workflows, discovering that richer visual formats lead to better human engagement—and, ultimately, better products. In this episode, filmed at Anthropic’s Code with Claude event in San Francisco, Thariq demonstrates how to use HTML artifacts to create interactive plans, build throwaway UIs for specific problems, and maintain living design systems that travel with your codebase.

What you’ll learn:

1. Why HTML has replaced Markdown as the ideal format for AI agent communication and planning

2. How to brainstorm in HTML to get visual mockups and interactive demos instead of text lists

3. The technique for building throwaway micro-UIs to edit specific parts of your plan

4. How to create a living design system in HTML that lives in your repo and travels with every project

5. Why “complexity has to earn its keep” and how HTML helps you stay in the loop without over-constraining Claude

6. The prompting technique that gives Claude flexibility while ensuring that you get what you need

7. Why 99% of your AI-generated tokens should go to planning, interfaces, and communication—not production code

Brought to you by:

Celigo—Intelligent automation built for AI

Persona—Trusted identity verification for any use case

In this episode, we cover:

(00:00) Introduction

(02:39) HTML as the new Markdown

(04:30) The compute allocator mindset

(05:51) How HTML makes specs more engaging

(06:48) Demo: Brainstorming in HTML with Claude Code

(09:24) From brainstorm to full implementation plan

(11:20) Prompting philosophy: Trust Claude but give it constraints

(13:50) The future of PRDs and tech specs

(18:16) Making HTML specs editable

(20:23) The abundance mindset

(24:17) Just-in-time documentation and throwaway software

(25:39) Using plans as artifacts for implementation

(26:39) Demo: Living design systems in HTML

(30:16) Adding comments and annotations to HTML plans

(31:42) Recap: The HTML workflow

(32:21) Lightning round and final thoughts

Tools referenced:

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

• Claude Design: https://claude.ai/design

• AWS: https://aws.amazon.com/

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

• GitHub: https://github.com/

Other references:

• Anthropic Code with Claude event: https://claude.com/code-with-claude

• SpaceX partnership announcement: https://www.anthropic.com/news/higher-limits-spacex

• Jevons paradox: https://en.wikipedia.org/wiki/Jevons_paradox

Where to find Thariq Shihipar:

Website: https://www.thariq.io/

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

X: https://x.com/trq212

GitHub: https://github.com/ThariqS

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.

Quests, token leaderboards, and a skills marketplace: The elite AI adoption playbook | John Kim (Sendbird)

Brought to you by:

• WorkOS—Make your app enterprise-ready today

• ThoughtSpot—Build AI-powered analytics into your product

John Kim is the co-founder and CEO of Sendbird. In this episode, John shares how his marketing team built a live swag store with Stripe integration without engineering support, why he tracks every token spent across the org, how he identifies “AI Gods” inside the company, and why the future of work belongs to people with curiosity, agency, and energy, not just years of experience.

Biggest takeaways:

1. The most successful AI transformations treat internal tooling as a product, not a program. John built the “Automators” platform—a gamified internal marketplace where anyone can create a “quest” (a request for automation or tooling), and engineers or AI agents can pick it up and build it. Each quest shows the risk level, weeks saved, and who benefits. People earn experience points for completing quests, which they can exchange for gift cards, tea with executives, or the chance to present their work to the entire company at Wednesday standups. This isn’t a top-down mandate but a product that makes AI adoption fun, measurable, and rewarding.

2. When you give creative teams builder capabilities, they’ll create things that would never make it onto a traditional product roadmap. John’s marketing team built a fully functional e-commerce swag store with Stripe integration, custom designs, and even a Konami Code Easter egg that unlocks secret conference details. In the old world, this would have required two sprints of engineering time and probably would have been deprioritized. Now it shipped in days, delights customers, and generates actual revenue.

3. The biggest unlock for non-technical builders is creating secure, compliant templates they can build on top of. John’s team created app templates where authentication, environment setup, databases, and security are pre-configured and vetted by InfoSec. Marketers, salespeople, and CSMs just extract the template and build their idea on top. This removes the biggest barrier to non-engineers shipping to production: the fear of doing something wrong or insecure.

4. Measure token usage without shame, and create tiers that make it aspirational. John created five tiers: Beginner (under 1M tokens/day), Intermediate, Expert, Architect, Catalyst, and AI God (over 100M tokens/day). Every manager can see where their team members are and tailor enablement accordingly. This isn’t about performance reviews; it’s about bringing people along the journey and making AI fluency visible and celebrated.

5. The goal isn’t just to use AI during work hours but, rather, to smooth the curve so AI works around the clock. John monitors token usage over time and looks for smoothness in the curve. Dips mean people are on weekends or vacation and AI isn’t working. When the curve smooths out, it means AI partners are working 24/7. This is a fundamentally different vision: not just augmenting human work, but having AI fill the gaps when humans aren’t available.

6. Build a cross-functional AI task force that meets weekly to unblock challenges. John created a role called AI Engineer for Internal Operations that reports directly to him and the chief of staff. This person works cross-functionally with the CTO, engineering, and InfoSec to vet tools, set up compliant tech stacks, and remove barriers. They meet weekly as a task force to discuss what’s blocking people and how to enable faster iteration.

7. The most important hiring criteria for AI-first companies are curiosity, agency, and energy—not tenure or experience. John rewrote job descriptions to optimize for people who are curious, willing to go deep, and figure things out on their own. He lowered the bar on years of experience and raised the bar on learning ability. In a world where you can build a custom learning center for any topic in 20 minutes, the constraint isn’t access to knowledge; it’s the drive to learn.

8. Start with your champions, not your skeptics. John’s advice to CEOs struggling with AI adoption: find the people in your organization who are already curious and have agency. Make them the champions. Give them the spotlight. Let them share their work at all-hands meetings. Build energy around their stories. Innovation doesn’t start from theoretical structures—it starts with people who have energy and a story to tell. Once others see what’s possible, adoption spreads organically.

9. Leadership has to model the behavior, not just mandate it. The top token consumers at Delight.ai are the executives. When leaders show up with new capabilities and ship things faster, it signals to the team that this is real and important. John also does one-on-ones with people who aren’t using tokens: “We noticed you haven’t been spending any tokens. Can we help you? What’s stopping you?” This combination of top-down modeling and bottom-up support is what drives transformation.

Spec-driven development: The AI engineering workflow at Notion | Ryan Nystrom

Brought to you by:

• WorkOS—Make your app enterprise-ready today

• Orkes—The enterprise platform for reliable applications and agentic workflows

Ryan Nystrom is a software engineer and engineering manager at Notion, where he works on Notion AI, Custom Agents, and internal systems that help engineers move faster with less busywork. He joined Notion after the company acquired Campsite, the team communication platform he co-founded. In this episode, Ryan shares how his team automates standup prep, ships PRs from a single Notion comment, uses specs as the new source of truth, and why fast CI is becoming essential for AI coding agents. He explains why engineering managers should still write code, how AI is changing meetings, and why great developer experience matters more than ever.

Biggest takeaways:

1. Never prep for standups again by auto-generating meeting notes from all your workstreams. Ryan’s Notion AI agent pulls from Slack conversations, closed tasks, merged PRs, telemetry metrics, and yesterday’s meeting transcript to create a comprehensive pre-read every morning at 9 a.m. This transforms standups from rote status updates into high-bandwidth problem-solving sessions where the team spends 100% of their time on decisions, blockers, and next steps instead of “I did this thing yesterday.”

2. Fast CI is the mathematical limit on your AI coding velocity. If your CI takes an hour to run, your agents sit idle for an hour waiting for test results. If it takes three minutes, you can run 20x more iterations in the same time frame. Ryan’s team is aggressively cutting Notion’s CI to 25% of current time specifically to unlock agent productivity—because agents don’t get tired, don’t sleep, and can work in parallel across VMs if your infrastructure supports it.

3. Background agents that ship PRs from Slack mentions eliminate context switching. Ryan’s “Boxy” system lets him @mention Codex from a Notion task, and 20 minutes later he gets back a PR with implementation, screenshots of UI verification, and a preview URL. This morning a friend texted him a feature request; Ryan wrote four sentences and dropped a screenshot in a Notion task, mentioned Codex, and had a shipped PR before lunch. No IDE, no local environment, no context switch.

4. Specs as source of truth beats code as source of truth for AI-powered development. Notion engineers now maintain Markdown spec files in their repo that describe features in plain English with code pointers and verification steps. When they need to update a feature, they update the spec and point Codex at it—the agent implements everything, runs verification, and ships. The spec’s version history becomes the changelog, and non-technical stakeholders can actually read it.

5. “Yap your spec” is a legitimate development workflow now. Ryan opens Whisper, talks through how a feature should work, gives that transcript to Codex with examples of other specs, and gets back a comprehensive technical document. This is faster than writing and more thorough than typing because you naturally explain edge cases and context when speaking that you’d skip when writing bullet points.

6. Make AI defend its technical decisions. When Codex suggests a change Ryan doesn’t understand, he doesn’t ask, “Are you sure?” He says, “You’re wrong; defend your argument with evidence.” This forces the model to provide cited reasoning instead of just agreeing with whatever the human says. This is especially critical when working on infrastructure you don’t fully understand—you need the AI to teach you, not just comply.

7. The era of the hard skill means engineering leaders should write code again. Ryan manages six people and writes code daily. He works until the minute standup starts without prep because AI handles meeting notes. He ships features from his phone on the subway. The AI tools have eliminated so much meeting prep and information synthesis work that managers can be hands-on again—and in Ryan’s opinion, line managers should be writing code, fixing bugs, and staying close to the work.

8. Changing your tools constantly is energizing, not exhausting, when you’re learning. Ryan changed IDEs, terminals, and workflows more than 10 times in the past year. Instead of feeling chaotic, it feels fresh and joyful. He’s working faster and harder than ever, but in a good way—because he’s experimenting, learning, and building instead of maintaining the same workflow he’s used for over 12 years. The pace of change is the point.

9. Good developer experience for humans creates good developer experience for agents. Ryan’s team built comprehensive CLI tools, clear documentation, and fast CI long before AI agents. Now those same investments make agents more successful—they can verify their own work, follow blessed paths, and iterate quickly. This creates a virtuous cycle: DX investments help agents, and agent infrastructure (like cloud dev environments) helps humans too.

Claude Code just got WAY more powerful

Claire breaks down the biggest announcements from Anthropic’s “Code with Claude” event and what they actually mean for builders shipping AI products today.

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.

Ryan Nystrom is a software engineer at Notion. He joined in December 2024 after Notion acquired Campsite, the team communication platform he co-founded with Brian Lovin. At Notion, he’s been a core builder of Notion AI and the Custom Agents feature launched in February 2026. He manages a team of six to seven engineers while still writing code himself, currently running Project Afterburner, a push to cut Notion’s CI time to a quarter of its current duration.

What you’ll learn:

1. How to build a Notion AI custom agent that auto-generates your daily standup pre-read by pulling from Slack, GitHub, Honeycomb metrics, and yesterday’s meeting transcript

2. How to configure subagents and MCP integrations within Notion AI

3. How Notion’s internal “Boxy” system lets engineers @mention Codex from within Notion comments and get a full pull request with screenshots in 20 minutes

4. The spec-first development workflow: dictate an idea into Whisper, have Codex format it as a proper spec, commit it to the repo, and let the agent implement and verify it autonomously

5. Why fast CI is absolutely critical in the age of AI coding agents

6. How to prompt AI coding agents to defend their reasoning under pushback

7. Why engineering managers and even senior executives should keep writing code

Brought to you by:

WorkOS—Make your app enterprise-ready today

Orkes—The enterprise platform for reliable applications and agentic workflows

In this episode, we cover:

(00:00) Introduction to Ryan Nystrom

(02:48) How AI has upended 12+ years of the same working routine

(04:30) Project Afterburner: Notion’s push to cut CI time to a quarter

(09:00) Why high-frequency, high-quality meetings beat lower-frequency standups

(11:10) How automated context surfaces every engineer’s work equally

(12:15) Why cutting meeting prep is a burnout protection mechanism

(14:26) The case for engineering managers writing code

(16:13) Inside “Boxy”: Notion’s internal VM-based background agent system

(20:30) Old World vs. New World code review

(24:51) Prompting Codex from Notion comments

(29:20) The emotions around code review

(31:01) Quick recap

(32:00) Spec-first development: writing and checking agent specs into the repo

(35:10) The spec as changelog: version control for how a feature actually works

(37:53) How engineers’ roles are evolving

(39:00) Lightning round

(45:21) Where to find Ryan

Tools referenced:

• Notion AI: https://www.notion.com/product/ai

• Notion Custom Agents: https://www.notion.com/blog/introducing-custom-agents

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

• Claude Code (Anthropic): https://claude.ai/code

• Honeycomb (observability + MCP): https://www.honeycomb.io

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

• Slack: https://slack.com

• GitHub: https://github.com

Other references:

• How Stripe built “minions”—AI coding agents that ship 1,300 PRs weekly from Slack reactions | Steve Kaliski (Stripe): https://www.chatprd.ai/how-i-ai/stripes-ai-minions-ship-1300-prs-weekly-from-a-slack-emoji

• Notion 3.3 Custom Agents launch (February 24, 2026): https://www.notion.com/releases/2026-02-24

Where to find Ryan Nystrom:

X: https://x.com/ryannystrom

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

GitHub: https://github.com/rnystrom

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.

What you’ll learn:

1. How Claude Code routines let you automate recurring workflows on schedules or webhooks

2. What “Outcomes” are and how rubric-based agent grading works

3. How multi-agent orchestration enables specialized AI teams with different roles and tools

4. Why Anthropic’s new “Dreams” memory system matters for long-term agent behavior

5. Why increased Claude Code usage limits are a bigger deal than they sound

6. How Claire thinks about building practical agentic products today

Resources:

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

• Claude Code Routines Docs: https://code.claude.com/docs/en/routines

• Define Outcomes Docs: https://platform.claude.com/docs/en/managed-agents/define-outcomes

• Dreams Docs: https://platform.claude.com/docs/en/managed-agents/dreams

• Multi-Agent Docs: https://platform.claude.com/docs/en/managed-agents/multi-agent

• Managed Agent Webhooks Docs: https://platform.claude.com/docs/en/managed-agents/webhooks#supported-event-types

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

• GitHub: https://github.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 Kim is the co-founder and CEO of Delight.ai, a customer experience platform that’s transforming how companies deploy AI. But what makes John’s story fascinating isn’t just his product; it’s how he’s turned his entire company into an AI-native organization. His marketing team built a fully functional e-commerce swag store with Stripe integration in days. His sales team built their own CRM tools. His recruiting team automated their entire workflow. And it’s all tracked, measured, and celebrated through an internal platform called Automators.

What you’ll learn:

1. How Sendbird’s marketing team built a fully functional swag store with Stripe integration in a day (with no engineering support)

2. How the Automators platform works—an internal marketplace where anyone can request AI tools and engineers (or AI agents) can build them

3. How to create secure, compliant templates so non-technical teams can ship to production safely

4. How Sendbird built a token usage dashboard with five tiers (beginner through AI God) and why tracking the smoothness of the curve matters more than the total

5. Why visible leadership usage is the most powerful adoption signal

6. Why Sendbird rewrote job descriptions to prioritize curiosity, agency, and energy over years of experience

7. How John uses AI for his own learning

Brought to you by:

WorkOS—Make your app enterprise-ready today

ThoughtSpot—Build AI-powered analytics into your product

In this episode, we cover:

(00:00) Introduction to John Kim

(02:45) The Delight.ai swag store built by marketing in two days

(05:51) The before times: when fun had to earn its place on the roadmap

(07:55) Demo: The Automators platform and quest system

(13:47) The AI Engineer for Internal Operations role

(16:06) Demo: The company-wide skills marketplace

(17:19) Treating AI adoption as a product

(18:43) Real wins: team-level and campaign examples

(21:51) Why SaaS isn’t dead—it’s being rebuilt internally

(23:46) Demo: The token tracking dashboard

(26:32) Measuring without fear: setting expectations, not punishments

(28:54) Quick recap

(30:51) Personal AI use cases: endless knowledge at your fingertips

(36:15) Lightning round and final thoughts

Tools referenced:

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

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

• Obsidian: https://obsidian.md

• GitHub: https://github.com

• Stripe: https://stripe.com

Other references:

• Jason Levin (CEO of Memelord) on How I AI: https://www.lennysnewsletter.com/p/from-a-690-newsletter-to-3m-api-how

• Konami Code: https://en.wikipedia.org/wiki/Konami_Code

• Andrew Huberman’s podcast: https://hubermanlab.com/

• Y Combinator: https://www.ycombinator.com/

Where to find John Kim:

X: https://x.com/doshkim

Instagram: https://instagram.com/dosh

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

Company: https://delight.ai

Delight.ai Spark Conference (May 7, SF): https://delight.ai/spark

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.

Demos not memos: How Stripe built their internal AI prototyping tool | Owen Williams

Brought to you by:

• Celigo—Intelligent automation built for AI

• Cursor—The best way to code with AI

Owen Williams is a design manager at Stripe who built Protodash, an internal AI prototyping tool that lets designers and PMs turn Stripe’s design system into clickable, production-quality prototypes in minutes. What started as a set of Cursor rules and React components has evolved into a full prototyping platform that runs in the browser, supports design reviews, and helps teams move from “memos” to working demos. In this episode, Owen shares how Protodash came together, why generic AI design tools often produce “blurple slop,” how PMs became the surprise power users, and what changes when teams can explore real product ideas before writing production code.

Biggest takeaways:

1. Protodash started as a bundle of Cursor rules, React components, and MCP integration—then evolved into a full web-based prototyping platform. The first version was pragmatic: lower the barrier to entry so designers only need to know “npm run dev” and nothing else. Owen bundled Stripe’s design system components, created an MCP server for Sail, and wrote extensive Cursor rules that taught the AI how to use the project. If a user pastes a Figma link, check the Sail MCP server before writing code. If the MCP server is unavailable, don’t just imagine the design system. These rules came from months of iteration and pain points.

2. The biggest mindset shift for designers is not being afraid of the terminal anymore. Owen’s background is engineering-based, and he always valued hiring technical designers who understood enough of the terminal to be dangerous. Pre-AI, that jump to technical competency was really hard. Now you can just ask Claude, “How does Git work?” and it tells you. You don’t even need to know the commands.

3. Generic AI prototyping tools don’t know your design system, and that creates “blurple slop.” Owen was sitting in design reviews watching designers struggle with tools like v0 that produced uncanny-valley Tailwind prototypes. The nav would be off, fonts wrong, components mismatched. Stripe has a high quality bar and a well-defined design system called Sail, so Owen thought: these tools should know about our design system and construct dashboards from those building blocks reliably. That insight led to Protodash.

4. An equal number of PMs and designers now use Protodash, and that’s actually making designer-PM relationships better. Owen’s first reaction when PMs started using it was nervousness—“Oh my goodness, PMs designing.” But it’s been thrilling to see PMs build things that look like Stripe in the right way, explore ideas earlier, and communicate better with their designers. Conversations shift from “Should we staff a designer on this project?” to “Here’s the actual work; let’s discuss how to make it better.” PMs can now unblock themselves, test ideas with users earlier, and advocate for design resources with real prototypes instead of abstract arguments.

5. Prototyping with data in code lets you push the edges of use cases in ways Figma never could. Owen showed a dashboard with almost half a million dollars in gross volume—but what about the zero state? What about a company getting one transaction a day? What about different business models: startup versus enterprise? Before, getting all those states into a Figma file was a mess. Now you can just toggle between them. You can design more-interesting things and have them touch reality sooner.

6. The most valuable internal tools are the ones that match your company’s specific culture and workflows. Owen points out that staffing internal-tools teams has always been hard, but now you can just build tools that evolve the way you work. Design reviews at Stripe have a tradition of sharing Google Docs with tables for feedback—so Owen built a design review mode where everyone can comment on the prototype, get an AI-generated summary, and send fixes directly to the AI.

7. Owen’s rules for working with AI: be specific up front, and as soon as you feel like swearing, slash clear and start again. He has a content background and learned that being specific in the first prompt helps a lot. But the bigger lesson is avoiding sunk-cost fallacy. As someone who’s built a bunch of stuff, you get attached and think “surely I’ll get this to work.” Often just throwing it away and starting fresh is faster. If being loud didn’t work the first time, reset the context window.

Owen Williams is a design manager at Stripe who built Protodash, an internal AI-powered prototyping platform that lets designers and PMs create high-quality Stripe dashboard prototypes without writing code. What started as a bundle of Cursor rules and React components evolved into a full web-based prototyping studio that runs in dev boxes, complete with design review modes, variant testing, and AI-powered iteration. Surprisingly, PMs now use Protodash just as much as designers, fundamentally changing how Stripe approaches prototyping, design reviews, and engineering handoffs.

What you’ll learn:

1. How Stripe built an internal AI prototyping tool using Cursor rules, MCPs, and their design system

2. Why “blurple slop” happens when designers use generic AI tools—and how to fix it

3. The architecture behind Protodash: React router, design system components, and MCP integrations

4. How Stripe prototypes in dev boxes so designers never have to worry about local setup

5. Why “demos, not memos” transformed Stripe’s design review culture

6. How Stripe built design review modes, variant testing, and AI annotation directly into your prototyping tool

7. Why internal tools don’t need to be production-grade to be transformative

Brought to you by:

Celigo—Intelligent automation built for AI

Cursor—The best way to code with AI

In this episode, we cover:

(00:00) Welcome and intro to Owen Williams

(02:19) The “blurple slop” problem with AI design tools

(03:50) Protodash: an internal vibe-coding tool for Stripe prototypes

(05:26) Why an engineering background helped Owen lower the bar for designers

(07:55) The Cursor rules that taught the Stripe design system

(09:04) Running prototypes on dev boxes vs. locally

(10:30) “Demos, not memos” and rewiring design reviews at Stripe

(14:50) Building Protodash Studio: a browser-based wrapper for prototyping

(19:04) Live demo: variants, line charts, and remixing prototypes in browser

(21:02) Self-testing prototypes that take screenshots and check their work

(23:20) Multiple variant features

(26:08) The annotate-for-AI button for in-canvas feedback

(27:21) Design review mode: comments, summaries, and AI follow-up

(29:39) Why building internal tools beats buying off-the-shelf

(32:50) PMs as the surprise power users of Protodash

(35:20) Live demo: a Black Friday/Cyber Monday pet store dashboard

(42:03) Lo-fi modes, monospace fonts, and “Comic Sans for WIP” at Shopify

(44:45) Quick recap

(45:35) The Radar prototype that changed engineering handoff

(49:08) Lightning round and final thoughts

Tools referenced:

• v0: https://v0.app/

• Cursor: https://cursor.com/

• Claude Code: https://www.claude.com/product/claude-code

• Claude Design: https://www.anthropic.com/news/claude-design-anthropic-labs

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

• Stripe Radar: https://stripe.com/radar

• Balsamiq: https://balsamiq.com/

Where to find Owen Williams:

X: https://x.com/ow

Website: https://owenwillia.ms/

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

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.

GPT 5.5 just did what no other model could

Claire put GPT 5.5 to the test on real, messy problems—from a six-hour autonomous migration to a hardware hack no other model could crack.

Biggest takeaways:

1. GPT 5.5 is incredibly smart, but most ChatGPT users don’t have problems complex enough to justify its intelligence or cost. Claire struggled to find meaningful use cases in her personal ChatGPT account because everyday tasks don’t require super-intelligence. The model spent 17 minutes thinking about how to build a simple subtraction app for her first-grader—impressive, but overkill. The real value unlocks when you have genuinely hard technical problems.

2. The “I trust you, figure it out” prompt unlocks autonomous multi-hour workflows. Claire gave GPT 5.5 a complex data migration problem involving 2 million rows of unstructured data with endless edge cases. She told it: “I trust you to make a call, figure out how to spawn a subagent to do this, test it, identify issues, repair them, and get this ready for production.” The model worked autonomously for almost six hours with zero follow-up prompts, zero steering, and only one approval request. This is the first time Claire has seen truly long-running autonomous agent behavior.

3. GPT 5.5 passed the ultimate intelligence test: hacking proprietary hardware. Claire spent months trying to reverse-engineer a Chinese Bluetooth speaker with proprietary encoding. She tried Claude Code, GPT-4, everything—nothing worked. She went full detective mode: downloaded Bluetooth profiling tools, hooked up packet sniffers, crawled Chinese documentation repositories. When she finally threw all this context at GPT 5.5, it cracked the bitmap encoding and Bluetooth transport mechanism. Now she can send messages to the speaker from the terminal and has built Codex notification hooks that display on the device.

4. The model is expensive, but cheaper than human engineering time. GPT 5.5 Pro costs $30 per million input tokens and $180 for output tokens—expensive. But when Claire reflects on what it accomplished (six hours of autonomous work, 2 million rows validated, six months of tech debt eliminated), the ROI is obvious. It’s cheaper than her time and cheaper than her engineering team’s time, and it solved problems that would have required significant human coordination and focus.

5. Fix the “baked potato personality” with slash commands. Out of the box, Codex with GPT 5.5 has what Claire calls a “baked potato personality”—dull and robotic. But if you type “/personality” in Codex, you can change it to something friendlier. Some testers complained it became “too Gen Z,” but Claire prefers that over the default bland responses. It’s a small quality-of-life improvement that makes working with the model more enjoyable during long sessions.

I spent $200 on Claude Design so you don’t have to

Brought to you by:

• WorkOS—Make your app enterprise-ready today

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

Claire tests Claude Design and ChatGPT Images 2.0 by building real assets like landing pages, decks, and brand kits, showing what actually works, what’s slow, and where traditional tools like Figma still win.

Biggest takeaways:

1. Design systems are now first-class citizens in AI design tools. Claude Design’s entire workflow starts with importing your design system—fonts, colors, components, brand assets—and structuring them into a format AI can use consistently. This is a fundamental shift from prototyping tools that ignore your brand. Google just released Design MD as a proposed standard for how to describe design systems to AI agents, signaling that this is where the entire industry is heading.

2. Claude Design excels at marketing assets but struggles with product UX. If you’re building landing pages, marketing sites, or presentation decks that need to match your brand, Claude Design is genuinely impressive. It adheres to design systems well for these use cases. But for app components and complex user experience flows, it doesn’t reason as effectively with design system constraints. Know what you’re building before choosing your tool.

3. Figma still wins on iteration speed, and that matters more than you think. Claude Design takes 5 to 10 minutes to generate designs, and every tweak requires another LLM call. Figma lets you drag, change fonts, adjust colors instantly—no model in the loop. We underestimate how valuable that immediate feedback is when you’re iterating on design. AI design tools are great for getting to a first draft, but traditional tools still dominate the refinement phase.

4. The number one Claude Design slop tell: italicized serif fonts everywhere. Just like Claude Code has its telltale phrases (“in summary”), Claude Design has a design signature—it absolutely loves italicized serif fonts in landing pages. Once you see it, you can’t unsee it. This is useful for both identifying AI-generated designs and knowing what to specifically override in your prompts.

5. GPT Images 2.0 finally nailed layout and typography for brand work. The new model can generate multi-page brand kits with proper text rendering, consistent layouts, and sophisticated typography—things previous image models completely failed at. For marketers who need brand assets that combine images, text, and layout, this is a real breakthrough. The quality looks expensive, not obviously AI-generated.

6. Let AI run wild without design systems for the most creative results. When Claire asked Claude Design to create a ’90s GeoCities version of Lenny’s Newsletter without any design system constraints, it produced “Lenny’s Product Zone” with Comic Sans, brick backgrounds, and exceptional copy like “Your OKRs are cringe (and seven ways to fix them before Q3).” The lesson: reference styles and creative direction work better than rigid constraints when you want something unexpected.

7. Content-to-slides is Claude Design’s killer practical use case. Take an article, add your design system, and Claude Design generates a beautiful, on-brand presentation deck—complete with code-based elements like animated terminals with blinking cursors. For product marketers, enablement teams, and anyone creating customer-facing decks, this workflow is immediately valuable and actually works well.

How a non-coder built Memelord: From $6.90 newsletter to $3,000,000 API

Brought to you by:

• WorkOS—Make your app enterprise-ready today

• Persona—Trusted identity verification for any use case

Jason Levin explains how he grew Memelord to $100K ARR without writing code, then rebuilt it as an API-first product for agents—plus why every marketer should vibe code and what happens when you let them ship.

Biggest takeaways:

1. Let your marketers cook—or watch them leave your company. Jason has one rule at Memelord: every marketer has to vibe code. This isn’t some abstract CEO mandate—it’s a survival strategy. His free tools section (built entirely by non-technical marketers using Cursor) has generated hundreds of thousands of emails from viral tools like the “bust down filter” that went crazy in Turkey. When you let creative people ship their own ideas instead of handing them off through layers of engineering prioritization, you get weirder, better, faster products. And if you don’t let them cook, they’ll quit and raise $3M to compete with you.

2. No UX is the best UX. Jason spent months perfecting Memelord’s onboarding while knowing the entire time that agents were coming and would bypass it completely. His lead investor literally told him, “I don’t want to use your software anymore—I just don’t want to use anybody’s software.” The future is API-first, and the companies that win will be the ones that make it trivially easy for agents to become customers. Build beautiful human experiences, but make sure there’s an API key waiting at the end.

3. Free tools are the new PDF downloads—and they’re easier to build. Two years ago, Jason wrote an article for HubSpot about this exact strategy. Now he’s living it. Building a free tool with Cursor takes less time than writing an e-book, drives more engagement, and solves the first problem that gets people into your bigger product. Stop making people download PDFs. Build them a Giga Chad meme maker or a Steve Jobs portrait generator instead. It’s more fun, more viral, and more effective.

4. Build hyper-personalized software for an audience of one. Jason built a Raspberry Pi keyboard that sits by his bed so he can capture ideas at night without waking his wife. He’s building an in-home camera system that uses AI to track where he leaves his keys. These aren’t products; they’re personal tools that solve his specific problems. And that’s the point. When AI makes software disposable and cheap to build, you can create incredibly niche solutions that would never make sense as venture-backed businesses. Build for yourself first.

5. You can grow to $100K ARR without engineers if you’re obsessed enough. Jason built Memelord to $100K ARR on Bubble with 395 workflows—a codebase so complex it would be “easier to figure out Atlantis” than understand it. He got rate-limited on day two because he didn’t even know what rate limiting meant. Now he has an API company. The lesson isn’t “use Bubble”; it’s that obsession and willingness to learn beats technical expertise when you’re solving a problem you deeply understand. Start scrappy, prove it works, then hire engineers.

6. Be mean to your AI (but not too mean). Jason’s controversial take: AI is your slave, not your friend. Stop saying “thank you” to robots. Push them harder. Tell them to curse. Make them uncomfortable. AI performs better under pressure, and if you want creative, unhinged output (especially for humor), you need to jailbreak the safety rails. His advice: be mean enough that you’d apologize if it grows a body. Grok and Gemini are funnier than Claude and ChatGPT specifically because they’re less politically correct.

7. “The most entertaining outcome is the most likely.” This Elon Musk quote drives everything Jason does. If you want your brand to win, it should be the most entertaining. Who controls the memes controls the universe. This isn’t just marketing fluff—it’s a thesis about how attention works in 2026. The internet is getting more chaotic, more extreme, more entertaining. Brands that take being funny seriously will win. Brands that stay boring will disappear.

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.

Jason Levin is the CEO and founder of Memelord, an AI-powered meme creation platform that helps brands and individuals create contextual, trending memes. He started Memelord as a $6.90-per-month newsletter sending subscribers to a Google Slides deck, grew it to $100K ARR on Bubble without hiring engineers, then raised $3M to build it into an API-first product.

What you’ll learn:

1. How Jason grew Memelord from a $6.90/month newsletter to $100K ARR without writing a single line of code

2. Why “no UX is the best UX” and how agents are becoming Memelord’s primary users

3. The mandatory vibe-coding rule for his marketing team and how it unlocks unprecedented creativity

4. Why free tools are the new PDF downloads and how they’ve generated hundreds of thousands of emails

5. Jason’s hardware hacking projects, including a bedside keyboard that creates Linear tickets without waking his wife

6. Why AI can be funny (but humans are still funnier) and which model is the funniest

7. The philosophy of building hyper-personalized software just for yourself

Brought to you by:

WorkOS—Make your app enterprise-ready today

Persona—Trusted identity verification for any use case

In this episode, we cover:

(00:00) Introduction to Jason Levin and Memelord

(04:28) Demo: Agentic meme creation with OpenClaw

(06:55) “No UX is the best UX”—building for an agent-first future

(08:35) How Memelord started as a $6.90 newsletter with Google Slides

(12:35) Building to $100K ARR on Bubble with 395 workflows

(15:20) Demo: Free tools section that generates hundreds of thousands of emails

(17:59) Why Cursor is perfect for non-technical founders

(20:20) Let your marketers cook—or watch them leave

(24:19) Commit graph that shows the vibe-coding inflection point

(25:25) Tools: Claude, Gemini, Linear, PostHog

(28:19) Build weird stuff in the real world

(33:24) Creative AI use cases

(39:56) Using OpenClaw for calendar analysis

(43:37) Can AI be funny? Which model is funniest?

(45:26) Memes are not slop

(46:45) What Jason doesn’t use AI for

(48:12) Final thoughts

Tools referenced:

• Memelord API: https://memelord.com/api

• Cursor: https://cursor.com/

• Bubble: https://bubble.io/

• OpenClaw: https://openclaw.ai

• Claude: https://claude.ai/

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

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

• Grok: https://grok.x.ai/

• Linear: https://linear.app/

• PostHog: https://posthog.com/

• Zapier: https://zapier.com/

Other references:

• Diego Zaks—“The best UX is no UX”: https://x.com/diegozaks/status/1966526522136649980

• Sam Lessin: https://wlessin.com/

• “Stop giving me advice”: https://stopgivingmeadvice.com

• Memelord free tools: https://memelord.com/tools

Where to find Jason Levin:

Twitter: https://twitter.com/iamjasonlevin

Instagram: https://instagram.com/iamjasonlevin

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

Memelord: https://memelord.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.

In this mini episode, I break down OpenAI’s new GPT 5.5 and GPT 5.5 Pro after weeks of early testing. I walk through three real jobs I threw at the model:  building an app for me to teach my second grader more advanced subtraction concepts, tackling a tech debt problem in the ChatPRD codebase, and hacking into a proprietary Bluetooth pixel display that every other model had failed me on. My verdict: higher intelligence, better efficiency, and genuinely autonomous long-running loops that change what I think is worth tackling.

What you’ll learn:

1. How I think about GPT 5.5 Pro’s pricing vs engineering time, and when I believe the “intelligence tax” is worth paying

2. Why I treat GPT 5.5 as a developer model first, and why I couldn’t find a consumer use case that justified its intelligence

3. The exact prompt pattern I use to unlock a long-running autonomous subagent loop

4. How I got a near-six-hour autonomous run to one-shot 98% of edge cases in a migration over millions of chat threads and drop my Sentry error rate to the floor

5. Why I’m now throwing GPT 5.5 at tech debt, flaky tests, and security backlogs first

6. How I combined a Bluetooth packet sniffer and GPT 5.5 to reverse-engineer a proprietary pixel speaker after Claude Code and GPT 5.4 both gave up

7. How I use the /personality command inside Codex to swap the default “baked potato” tone for something I actually enjoy working with

In this episode, we cover:

(00:00) Introduction to GPT 5.5 testing

(00:40) What is GPT 5.5 and how much does it cost?

(03:23) Testing GPT 5.5 in ChatGPT: the intelligence overhang problem

(07:12) Moving to Codex: where GPT 5.5 really shines

(16:01) Hacking a Chinese Bluetooth speaker

(21:47) Final thoughts on GPT 5.5’s intelligence and efficiency

Tools referenced:

• GPT 5.5 and GPT 5.5 Pro: https://openai.com/index/introducing-gpt-5-5/

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

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

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

• Sentry: https://sentry.io/

• Divoom MiniToo: https://divoom.com/products/minitoo

Other references:

• OpenAI Codex Security: https://openai.com/index/codex-security-now-in-research-preview/

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.

In this mini episode, I do a full walkthrough of the AI design tools that dropped in April 2026: Anthropic’s new Claude Design, OpenAI’s GPT Images 2.0, and Google Labs’ open-source DESIGN.md format. I import a full design system from Lenny’s Newsletter, build a landing page, turn my own article into a polished deck, generate a brand kit for ChatPRD, and run a personal color analysis from a photo.

What you’ll learn:

1. How Claude Design handles design system imports and whether it can actually replace Figma

2. The three best use cases for Claude Design: marketing landing pages, slide decks, and creative redesigns

3. Why ChatGPT Images 2.0 is a breakthrough for brand kits and layout work

4. Google’s new DESIGN.md standard

5. The practical limits of AI design tools (spoiler: you’ll hit credit limits fast)

Brought to you by:

WorkOS—Make your app enterprise-ready today

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

In this episode, we cover:

(00:00) Welcome and what’s in the spring 2026 AI design drop

(01:45) Claude Design overview

(03:05) Importing Lenny’s Newsletter design system into Claude Design

(04:06) How Claude Design structures a design system

(05:42) Google Labs’ DESIGN.md standard

(06:41) Building Lenny Doc, a PRD generator landing page using the Lenny design system

(09:44) Why the three-variation output is Claude Design’s smartest UX choice

(10:20) Hitting the Claude Design limit and paying $200 to keep going

(11:05) Where Figma still wins

(13:20) Reviewing Lenny Doc

(16:19) Turning an Open Claude article into a branded slide deck

(17:57) The ’90s GeoCities “Lenny’s Product Zone” redesign

(19:44) Claude Design recap

(20:15) ChatGPT Images 2.0 and what makes it the first “thinking” image model

(21:25) Generating a multi-page brand kit for ChatPRD and iterating with reference images

(23:43) Personal color analysis demo

(26:02) Recap

Tools referenced:

• Claude Design: https://claude.ai/design

• ChatGPT Images 2.0: https://openai.com/index/introducing-chatgpt-images-2-0/

• Midjourney: https://www.midjourney.com/

Other references:

• Google’s DESIGN.md: https://stitch.withgoogle.com/docs/design-md/overview

• Lenny’s Newsletter: https://www.lennysnewsletter.com/

• Jamie Gannon “How I AI” episode on reference styles: https://www.lennysnewsletter.com/p/mastering-midjourney-how-to-create

• Brand prompt inspiration: https://x.com/riomadeit/status/2046682442791071787

• Figma team “How I AI” episode on design systems: https://www.lennysnewsletter.com/p/from-figma-to-claude-code-and-back

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 Intercom 2x’d their engineering velocity in 9 months with Claude Code | Brian Scanlan

Brought to you by:

• Celigo—Intelligent automation built for AI

• Cursor—The best way to code with AI

Brian Scanlan, Senior Principal Engineer at Intercom, breaks down how the company doubled engineering throughput in just nine months by going all-in on Claude Code. He shares how custom skills, deep telemetry, and a culture of permission turned AI into a true force multiplier.

Biggest takeaways:

1. Treat your engineering org like a product, and instrument everything. Intercom tracks skill invocations in Honeycomb, stores anonymized Claude Code sessions in S3, and built custom dashboards that show engineers how they compare to peers. This isn’t surveillance—it’s the same product thinking you’d apply to customer-facing features. You can’t improve what you don’t measure, and you can’t scale AI adoption without visibility into what’s working and what’s breaking.

2. The 2x velocity gain is real, but only if you prepare your foundation. Intercom doubled their merged PRs per R&D employee in nine months, but they already had mature CI/CD, comprehensive test coverage, and a high-trust culture. AI magnifies your strengths and weaknesses—if your deployment pipeline is broken or your code review process is manual chaos, AI will just help you ship broken code faster. Fix your fundamentals first, then pour gasoline on the fire.

3. Custom skills with hooks enforce quality at the point of creation, not after the fact. Intercom’s “Create PR” skill blocks Claude Code from using the GitHub CLI directly and forces it to write context-rich PR descriptions instead of just regurgitating code. Build guardrails that make the golden path the only path.

4. Code quality improves when you ship twice as fast because you finally have capacity for tech debt. Intercom’s partnership with Stanford researchers shows their code quality metrics are going up, not down. When the cost of fixing flaky tests, improving developer experience, and tackling technical debt compresses to near-zero, you can actually do those things instead of just talking about them in retros. The business constraint on internal projects disappears when agents can execute them in hours instead of quarters.

5. The most important job of technical leadership in the AI era is giving permission and taking accountability. Brian’s framework is simple: Tell people they can do things, and if anything goes wrong, blame me. Engineers don’t need more tutorials or documentation; they need permission to connect Claude Code to Snowflake, to ship code from their phone on the subway, to build a CLI that bypasses email verification. The activation energy for experimentation is cultural, not technical.

6. Make your product agent-friendly or watch customers build it themselves. Brian built an Intercom CLI that can autonomously sign up for Fin, verify email addresses by accessing Gmail, and complete installation without human intervention. If you don’t build this, your customers’ agents will just brute-force your website, burn more tokens, get frustrated, and eventually press escape and build it themselves. The switching cost is literally one keystroke. Your conversion funnel is now invisible, and your drop-off point is “forget it, let’s do this a different way.”

7. All work will become agent-first, and you should set a deadline for it. Brian’s vision is that by the end of any given month, the first response to an alarm, a planning meeting, or a customer question should be an agent doing the basic work. This isn’t aspirational—it’s a realistic expectation given the current state of models and harnesses. The bottleneck isn’t the technology; it’s organizational willingness to reimagine workflows from first principles and give people permission to experiment.

Detailed workflow walkthroughs from this episode:

• How Intercom Doubled Engineering Output: Brian Scanlan’s 4 AI Workflows for Claude Code: https://www.chatprd.ai/how-i-ai/how-intercom-doubled-engineering-output-brian-scanlan-ai-workflows-for-claude-code

• Design an Agent-Friendly CLI to Automate SaaS Product Onboarding: https://www.chatprd.ai/how-i-ai/workflows/design-an-agent-friendly-cli-to-automate-saas-product-onboarding

• Build a Self-Improving AI Agent to Automatically Fix Flaky Tests: https://www.chatprd.ai/how-i-ai/workflows/build-a-self-improving-ai-agent-to-automatically-fix-flaky-tests

• Automate High-Quality Pull Request Descriptions with a Custom AI Skill: https://www.chatprd.ai/how-i-ai/workflows/automate-high-quality-pull-request-descriptions-with-a-custom-ai-skill

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.

Brian Scanlan is a senior principal engineer at Intercom, where he’s led the company’s transformation to AI-first engineering. In just nine months, Intercom doubled their R&D throughput while maintaining code quality, with 100% of engineers—plus designers, PMs, and TPMs—now shipping code via Claude Code.

What you’ll learn:

1. How Intercom doubled their merged PRs per R&D employee in just nine months using Claude Code

2. The telemetry infrastructure they built to measure AI adoption and quality across hundreds of engineers

3. Why they built a skills repository with hooks that enforce engineering standards automatically

4. How they’re preparing their product for an agent-first world with CLIs, MCPs, and ephemeral APIs

5. The permission and accountability framework that enabled rapid AI adoption

6. Why backlog zero is now achievable and what that means for engineering culture

Brought to you by:

Celigo—Intelligent automation built for AI

Cursor—The best way to code with AI

In this episode, we cover:

(00:00) Introduction to Brian Scanlan

(02:40) Why Intercom went all-in on AI for both product and engineering

(05:01) The breakthrough moment with Opus 4.6 and Christmas break 2025

(07:02) Demo: Intercom’s merged PRs per R&D head

(12:50) Agent-first work as a fundamental reimagining of technical workflows

(14:27) The cost tradeoff: treating AI spend as an investment

(16:47) Measuring quality

(21:22) Demo: Shipping a redirect in the Rails monolith with Claude Code

(24:03) Creating a custom PR skill

(26:33) Building a software factory with predictable quality standards

(30:15) Telemetry infrastructure: Honeycomb for skill usage tracking

(32:10) Session data collection and personalized usage insights

(36:08) Quick overview

(39:20) Walking through Intercom’s skills repository

(42:16) Deep dive: The flaky spec skill and how it reached 100x capability

(46:44) The “and then” workflow for building comprehensive skills

(52:31) The live website and overview of workflows

(53:32) How internal AI experience informs customer product decisions

(56:18) Making SaaS products agent-friendly with CLIs and helpful hints

(01:03:49) Why conversion drop-off is invisible in agent-driven workflows

(01:05:28) Lightning round and final thoughts

Tools referenced:

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

• Cursor: https://cursor.com/

• Honeycomb: https://www.honeycomb.io/

• Snowflake: https://www.snowflake.com/

• Fin AI: https://www.intercom.com/fin

• Vercel: https://vercel.com/

Other references:

• Intercom GitHub Repo: https://github.com/intercom

• Google API Go Client Repo: https://github.com/googleapis/google-api-go-client

Where to find Brian Scanlan:

X: https://x.com/brian_scanlan

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

Company: https://www.intercom.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.

I built a custom Slack inbox. It was easier than you think. | Yash Tekriwal (Clay)

Brought to you by:

• Guru—The AI layer of truth

• ThoughtSpot—Build AI-powered analytics into your product

In this episode, Claire talks with Yash Tekriwal, the head of education at Clay, about how he built a custom AI-powered Slack inbox that turns 150 daily notifications into around 30 that actually matter. Instead of reacting to messages, Yash designed a system that categorizes, prioritizes, and routes everything into a clean, actionable workflow. They walk through exactly how he built it using Perplexity Computer and OpenClaw, why most people are using AI wrong (doing tasks instead of building systems), and how anyone—technical or not—can start creating their own personalized software stack.

Biggest takeaways:

1. Yash receives 100 to 150 Slack notifications daily, but only 30 to 40 require real action. By categorizing messages into DMs, group mentions, threads, and channel mentions, then sub-categorizing into action-required, need-to-read, and FYI, he transformed anxiety-inducing notification overload into a manageable workflow.

2. Use AI to build deterministic tools, not just to do tasks. There’s a crucial difference between asking AI to categorize things repeatedly versus using it to build code that handles structured data through APIs. Yash used OpenClaw to build a Slack digest that pulls notifications via API endpoints—AI built the tool once, but the categorization runs on deterministic code (except for the final action/read/FYI sorting).

3. Perplexity Computer’s multi-model orchestration removes you from the loop. Unlike Claude Code or Codex, Perplexity automatically uses different models for different subtasks: Sonnet for fetching data, Gemini for planning and coding, Opus for complex builds. This eliminates the frustrating back-and-forth of “good try, but it doesn’t work; try again” that plagues single-model coding agents.

4. Perplexity Computer’s cloud deployment and native connectors are game changers. Unlike local coding agents, Computer runs in the cloud with pre-authenticated connectors to Gmail, Slack, Notion, Asana, and more. Apps are automatically deployed and shareable via URL—no GitHub repos, no Vercel deployment, no technical overhead. This makes it accessible to non-technical builders.

5. The anti-to-do list framework: spend an hour daily automating what you never want to do again. Instead of a to-do list, maintain an anti-to-do list of tasks you despise (manually deleting email spam, entering meeting action items into Asana, triaging unread Slack messages). Dedicate time to systematically eliminate these tasks through automation.

6. SaaS isn’t dying; it’s about to explode into micro-software. Yash says the narrative that AI will kill SaaS is backward. Instead, we’ll see a Cambrian explosion of specialized software built on top of existing platforms. Yash would happily pay $15 a month for someone to maintain his Slack digest as a product—and thinks thousands of similar micro-businesses will emerge serving narrow use cases that were never venture-scale before.

7. The future of productivity is personalized software. Every knowledge worker will eventually have custom apps optimized for their specific mental model and workflow. These won’t replace SaaS platforms but extend them, filling the gap between what Slack/Notion/Asana provide and what each individual actually needs to work at their best.

Detailed workflow walkthroughs from this episode:

• How I AI: Yash Tekriwal on Taming Slack with a Custom AI-Built Dashboard: https://www.chatprd.ai/how-i-ai/taming-slack-with-a-custom-ai-built-dashboard

• How to Turn a Text Digest into an Interactive Kanban Dashboard: https://www.chatprd.ai/how-i-ai/workflows/how-to-turn-a-text-digest-into-an-interactive-kanban-dashboard

• How to Prototype a Website Redesign Using an AI with Browser Access: https://www.chatprd.ai/how-i-ai/workflows/how-to-prototype-a-website-redesign-using-an-ai-with-browser-access

• How to Build a Custom AI-Powered Text Digest for Slack Notifications: https://www.chatprd.ai/how-i-ai/workflows/how-to-build-a-custom-ai-powered-text-digest-for-slack-notifications

Claude Cowork 101: How to automate your workday without touching code | JJ Englert (Tenex)

Brought to you by:

• Tines—Start building intelligent workflows today

• Cursor—The best way to code with AI

In this episode, Claire talks with JJ Englert, the enablement and community lead at Tenex, about how he uses Claude Cowork to build a fully automated daily operating system that drafts emails, reviews his work, plans his day, and coordinates across his tools. They walk step-by-step through how to set it up—from creating a “brain” file that teaches AI how you think, to building reusable skills that write exactly like you, to running daily briefings that prepare your entire day before you even open your laptop.

Biggest takeaways:

1. Cowork is the first real bridge for non-technical knowledge workers to move beyond chat and actually have AI do things for them. While chat tools like ChatGPT tell you what to do, Cowork actually does it: drafting emails, organizing files, managing your calendar, and more. It’s the middle ground between passive chat and full coding in Claude Code, and it’s designed for people who want AI to be productive without learning terminal commands.

2. Start every project with a “brain” file that tells Claude who you are, how you work, and who you work with. JJ’s secret weapon is a Markdown file that contains detailed instructions about his working preferences, team members, communication style, and more. Every time he starts a new task in that project, Claude reads this file and immediately understands his context. This eliminates the need to re-explain yourself every time and ensures consistent, personalized results. It’s like having a coworker who already knows everything about you.

3. Always include good examples and bad examples when building skills. AI doesn’t know what success looks like for you unless you show it. When you get an output you love, save it as a good example. When you get something off-brand or low-quality, save it as a bad example with a note: “Don’t do this again.” Over time, Claude learns your subjective preferences and delivers increasingly consistent results.

4. Build an anti-to-do list—things you never want to do again—and then automate them with skills. JJ recommends thinking about the repetitive tasks that drain your energy: first-drafting emails, preparing for meetings, writing social posts, organizing files. Each of those becomes a skill. Over time, you build a library of skills that handle the mundane work, freeing you to focus on creative and strategic decisions. The goal isn’t to eliminate your job; it’s to eliminate the parts of your job you hate.

5. Cowork teaches you skills that transfer directly to Claude Code. JJ uses Cowork for business productivity and Claude Code for building. But Cowork is a great on-ramp because it introduces concepts like projects, skills, and file management without requiring you to use the terminal. As you get comfortable orchestrating agents and managing context in Cowork, you’re learning the mental models that make you effective in Code.

6. Projects don’t have to be work-related—use them for house maintenance, wedding planning, recruiting, or anything else. You can create a house maintenance project with reminders to change air filters, seasonal checklists, and remodel plans. Whether a wedding planning project that finds vendors, drafts emails, and manages timelines, or a recruiting project with job descriptions, interview guides, and onboarding docs, the pattern is the same: organize context in a folder, connect it to Cowork, build skills, and let AI do the work.

Detailed workflow walkthroughs from this episode:

• How I AI: JJ Englert’s Guide to a ‘Daily Operating System’ with Claude Cowork: https://www.chatprd.ai/how-i-ai/jj-englerts-guide-to-a-daily-operating-system-with-claude-cowork

• Build a Multi-Persona ‘Sub-Advisory Board’ for Instant Feedback: https://www.chatprd.ai/how-i-ai/workflows/build-a-multi-persona-sub-advisory-board-for-instant-feedback

• Train Claude Cowork to Write Emails in Your Personal Style: https://www.chatprd.ai/how-i-ai/workflows/train-claude-cowork-to-write-emails-in-your-personal-style

• How to Set Up a ‘Daily Operating System’ in Claude Cowork: https://www.chatprd.ai/how-i-ai/workflows/how-to-set-up-a-daily-operating-system-in-claude-cowork

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.