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.

JJ Englert leads community enablement at Tenex. In this episode, JJ provides a complete zero-to-one tutorial on Claude Cowork, Anthropic’s desktop tool that sits between simple chat and full terminal-based coding.

What you’ll learn:

1. How to create your first Claude Cowork project by connecting a folder on your computer and building context over time

2. The “brain” file strategy: how to create a preferences document that Claude reads every time to understand who you are and how you work

3. Why one-click connectors to Gmail, Slack, Notion, and Google Calendar unlock AI that actually does work instead of just suggesting it

4. How to analyze your sent emails to build a writing skill that perfectly matches your tone and style

5. The sub-advisory-board technique: spinning up three AI agents with different personas to review your work from multiple perspectives

6. How to set permissions for each connector so Claude only drafts (never sends) or always asks before taking action

7. The scheduled-task workflow that creates a morning debrief by reading your email, Slack, and calendar every day at 7:30 a.m.

8. Why projects with shared memory beat individual chat threads for consistent, high-quality AI outputs

Brought to you by:

Tines—Start building intelligent workflows today

Cursor—The best way to code with AI

In this episode, we cover:

(00:00) Introduction to JJ Englert

(02:48) What Cowork is and who it’s for

(05:49) Getting started: Opening the Cowork tab in Claude Desktop

(07:04) Understanding projects as folders on your computer

(07:54) Creating your “brain” file, with working preferences and context

(10:24) Demo: Building a daily operating system project from scratch

(12:18) How to prompt Cowork when starting a new project

(14:54) Understanding the project interface and shared memory

(18:37) Setting up connectors to Gmail, Slack, Google Calendar, and other tools

(21:00) Using connectors to analyze your emails and build personalized writing skills

(24:21) Creating a thinking-partner skill for decision support

(26:18) Cowork vs. OpenClaw

(27:18) Building a sub-advisory skill with multiple AI personas for feedback

(34:03) Advanced skill example: Multi-step newsletter creation with research and evaluation

(36:08) Setting up scheduled tasks for morning debriefs

(37:57) Going beyond one-off tasks with AI

(41:00) Progressive trust and the tradeoff of information for productivity

(44:08) Different use cases beyond work productivity

(46:08) Lightning round

Tools referenced:

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

• Wispr Flow: https://whisperflow.ai/

• Monologue: https://www.monologue.to/

• Domo: https://www.domo.com/

• Pencil.dev: https://pencil.dev/

• Remotion: https://www.remotion.dev/

• Obsidian: https://obsidian.md/

• OpenClaw: https://openclaw.ai/

• Notion: https://notion.so/

Other references:

• Get Started with Claude Cowork: https://support.claude.com/en/articles/13345190-get-started-with-cowork

Where to find JJ Englert:

YouTube: https://www.youtube.com/channel/UCv2ovDhYVtlJw4QMidLFP8Q

X: https://twitter.com/jjenglert

LinkedIn: https://www.linkedin.com/in/jj-englert-a08836a6/

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.

Yash Tekriwal is the head of education at Clay. A self-described hyper-optimizer, Yash has built multiple custom productivity applications using Perplexity Computer and OpenClaw to manage his overwhelming daily workflow—including a Slack digest system that categorizes over 150 daily notifications into actionable priorities, and a consolidated news/email/Slack dashboard that serves as his personal command center.

What you’ll learn:

1. How Yash built a custom Slack digest that categorizes 150+ daily notifications into action-required, need-to-read, and FYI buckets

2. Why Perplexity Computer beats Claude Code and Codex for building personal productivity apps

3. His “anti-to-do list” framework: spending an hour daily automating tasks you never want to do again

4. How to use AI for deterministic tasks (APIs, structured data) vs. subjective tasks (categorization, summarization)

5. Why the SaaS apocalypse narrative is wrong—and why we’re about to see an explosion of micro-software

6. How his team uses Perplexity Computer to prototype design systems and communicate with cross-functional partners

Brought to you by:

Guru—The AI layer of truth

ThoughtSpot—Build AI-powered analytics into your product

In this episode, we cover:

(00:00) Introduction to Yash

(02:38) The burden of 150 daily Slack notifications

(05:45) When to use AI for tasks vs. building deterministic code

(06:38) Building the Slack digest with OpenClaw

