2026-04-14 20:46:08
👋 Hey there, I’m Lenny. Each week, I answer reader questions about building product, driving growth, and accelerating your career. For more: Lenny’s Podcast | Lennybot | How I AI | My favorite AI/PM courses, public speaking course, and interview prep copilot
P.S. Get a full free year of Lovable, Manus, Replit, Gamma, n8n, Canva, ElevenLabs, Amp, Factory, Devin, Bolt, Wispr Flow, Linear, PostHog, Framer, Railway, Granola, Warp, Perplexity, Magic Patterns, Mobbin, ChatPRD, and Stripe Atlas by becoming an Insider subscriber. Yes, this is for real.
Agents are so hot right now. Every other day, someone’s launching a new one or a new tool to manage them. I bet your team has a half-dozen agent ideas on your backlog right now. None of this means you actually need to build an agent today. But it does mean that you need to understand how agents fit into your broader strategy, and what the right investment looks like.
Hamza Farooq and Jaya Rajwani teach two of the most highly rated and well-respected courses on building AI agents (Agent Engineering Bootcamp and Agentic AI for PMs) and spent over 50 hours putting this guide together. By the time you finish reading this post, you’ll understand the three types of agents, how to decide which initiatives to prioritize, and how to avoid common pitfalls—with specific recommended tools and platforms and tons of real-life examples.
Let’s get into it.
P.S. You can listen to this post in convenient podcast form: Spotify / Apple / YouTube.
Over the past year, we’ve had the same conversation at least 30 times. An AI leader pulls up their roadmap, usually 5 to 10 “agent” initiatives, and says, “Help us figure out which one to build first.”
The list usually includes a PM assistant, a RAG copilot, a customer support system, a code review agent, and a voice-enabled shopping assistant
If you’re reading this, you probably have a similar list. Your team is energized, investors are asking about it, competitors are announcing agent launches. You need to pick something and ship it.
That’s where most teams get stuck. The problem isn’t that they lack ideas; it’s that they try to prioritize fundamentally different kinds of systems as if they were the same thing. The usual approach is to reach for familiar planning tools. Teams open an impact-vs.-effort matrix and try to compare ideas side by side.
But with AI agents, that quickly falls apart. One “agent” might take six weeks to build. Another might take six months. One can be assembled by a product manager using n8n. Another requires a dedicated ML engineering team. One costs $500 per month to operate. Another could generate a six-figure annual LLM bill.
A customer support assistant and a voice-enabled shopping agent may both be called agents, but they demand different architectures, different teams, different infrastructure, and different timelines. Until you recognize those differences, any attempt to compare “effort” or “impact” is essentially guesswork.
Treating architecturally different products as if they’re in the same category makes effective prioritization nearly impossible. Prioritization breaks not because teams are bad at planning but because they’re comparing apples, oranges, and jet engines on the same spreadsheet.
Before you can decide which agent to build first, you need to answer a more basic question: What type of agent is each idea actually proposing?
This will determine almost everything that matters for planning:
How complex it will be to build
What skills and infrastructure are required
How long it is likely to take
How expensive it will be to operate
How you should measure success
In other words, categorization isn’t just a technical exercise. It’s the foundation for smart prioritization.
This post gives you a decision framework you can start using today with your current roadmap.
We developed this framework from patterns we’ve seen while helping organizations turn agent ideas into real production systems. Working with enterprise teams across Fortune 500 companies such as Jack in the Box, Tripadvisor, and The Home Depot, we found that grouping ideas by their underlying architecture unlocks prioritization and significantly speeds up the development and launch process. These distinctions also mirror how the broader industry is beginning to classify AI agents, from automation workflows to reasoning systems and multi-agent networks (like the Levels of Autonomy for AI Agents paper and Types of AI agents by IBM). These are also the foundations of how massively popular tools like OpenClaw and Claude Code are actually architected.
If you’re staring at a backlog of agent ideas trying to figure out what to build first, here’s what you’ll have by the end of this post:
A 5-minute triage process to categorize every agent idea into one of three architectural types
A guide to picking the right tool/platform for your project (i.e. when to use n8n vs. LangGraph vs. ADK)
Success metrics and ROI frameworks tailored to each architectural type
Warning signs that you’ve picked the wrong path (and how to fix it)
You’ll be able to look at your backlog and know which ideas can ship in six weeks for quick ROI, which need three months but will drive significant revenue growth, and which are a six-month bet that only makes sense with the right resourcing and expectation setting.
All by first recognizing that “agent” is an umbrella term for very different kinds of systems.
Every “agent” idea falls into one of three architectural categories.
Category 1: Deterministic automation
You define the entire flow. AI handles content at specific steps. Think: n8n or Zapier workflows with LLM nodes. This is where the majority of agent opportunities belong and where most teams should start. These projects are fastest to launch and deliver measurable ROI quickly.
Category 2: Reasoning and acting agents
AI decides what to do next, using available tools. Think: Cursor, Lovable, or agents built with LangGraph, CrewAI, Google ADK, etc. These initiatives typically come after Category 1, when higher-value problems require flexibility and dynamic decision-making that workflows alone can’t handle.
Category 3: Multi-agent networks
Multiple specialized agents coordinate with each other. Think: enterprise systems built with ADK or AutoGen. These projects are typically reserved for later stages, when multiple teams must coordinate across domains, and should almost never be the starting point on a roadmap.
Some examples of “agents” that fit into each category to help you understand the differences:
Organizations often try to build Category 1 problems with Category 2 frameworks—overengineering solutions that add unnecessary complexity and cost. Less frequently but with worse outcomes, they try to solve Category 2 problems with Category 1 tools, and it breaks in production because the tool is not robust enough.
Let’s take a deeper dive into each category, starting with the workhorse, Category 1.
These are workflows where you define every step, every branch, every decision point. An LLM handles natural language understanding and generation at specific nodes, but you control the flow. Think of them as intelligent flowcharts where you design the path and AI handles the content.
Tools most commonly used for deterministic automation are n8n, Zapier, Make.com, OpenAI AgentKit, Lindy, and Gumloop. These tools are built around explicit triggers and predefined branching logic. You define the workflow, while LLMs are used only for classification, extraction, or drafting within those boundaries.
If your backlog includes a mix of agent ideas, Category 1 projects are almost always the smartest place to begin. These initiatives tend to be the simplest to plan and the lowest-risk to execute.
They’re best suited to situations where the process is already well-defined and the goal is to automate repetitive, high-volume work. If you need quick, measurable ROI, have limited AI engineering capacity, or are under pressure to deliver results in weeks rather than months, Category 1 projects are almost always the right starting point.
Most initiatives in this category share a similar profile across certain criteria:
That combination of fast timelines, modest resources, and clear business impact is what makes Category 1 initiatives such powerful early wins. They generate near-term value while building organizational confidence for more advanced efforts later.
If you can map the entire process as a flowchart with clear decision points, a product belongs in Category 1. Here are some more traits of a Category 1 product:
Execution paths are finite and predictable (fewer than 15 to 20 branches)
Task completion needs to happen in seconds to minutes
The value is in automating a known process, not discovering new approaches
In our experience with customers, this covers 60% to 70% of agent opportunities. Revisiting the typical list of opportunities I mentioned above, here is a great example of a Category 1 product: “We need an AI agent to handle incoming customer emails, read them, understand what they’re asking, pull relevant information from our docs, draft replies, and route to our team for approval.”
At first, this sounds like it needs sophisticated reasoning. But when you map out what actually needs to happen, it’s remarkably deterministic:
Every step is predictable. The “intelligence” is in understanding the email and generating a good response, not in figuring out what to do next. This is Category 1.
There are a ton of great examples of automation agents; here’s one built by me.
I love Airbnb, but I hate spending long hours finding the best ones, so I built an agent that will take my exact request for, e.g., “Modern apartment in Paris near train stations from 20th March to 26th March. Great for a couple” (more than 10,000 users have used it) and run a search. Here’s how you can build your own.
Other examples of Category 1 “agents”:
a travel planning agent
a voice-enabled book companion agent
a content automation agent (YouTube → LinkedIn)
a knowledge base of your organization with internet search (Perplexity clone)
an agent that generates deeply researched blogs, based on a given topic
a highly personalized calorie counter app that allows you to upload images of your meals to keep track of your daily caloric intake and recommends better dietary choices and exercises
The metrics below are designed to answer a simple question: Did this agent automate the right process, or should this idea be reconsidered or re-scoped?
A deterministic agent built for the email automation process can be evaluated as follows:
Workflow completion rate: % of executions that finish successfully
Automation rate: % of requests handled without human intervention
Accuracy: correctness of intent classification, data extraction, and routing decisions
Latency: time from trigger to final output (P50/P95 if relevant)
Cost per workflow: total LLM and API cost per completed run
Error rate: % of runs failing due to tool, integration, or system errors
Human review rate: % of runs requiring manual approval or intervention
Here are workflow completion rate metrics from a real-life example of a Category 1 product, an email support agent built by a SaaS company we worked with:
Week 1: 52% completion rate (lots of edge cases discovered)
Week 4: 78% completion rate (refined classification logic)
Week 8: 87% completion rate (stable, production-ready)
Result: 3,000 support emails/month automated, 2.5 FTE hours/day freed, $18K/month savings
When these metrics stabilize and cost trends downward, the workflow is doing what it should. If completion remains low or manual intervention stays high, the problem may not be deterministic enough for this category.
You’ll know you need a different architecture when:
Your flowchart has 30+ nodes and you’re adding new branches every week
Customers phrase things in ways you can’t anticipate, and mapping all variations is impossible
The agent needs to decide which API or knowledge source to use based on context, not follow a predetermined path
Breaking down ambiguous requests requires exploration and adaptation, not predefined decomposition
The highest-value opportunities can no longer be expressed as predictable workflows
Most quick-win processes are already automated
If several of these signals are present at once, the problem is no longer a good fit for a deterministic workflow, and you should consider Category 2.
Instead of defining the flow, you define the available tools, and an LLM autonomously decides what to do next. The agent operates in a loop: observe → reason → act → observe result → repeat.
The key characteristic: you control the tools; the LLM controls the reasoning.
Tools most commonly used for building ReAct agents include LangGraph, CrewAI, AutoGen, and other agent orchestration libraries that support tool use, memory, and dynamic planning.
Category 2 is for situations where user requests are ambiguous, workflows cannot be mapped in advance, and real value comes from flexible, contextual decision-making. If you need agents that can reason across multiple tools, handle conversational interactions, or adapt dynamically to new inputs, that’s a Category 2 product.
Category 2 products are more complex to plan and carry higher execution risk than Category 1. Most initiatives in this category share a similar profile:
The combination of longer timelines, specialized expertise, and higher costs is what makes Category 2 initiatives powerful but more demanding than Category 1. If your backlog includes problems that truly require reasoning and dynamic behavior, prioritizing Category 2 projects becomes essential. They unlock use cases that deterministic automation cannot handle and enable more advanced, high-impact agent experiences.
A product belongs in Category 2 if the same user request can trigger different action sequences every time. That means that you don’t determine the path; the LLM does. That’s the key difference from Category 1. Here are some more traits of a Category 2 product:
The same high-level task requires different sequences of actions depending on input
You have 5-15+ distinct capabilities and the right one depends on context
User intent is ambiguous and needs clarification through interaction
Multiple input modalities (voice, image, text) need to be understood contextually
Breaking down complex requests into sub-tasks is part of the value
In our work with customers, this is the right choice for 25% to 30% of agent opportunities. For an example of this type of product, let’s return to the voice-enabled shopping assistant opportunity from the start of this post.
Customers should be able to search products by voice, upload images to find similar items, check order status, update preferences, and initiate returns, all through conversation.
At first, this sounds like Category 1. Just map out the intents and route accordingly, right? But in practice, real conversations don’t follow fixed paths. To see why, let’s walk through one interaction.
A customer uploads a photo of shoes and says:
“These are too small. I need a size up, and I want them delivered by Thursday.”
Here’s what happens under the hood:
Observe. The agent receives mixed input: an image + voice request.
Reason. It determines:
First, identify the product in the image
Then, find available size variants
Then, check delivery dates
Finally, confirm the order with the user
Act. The agent dynamically selects tools:
visual_search() → identify product
check_inventory() → find size-up availability
get_delivery_options() → verify Thursday delivery
place_order() → after confirmation
Observe result → reason again. Each tool response updates the agent’s state and influences the next step.
This sequence cannot be pre-defined.
If the item is out of stock, the agent may suggest alternatives.
If Thursday delivery isn’t available, it may propose pickup.
If the image can’t be recognized, it asks a clarifying question.
The same user request triggers different action sequences based on reasoned considerations.
Other examples of Category 2 “agents”:
a conversational customer support agent
a code assistant that modifies repositories, e.g. Claude Code
an intelligent personal shopping assistant
an IT troubleshooting agent
a sales copilot that researches accounts and drafts outreach
a multimodal assistant combining voice, image, and text
Reasoning agents should be evaluated on whether they help users achieve their goals across variable paths, while remaining efficient enough to justify their cost.
These metrics answer the question: Was dynamic reasoning necessary, or should the problem be simplified to a lower category?
Task completion rate: % of sessions where users achieve their intended goal
Reasoning accuracy: correctness of task decomposition, tool selection, and decision ordering
Conversation length: average turns to resolution
Multimodal accuracy: correctness of image, voice, or structured input interpretation (if applicable)
Tool call efficiency: average number of tool calls per successful session
Latency: time per turn and end-to-end session duration
Cost per session: total LLM and API cost per completed interaction
User satisfaction: post-interaction CSAT or equivalent signal
Business impact: lift in conversion, retention, or task success versus baseline
Here are some metrics from a real-life example, a voice + image shopping assistant for a home goods retailer we built:
Month 1: 71% task completion, longer conversations, higher tool usage, $0.12 cost per session
Month 4: 86% task completion, shorter conversations, fewer tool calls, $0.08 cost per session
Result: Image identification accuracy improved from 76% to 91%, conversion lift increased from +8% to +22%, and CSAT rose from 4.0 to 4.5.
When task completion improves while conversation length, tool usage, and cost per session decline, the agent’s reasoning loop is adding value. If performance stalls while costs remain high, the problem may be over-scoped or better served by the deterministic approach of Category 1 tools.
You’ll know you need a different architecture when:
Your single agent is trying to handle too many domains (customer service + inventory + logistics + finance) and performance is degrading
You need agents to delegate tasks to each other, not just call stateless APIs. Example: A shopping agent needs to ask an inventory agent, “Can you check all warehouses and suggest alternatives?”
Tasks take hours or days to complete (like the automated eval agent analyzing 10,000 conversations overnight)
You need hundreds of agent instances running in parallel, coordinating work among them
Different teams want to own their specialized agents, but they need to work together
If you’re hitting two to three or more of these, it’s time to consider Category 3 tools and approaches.
Instead of one agent calling tools, you have multiple specialized agents that coordinate with each other. Each agent is owned by a different team, handles its own domain, and can request help from other agents.
2026-04-13 23:07:46
Listen now on YouTube • Spotify • Apple Podcasts
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.
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.
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).
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.
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.
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.
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.
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.
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
Listen now on YouTube • Spotify • Apple Podcasts
Brought to you by:
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.
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.
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.
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.
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.
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.
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.
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.
2026-04-13 20:03:52
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.
Listen or watch on YouTube, Spotify, or Apple Podcasts
How to create your first Claude Cowork project by connecting a folder on your computer and building context over time
The “brain” file strategy: how to create a preferences document that Claude reads every time to understand who you are and how you work
Why one-click connectors to Gmail, Slack, Notion, and Google Calendar unlock AI that actually does work instead of just suggesting it
How to analyze your sent emails to build a writing skill that perfectly matches your tone and style
The sub-advisory-board technique: spinning up three AI agents with different personas to review your work from multiple perspectives
How to set permissions for each connector so Claude only drafts (never sends) or always asks before taking action
The scheduled-task workflow that creates a morning debrief by reading your email, Slack, and calendar every day at 7:30 a.m.
Why projects with shared memory beat individual chat threads for consistent, high-quality AI outputs
Tines—Start building intelligent workflows today
Cursor—The best way to code with AI
(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
• 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/
• Get Started with Claude Cowork: https://support.claude.com/en/articles/13345190-get-started-with-cowork
YouTube: https://www.youtube.com/channel/UCv2ovDhYVtlJw4QMidLFP8Q
X: https://twitter.com/jjenglert
LinkedIn: https://www.linkedin.com/in/jj-englert-a08836a6/
ChatPRD: https://www.chatprd.ai/
Website: https://clairevo.com/
LinkedIn: https://www.linkedin.com/in/clairevo/
Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email [email protected].
2026-04-12 20:31:41
Keith Rabois was an early executive at PayPal (part of the famous PayPal Mafia), COO at Square, VP of Corporate Development at LinkedIn, and an early investor in Stripe, DoorDash, Airbnb, YouTube, Ramp, and Palantir. Currently he’s managing director at Khosla Ventures. Also, he hasn’t touched a computer since September 2010 (he does everything from an iPad).
Listen on YouTube, Spotify, and Apple Podcasts
The barrels vs. ammunition hiring framework (and how to spot barrels)
Why talking to customers is actively harmful for consumer products
How to identify undiscovered talent
Why the PM role is dying
The three traits of the best-performing companies right now
The specific interview question he asks every senior candidate
Why CMOs (not engineers) are becoming the #1 consumer of tokens
WorkOS—Modern identity platform for B2B SaaS, free up to 1 million MAUs
Vanta—automate compliance, manage risk, and accelerate trust with AI
• X: https://x.com/rabois
• LinkedIn: linkedin.com/in/keith
• Website: https://www.khoslaventures.com
• Square: https://squareup.com
• Jack Dorsey on X: https://x.com/jack
• Head of Claude Code: What happens after coding is solved | Boris Cherny: https://www.lennysnewsletter.com/p/head-of-claude-code-what-happens
• Simon Willison’s Weblog: https://simonwillison.net
• Vinod Khosla on X: https://x.com/vkhosla
• Peter Thiel on X: https://x.com/peterthiel
• Max Levchin on X: https://x.com/mlevchin
• David Sacks on LinkedIn: https://www.linkedin.com/in/davidoliversacks
• Tony Xu on X: https://x.com/t_xu
• David Sze on X: https://x.com/davidsze
• Faire: https://www.faire.com
• Max Rhodes on X: https://x.com/MaxRhodesOK
• Jeffrey Kolovson on LinkedIn: https://www.linkedin.com/in/jeffreykolovson
• Uncapped | Comparative Advantages w/ Keith Rabois: https://www.khoslaventures.com/posts/uncapped-comparative-advantages-w-keith-rabois
• Lattice: https://lattice.com
• Taylor Francis on LinkedIn: https://www.linkedin.com/in/taylor-francis-4ba49640
• Building product at Stripe: craft, metrics, and customer obsession | Jeff Weinstein (Product lead): https://www.lennysnewsletter.com/p/building-product-at-stripe-jeff-weinstein
• The art of hiring: insights from Khosla Ventures, Airbnb, Ramp and Traba: https://ramp.com/velocity/the-art-of-hiring-insights
• Eric Glyman: Seek out super individual contributors (ICs): https://ramp.com/velocity/the-art-of-hiring-insights#Eric-Glyman:-Seek-out-super-individual-contributors-(ICs)
• Eric Glyman on X: https://x.com/eglyman
• Mike Moore on LinkedIn: https://www.linkedin.com/in/mike-moore-802223177
• Brian Chesky’s new playbook: https://www.lennysnewsletter.com/p/brian-cheskys-contrarian-approach
• Why you should work much harder RIGHT NOW: https://marginalrevolution.com/marginalrevolution/2026/03/why-you-should-work-much-harder-right-now.html
• Opendoor: https://www.opendoor.com
• The Craft of Early Stage Venture | Peter Fenton, General Partner at Benchmark | Uncapped with Jack Altman: https://www.youtube.com/watch?v=vRiblwiXt-Q
• Lovable: https://lovable.dev
• The rise of the professional vibe coder (a new AI-era job) | Lazar Jovanovic (Professional Vibe Coder): https://www.lennysnewsletter.com/p/getting-paid-to-vibe-code
• Building Lovable: $10M ARR in 60 days with 15 people | Anton Osika (co-founder and CEO): https://www.lennysnewsletter.com/p/building-lovable-anton-osika
• Marc Andreessen: The real AI boom hasn’t even started yet: https://www.lennysnewsletter.com/p/marc-andreessen-the-real-ai-boom
• Jeremy Stoppelman on X: https://x.com/jeremys
• The design process is dead. Here’s what’s replacing it. | Jenny Wen (head of design at Claude): https://www.lennysnewsletter.com/p/the-design-process-is-dead
• Andy Warhol: https://en.wikipedia.org/wiki/Andy_Warhol
• Curation and Algorithms: https://stratechery.com/2015/curation-and-algorithms
• Ernest Hemingway: https://en.wikipedia.org/wiki/Ernest_Hemingway
• William Shakespeare: https://en.wikipedia.org/wiki/William_Shakespeare
• Evan Moore on X: https://x.com/evancharles
• Andrew Mason on X: https://x.com/andrewmason
• Read Taylor Swift’s Full Viral Speech After Record-Breaking Awards Sweep: https://www.newsweek.com/entertainment/read-taylor-swift-full-acceptance-speech-record-breaking-awards-sweep-11745941
• The Chainsmokers: Stories Behind the Songs, AI’s Impact on Music, and Venture Investing | Uncapped with Jack Altman: https://www.youtube.com/watch?v=9GMSC-2pYnw&list=PLtpH7YnTL8ihy0nR2BV32n5VkRtqlDAS1&index=16
• How to spot a top 1% startup early: https://www.lennysnewsletter.com/p/how-to-spot-a-top-1-startup-early
• David Weiden on LinkedIn: https://www.linkedin.com/in/davidweiden
• Alfred Lin on LinkedIn: https://www.linkedin.com/in/linalfred
• Keith’s post about vertical integration on X: https://x.com/rabois/status/870673635375104000
• Jon Chu on X: https://x.com/jonchu
• Kanu Gulati on X: https://x.com/KanuGulati
• Rogo: https://rogo.ai
• Profound: https://www.tryprofound.com
• Basis: https://www.getbasis.ai
• Spellbook: https://www.spellbook.legal
• Roelof Botha on X: https://x.com/roelofbotha
• Delian Asparouhov on LinkedIn: https://www.linkedin.com/in/delian-asparouhov-87447742
• Lessons From Keith Rabois, Essay 1: How to become a Venture Capitalist: https://delian.io/lessons-1
• Velocity over everything: How Ramp became the fastest-growing SaaS startup of all time | Geoff Charles (VP of Product): https://www.lennysnewsletter.com/p/velocity-over-everything-how-ramp
• Nuremberg on AppleTV+: https://tv.apple.com/us/movie/nuremberg/umc.cmc.3sg4y0382byupy76bfy7307k4
• Eight Sleep: https://www.eightsleep.com
• “NO DAYS OFF”—Bill Belichick on X: https://x.com/SNFonNBC/status/829036279069364224
• Creativity, Inc.: Overcoming the Unseen Forces That Stand in the Way of True Inspiration: https://www.amazon.com/Creativity-Inc-Overcoming-Unseen-Inspiration/dp/0812993012
• The Jordan Rules: The Inside Story of One Turbulent Season with Michael Jordan and the Chicago Bulls: https://www.amazon.com/Jordan-Rules-Sam-Smith/dp/0671796666
• The Upside of Stress: Why Stress Is Good for You, and How to Get Good at It: https://www.amazon.com/Upside-Stress-Why-Good-You/dp/1101982934
Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email [email protected].
Lenny may be an investor in the companies discussed.
2026-04-12 03:36:51
👋 Hello and welcome to this week’s edition of ✨ Community Wisdom ✨ a subscriber-only email, delivered every Saturday, highlighting the most helpful conversations in our members-only Slack community.
2026-04-08 20:03:47
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.
Listen or watch on YouTube, Spotify, or Apple Podcasts
How Yash built a custom Slack digest that categorizes 150+ daily notifications into action-required, need-to-read, and FYI buckets
Why Perplexity Computer beats Claude Code and Codex for building personal productivity apps
His “anti-to-do list” framework: spending an hour daily automating tasks you never want to do again
How to use AI for deterministic tasks (APIs, structured data) vs. subjective tasks (categorization, summarization)
Why the SaaS apocalypse narrative is wrong—and why we’re about to see an explosion of micro-software
How his team uses Perplexity Computer to prototype design systems and communicate with cross-functional partners
Guru—The AI layer of truth
ThoughtSpot—Build AI-powered analytics into your product
(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
• 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/
• 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
LinkedIn: https://www.linkedin.com/in/yashtekriwal/
Company: https://www.clay.com/
ChatPRD: https://www.chatprd.ai/
Website: https://clairevo.com/
LinkedIn: https://www.linkedin.com/in/clairevo/
Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email [email protected].