(11:33) Introducing Perplexity Computer and the visual dashboard

(14:28) Three reasons Perplexity Computer beats Claude Code

(16:14) Using connectors to automate meeting follow-ups across Notion and Asana

(18:21) The Kanban-style Slack dashboard

(20:15) The long tail of customer requests and the future of micro-software

(24:09) The anti-to-do list framework

(26:21) Building a consolidated news, email, and Slack digest

(29:48) How Perplexity Computer handles authentication and deployment

(31:46) Team use case: Prototyping persona-based learning journeys for Clay University

(35:49) Lightning round and final thoughts

Tools referenced:

• Perplexity Computer: https://www.perplexity.ai/computer/new

• OpenClaw: https://openclaw.ai/

• Discord: https://discord.com/

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

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

• Asana: https://asana.com/

• Airtable: https://airtable.com/

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

• Vercel: https://vercel.com/

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

Other references:

• Slack: https://slack.com/

• Notion: https://www.notion.so/

• Superhuman: https://superhuman.com/

• Clay University: https://www.clay.com/university

• Kanban boards: https://en.wikipedia.org/wiki/Kanban_board

Where to find Yash Tekriwal:

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

X: https://x.com/yash_tek

Company: https://www.clay.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 gave Claude Code our entire codebase. Our customers noticed. | Al Chen (Galileo)

Brought to you by:

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

• Tines—Start building intelligent workflows today

Al Chen is a field engineer at Galileo who works directly with enterprise customers asking highly technical questions. In this episode, Claire talks with Al about how he uses Claude Code to query Galileo’s entire codebase across 15 repositories, combine it with Confluence and Slack, and deliver accurate, real-time answers without relying on documentation or constantly pinging engineering. They cover why code is often a better source of truth than docs, how to turn customer questions into scalable knowledge, and how AI is changing what customer-facing teams can do.

Biggest takeaways:

1. Write a script to pull the latest code from all repos daily—and let Claude Code write it. Al uses a 16-line script (written entirely by Claude Code) that pulls the latest main branch from all 15 repositories every morning. This ensures that he’s always querying current code instead of outdated information, solving the “docs are stale” problem that plagues most technical support teams.

2. Maintain a “customer quirks” page to make AI answers customer-specific. Al keeps a Confluence page listing each enterprise customer’s unique deployment requirements: how they handle secrets, namespaces, encryption, air-gapped environments. His Claude Code custom commands reference this page first, generating highly tailored deployment instructions instead of generic answers anyone could Google.

3. Combine code repositories with Confluence MCP for maximum context. Al’s custom Claude Code commands first check Confluence for deployment documentation, then query the code repositories if needed. This multi-source approach means Claude Code pulls from official docs, tribal knowledge, and actual implementation—delivering answers no single source could provide.

4. Your code is better documentation than your docs. Al realized public documentation couldn’t answer his enterprise customers’ detailed technical questions. By pulling all 15 of Galileo’s repositories into VS Code and querying them with Claude Code, he can now answer questions about how services cascade together, how features actually work, and deployment specifics that aren’t captured anywhere else.

5. Turn Slack support threads into knowledge base articles automatically. Using Pylon, Al converts detailed customer conversations into abstracted help articles with one click. These articles are more in-depth and current than official docs because they’re based on real customer questions and don’t require the overhead of PR reviews and approval processes.

6. Reduce engineering interruptions to near-zero by self-serving answers. Before this system, Al constantly pinged engineering with customer questions, creating frustration on both sides. Now he queries the code directly, only reaching out to validate answers or when Claude Code can’t find information (usually because it exists only in meeting notes or hallway conversations).

7. The human value-add is making AI answers sound human, and knowing when to validate. Al doesn’t blindly copy-paste Claude Code responses. He proofreads everything, removes telltale AI phrases like “in summary,” condenses verbose answers to what customers actually need, and validates complex technical answers with engineering when he doesn’t fully understand the implementation.

8. Compete on customer experience, not just product velocity. Everyone uses AI to ship faster products. Al uses AI to show up differently in customer relationships—delivering custom deployment documentation that accounts for each customer’s specific security requirements and infrastructure constraints. This differentiation in service quality is harder to replicate than product features.

Detailed workflow walkthroughs from this episode:

• How Al Chen Uses Claude Code and 15 Repos to Answer Any Customer Question: https://www.chatprd.ai/how-i-ai/claude-code-and-repos-to-answer-any-customer-question

• Automatically Create a Knowledge Base from Slack Support Threads: https://www.chatprd.ai/how-i-ai/workflows/automatically-create-a-knowledge-base-from-slack-support-threads

• How to Use AI to Answer Customer Questions from Your Entire Codebase: https://www.chatprd.ai/how-i-ai/workflows/how-to-use-ai-to-answer-customer-questions-from-your-entire-codebase

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.

Al Chen is a field engineer at Galileo, an observability platform for AI applications, where he works on the front lines with enterprise customers asking highly technical questions. Despite never having held an engineering role, Al has built a system using Claude Code to query Galileo’s 15 separate repositories, combine that with Confluence documentation and customer-specific quirks, and deliver hyper-personalized answers that would otherwise require constant engineering support.

What you’ll learn:

1. How to use Claude Code to query multiple repositories simultaneously for customer support

2. Why code is often a better source of truth than documentation

3. How to combine repository context with Confluence and Slack using MCPs

4. The “customer quirks” system that creates hyper-personalized deployment guides

5. How to build virtuous loops that turn single customer questions into scalable knowledge

6. Why information organization matters less in the AI era

7. A simple 16-line script (written by Claude Code) that pulls the latest main branch across all your repositories to keep your context current

8. How to reduce engineering interruptions to near-zero by empowering customer-facing teams to query the codebase directly

Brought to you by:

Orkes—The enterprise platform for reliable applications and agentic workflows

Tines—Start building intelligent workflows today

In this episode, we cover:

(00:00) Introduction to Al Chen

(02:50) The problem: documentation wasn’t enough

(04:23) Pulling 15 repos into VS Code

(06:03) How Claude Code queries the entire codebase

(08:00) Why current code beats documentation

(08:31) The pull script that keeps everything updated

(09:54) Opening projects at the multi-repo level

(11:40) Live demo: answering deployment questions

(13:25) The customer quirks system

(15:00) Living in chaos: why organization matters less now

(17:03) Competing on customer experience, not just product

(18:20) Should customers be able to query the code directly?

(20:05) Where humans still add value

(25:46) Using AI for reactive Slack support

(29:16) The “and then” workflow discovery

(32:07) Scaling processes across the team

(34:07) Lightning round and final thoughts

Tools referenced:

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

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

• Pylon: https://usepylon.com/

• Confluence: https://www.atlassian.com/software/confluence

Other references:

• Slack: https://slack.com/

• Kubernetes: https://kubernetes.io/

• Stack Overflow: https://stackoverflow.com/

• Intercom: https://www.intercom.com/

Where to find Al Chen:

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

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

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

Brought to you by:

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

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

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

Biggest takeaways:

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

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

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

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

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

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

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

Detailed workflow walkthroughs from this episode:

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

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

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

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

Brought to you by:

WorkOS—Make your app enterprise-ready today

Lovable—Build apps by simply chatting with AI

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

Biggest takeaways:

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

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

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

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

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

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

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

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

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

Detailed workflow walkthroughs from this episode:

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

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

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

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

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

Catch you next week,
Lenny

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

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

What you’ll learn:

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

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

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

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

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

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

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

Brought to you by:

WorkOS—Make your app Enterprise Ready today

Lovable—Build apps by simply chatting with AI

In this episode, we cover:

(00:00) Introduction to Hilary Gridley

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

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

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

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

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

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

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

(25:28) Daily logging and observation patterns

(27:45) Quick summary

(30:50) The power of screenshots

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

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

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

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

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

(50:18) Where to find Hilary

Tools referenced:

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

• Obsidian: https://obsidian.md/

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

• Cursor: https://cursor.sh/

Other references:

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

Where to find Hilary Gridley:

Substack: https://hils.substack.com/

Website: https://writerbuilder.com

Where to find Claire Vo:

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

Website: https://clairevo.com/

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

X: https://x.com/clairevo

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

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

What you’ll learn:

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

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

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

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

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

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

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

Brought to you by:

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

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

In this episode, we cover:

(00:00) Introduction to Steve

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

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

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

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

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

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

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

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

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

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

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

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

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

(32:15) Quick recap

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

(36:36) Lightning round and final thoughts

Tools referenced:

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

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

• Cursor: https://cursor.sh/

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

• Slack: https://slack.com/

• Browserbase: https://browserbase.com/

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

• PostalForm: https://postalform.com/

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

Other references:

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

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

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

Where to find Steve Kaliski:

Twitter: https://twitter.com/stevekaliski

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

Where to find Claire Vo:

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

Website: https://clairevo.com/

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

X: https://x.com/clairevo

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

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

Brought to you by:

• Rovo—AI that knows your business

• Lovable—Build apps by simply chatting with AI

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

Biggest takeaways:

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

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

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

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

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

Detailed workflow walkthroughs from this episode:

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

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

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

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

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

Catch you next week,
Lenny

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

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

What you’ll learn:

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

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

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

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

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

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

7. Strategies for creating consistent AI interactions using AutoHotkey shortcuts

Brought to you by:

Rovo—AI that knows your business

Lovable—Build apps by simply chatting with AI

In this episode, we cover:

(00:00) Introduction to Marco Casalaina

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

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

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

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

(10:28) Demo: Document scanning automation

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

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

(17:12) Video compression using FFmpeg commands

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

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

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

(27:17) How AI automation changes time management

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

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

Tools referenced:

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

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

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

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

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

Other references:

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

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

• FFmpeg: https://ffmpeg.org/

Where to find Marco Casalaina:

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

Where to find Claire Vo:

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

Website: https://clairevo.com/

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

X: https://x.com/clairevo

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

From Figma to Claude Code and back

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

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

Biggest takeaways:

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

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

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

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

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

Detailed workflow walkthroughs from this episode:

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

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

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

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

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

Brought to you by:

• WorkOS—Make your app enterprise-ready today

• Vanta—Automate compliance and simplify security

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

Biggest takeaways:

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

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

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

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

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

Detailed workflow walkthroughs from this episode:

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

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

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

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

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

Catch you next week,
Lenny

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

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

What you’ll learn:

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

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

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

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

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

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

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

Brought to you by:

WorkOS—Make your app enterprise-ready today

Vanta—Automate compliance and simplify security

In this episode, we cover:

(00:00) Introduction to Daniel Roth

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

(05:56) Using Claude to prioritize feature ideas

(08:58) Building vs. marketing

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

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

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

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

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

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

(21:12) Navigating the App Store

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

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

(28:14) Quick recap

(30:00) Creating terminal aliases with Claude

(31:38) Demo of his Commutely app

(32:10) Using Copilot to manage work responsibilities

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

Tools referenced:

• Claude: https://claude.ai/

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

• Cursor: https://cursor.sh/

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

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

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

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

• Obsidian: https://obsidian.md/

Other reference:

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

Where to find Daniel Roth:

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

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

Where to find Claire Vo:

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

Website: https://clairevo.com/

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

X: https://x.com/clairevo

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

Most teams are still passing static design files back and forth, and most Figma files are already out of date by the time they reach engineering. Gui Seiz (designer) and Alex Kern (engineer) from Figma walk through the exact workflow their team uses to bridge that gap with AI, live onscreen. They demo how to pull a running web app directly into Figma using the Figma MCP, edit it collaboratively, and push it back to code. The old linear waterfall workflow is gone. What replaces it is a fluid, bidirectional loop where design and code inform each other in real time.

What you’ll learn:

1. How to use Figma’s MCP to pull production code directly into Figma files

2. A workflow for pushing design changes from Figma back into your codebase using Claude Code without manual CSS adjustments

3. How to export multiple code states (like all five states of a signup flow) into Figma so designers can work with what actually exists in production

4. Why AI has shifted design work upstream to planning and downstream to craft, eliminating the rushed middle phase of execution

5. How to create custom skills that automate pre-flight checks, lint fixes, and CI monitoring before pushing code to production

6. How to structure your codebase so AI can write 90% of your code more effectively

Brought to you by:

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

In this episode, we cover:

(00:00) Introduction to Gui and Alex from Figma

(02:56) How AI has transformed Figma’s internal workflows

(05:17) The collapse of linear design-to-code workflows

(07:28) Demo: Pulling production code into Figma using MCPs

(10:49) Using Figma for precise design manipulation and team collaboration

(14:10) Demo: Pushing Figma designs back into code with Claude Code

(16:06) How AI has changed the role of software engineers

(18:43) The shift to upstream planning and downstream craft

(22:31) Demo: Exporting multiple code states back into Figma

(25:23) Synchronous vs. asynchronous collaboration with AI

(28:00) Eliminating design and engineering toil with AI

(29:03) Demo: Custom skills for automating pre-flight checks

(34:06) Code first or design first?

(35:24) Using AI to learn and explore codebases

Tools referenced:

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

• From Claude Code to Figma: Turning production code into editable Figma designs: https://www.figma.com/blog/introducing-claude-code-to-figma/

• Codex: https://codex.ai/

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

• Buildkite: https://buildkite.com/

Other references:

• Balsamiq: https://balsamiq.com/

Where to find Gui Seiz:

X: https://x.com/guiseiz

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

Where to find Alex Kern:

X: https://x.com/kernio

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

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.

Every Monday, host Claire Vo shares a 30- to 45-minute episode with a new guest demoing a practical, impactful way they’ve learned to use AI in their work or life. No pontificating—just specific and actionable advice.

Mastering Midjourney: How to create consistent, beautiful brand imagery without complex prompts

Brought to you by:

• Vanta—Automate compliance and simplify security

• Lovable—Build apps by simply chatting with AI

Jamey Gannon is an AI creative director who has spent thousands of hours working inside Midjourney. In this episode, she walks through the system she uses to generate consistent, high-quality brand imagery using mood boards, style references, and personalization codes. She and Claire cover her full workflow for turning loose inspiration into a scalable visual system, how to avoid the biggest mistakes people make with AI image tools, and why a single image reference can often outperform a paragraph of prompting.

Detailed workflow walkthroughs from this episode:

• How I AI: Jamey Gannon’s Workflow for Consistent Brand Imagery in Midjourney: https://www.chatprd.ai/how-i-ai/consistent-brand-imagery-in-midjourney

• How to Generate Realistic AI Self-Portraits for Content: https://www.chatprd.ai/how-i-ai/workflows/how-to-generate-realistic-ai-self-portraits-for-content

• How to Fix and Refine AI-Generated Images: https://www.chatprd.ai/how-i-ai/workflows/how-to-fix-and-refine-ai-generated-images

• How to Create a Consistent Brand Aesthetic in Midjourney: https://www.chatprd.ai/how-i-ai/workflows/how-to-create-a-consistent-brand-aesthetic-in-midjourney

Biggest takeaways:

1. Avoid prompting. Jamey’s entire workflow is designed to minimize text prompting: “I try to avoid prompting at all costs in my process.” Instead of writing complex JSON prompts or detailed descriptions, she relies on style references, image references, and personalization codes to communicate visually with AI.

2. Style references (SREFs) often outperform mood boards. While mood boards are a good starting point, using SREFs as the mood board can give much better results. This is because mood boards with varied styles can cause Midjourney to “average things out,” while SREFs provide more direct style guidance.

3. Personalization codes create your unique aesthetic. By carefully rating images during the personalization process, you can create codes that consistently deliver your preferred style. Jamey recommends “only picking things that I would like if I generated it” and being mindful of potential “style bleeding” from consistently selecting certain elements.

4. Editorial and camera references are prompting shortcuts. Instead of describing complex aesthetics, simply reference known publications or camera models: “When you just say ‘Dazed editorial,’ depending on how famous the publication is, Midjourney’s gonna know what you’re talking about.” This communicates lighting, composition, and style instantly.

5. When something’s not working, remove it completely. Rather than trying to fix problematic elements through prompting, Jamey takes a more direct approach: “If you’re getting too much green, just boot the thing that is so obvious and overwhelming.” This might mean removing an image from your references or cropping out distracting elements.

6. Use AI routing to get the best from each model. Jamey uses different tools for different purposes: Midjourney for initial creation, Nano Banana for editing specific elements, and Flora for packaging and delivering brand imagery to clients. Each tool has strengths that complement the others.

7. See things from the AI’s perspective. When troubleshooting, try to understand what the AI is “seeing” in your references: “I think where a lot of people get tripped up is trying to make AI work the way you want it to work instead of actually understanding how it works.” This perspective shift often leads to better results.

▶️ Listen now on YouTube | Spotify | Apple Podcasts

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.