CHAPTERS
- 0:00 – 3:18
LinkedIn’s shift to “Product Builder” and whether the role is real
Aakash opens with LinkedIn replacing its APM program with an Associate Product Builder program and questions whether this is hype. Ankit previews research across thousands of job postings suggesting the role is real and increasingly demanded.
- •LinkedIn’s program change as a signal of market shift
- •Central question: real role vs influencer-driven hype
- •Ankit’s evidence-based approach (job-posting analysis)
- •Who the episode is for: PMs and adjacent roles considering the shift
- 3:18 – 4:39
What the job market data says: AI skills are now required in PM roles
Ankit explains how he used LLMs to analyze ~12,500 PM job descriptions and what patterns emerged. The key finding: many PM roles now explicitly require AI fluency, especially good judgment about what should and shouldn’t be solved with AI.
- •Method: analyzing 12,500 PM job descriptions using Claude/GPT
- •~30% of PM roles request meaningful AI skills
- •Demand is not just for tools; it’s for judgment and problem selection
- •“Product builder” framed as a major career opportunity
- 4:39 – 7:09
Defining the product builder: upgrading discovery, delivery, and distribution
Aakash asks what a product builder actually is and how it differs from AI PM or engineering roles. Ankit anchors the definition in the classic PM loop—discovery, delivery, distribution—and argues AI changes the speed and ownership of these phases, especially delivery and experimentation.
- •PM work decomposed: discovery → delivery → distribution
- •AI accelerates discovery (research, competitive analysis, synthesis)
- •Delivery used to be the bottleneck; AI reduces gatekeeping
- •PMs can prototype/experiment without always waiting on engineering
- •Faster iteration enables less “cowardly” product decisions
- 7:09 – 12:03
Sponsor segment: Mobbin MCP to ground AI-generated UI in real product patterns
Aakash shares why AI-generated UI can feel generic and how Mobbin’s MCP helps by providing real shipped-screen references. He demos a before/after workflow where an agent studies patterns (hero, proof, pricing) instead of inventing from scratch.
- •Problem: LLM UIs look templated without strong references
- •Mobbin library scale: hundreds of thousands of screens/flows
- •MCP server lets Claude/Cursor/Lovable reference real examples
- •Use cases: redesigns, product audits, PRDs with grounded examples
- •Principle: study patterns, don’t copy apps
- 12:03 – 14:26
Compensation: the AI/product builder premium in the US and India
Ankit walks through pay data showing AI-skilled PMs earn a meaningful premium versus traditional counterparts. He provides median and upper-range compensation examples for the US and India, emphasizing that seniority plus AI skills compound leverage.
- •AI/‘builder’ roles pay ~15–20%+ more in US/Europe
- •India premium cited as ~30–50%+ in many cases
- •US median cited around $195K; senior ranges can go far higher
- •Top-lab compensation can reach very high totals (e.g., Netflix posting)
- •India examples: entry and experienced LPA ranges with AI portfolio
- 14:26 – 22:16
The POWER framework: why tools come last (Possibilities → Opportunities → Workflows → Engineering → ROI/Results)
Ankit introduces a clear framework to cut through AI noise and focus on ROI. The core message: don’t start with tools; start by mapping what AI can do, where it matters in your company, and the workflows to improve—then engineer the solution.
- •P = Possibilities: research what AI can do (UTG: understand/transform/generate)
- •O = Opportunities: identify high-ROI problems inside your company
- •W = Workflows: go deep into real processes; find optimization vs innovation
- •E = Engineering: only after POW, pick tools (agents, automations, coding)
- •Most valued skill in postings: choosing the right AI use case, not RAG/prompting
- 22:16 – 26:30
Scaling empathy with transcripts: turning 200 intro calls into usable personas
Ankit gives a concrete workflow example: feeding hundreds of user transcripts into Claude to generate representative personas. He uses these personas as a decision filter to predict how changes will land across different user segments—‘empathy at scale.’
- •Collecting real user language via recorded transcripts
- •Using Claude to synthesize personas from raw qualitative data
- •Decision-making aid: test a decision against each persona
- •Innovation opportunity: doing something previously infeasible manually
- •Practical system: folders of transcripts + repeatable prompting
- 26:30 – 34:06
Five levels of AI engineering: from prompting to production-grade systems
Ankit proposes a maturity ladder for AI execution, starting with basic prompting and progressing toward production-grade implementations. He maps common tools to each level and highlights ‘skills + connectors’ as a major productivity unlock.
- •Level 0: basic prompting in chat UI
- •Level 1: reusable prompts via Custom GPTs / Google Gems
- •Level 2: ‘skills’ + connectors (context-preserving, progressive disclosure)
- •Level 3: vibe coding (e.g., Google AI Studio) for simple apps/interfaces
- •Level 4: workflow automation platforms (n8n/Make) with AI-assisted building
- 34:06 – 35:46
Claude Code vs Codex: why the debate mostly doesn’t matter
Aakash presses on tooling, and Ankit argues performance differences are minor for most product-builder use cases. He shares informal benchmarking across common web builds and recommends focusing on outcomes rather than model tribalism.
- •Most builders don’t need to optimize model choice for typical apps
- •Benchmarks: multiple platforms can build functional websites
- •Differences exist (tokens, prompting) but converge with iteration
- •Recommendation: stop the debate and ship
- •Only extreme/PhD-level problems warrant deep model selection concern
- 35:46 – 36:47
Beyond level five: loop/agent engineering (plan → execute → evaluate → repeat)
Ankit describes the next frontier: letting AI not only write code but also run it, evaluate results, and iterate in loops. He positions this as where ‘real leverage’ comes from, then transitions into a full case study to make it concrete.
- •Mental model: AI can plan, execute, and self-evaluate in cycles
- •Loop engineering/harness design as the advanced layer
- •Goal: reduce human micromanagement, increase iteration speed
- •Bridge from theory into a real production build
- 36:47 – 38:17
Case study setup: replacing a $550/month email platform with an in-house tool
Ankit explains HelloPM’s email needs (120K subscribers) and the cost problem: SES is cheap but API-only, and the UI platform on top became expensive. He sets constraints: build on modern stack (Node/TypeScript), deploy to AWS, and rely heavily on Claude Code rather than manual AWS work.
- •SES provides sending API; missing campaign UI and management
- •Third-party email UI tool cost grew to ~$550–$700/month
- •Constraint: build with Node.js + TypeScript and AWS services
- •Constraint: minimal manual AWS console work; use MCP/agent assistance
- •Objective: production-grade replacement, not a toy demo
- 38:17 – 45:57
Build-and-deploy walkthrough: specs → Claude plan → overnight slices → documentation
Ankit details the actual workflow: draft simple requirements, have an LLM expand into specs, run Claude Code in plan mode, then execute slice-by-slice—continuing while he sleeps. He also shows how he requested deployment runbooks and team manuals to make the system operable.
- •Start with rough feature list; use LLM to produce markdown specs
- •Claude Code generates a plan, asks clarifying questions, implements in phases
- •Overnight autonomous execution request: implement/test each slice sequentially
- •Use MCP to handle AWS deployment and credentials setup
- •Deliverables include product manual + technical documentation for handoff
- 45:57 – 49:35
Cost auditing and architecture decisions: challenging the agent’s defaults
After deployment, Ankit reviews estimated infrastructure costs and pushes the agent to simplify. By questioning instance sizing and components (e.g., Fargate vs EC2), he reduces projected costs dramatically—illustrating why builders must audit, not blindly accept outputs.
- •Agent’s initial stack estimate still required human scrutiny
- •Key skill: ask ‘why this service/size?’ and request alternatives
- •Example: downsizing compute and removing unnecessary complexity
- •Result: cost estimate reduced significantly (e.g., ~$420 → ~$110)
- •Lesson: product builder = judgment + iteration, not autopilot
- 49:35 – 1:08:01
Why the last 20% is the new PM job (and how to land the role + interviews)
Aakash and Ankit emphasize that AI gets you ~80% quickly; the hard part is debugging, edge cases, security, and production hardening. Ankit then provides a practical roadmap to become a product builder (alignment, skill map, portfolio, targeted outreach) and breaks down the three interview areas candidates must prepare for.
- •Reality: prototypes are easy; production readiness is the differentiator
- •PM/engineer split: PM builds prototype, engineering hardens and scales
- •Roadmap: analyze 25–30 JDs, create skill map, learn by building, talk to practitioners
- •Job strategy: portfolio-first outreach + tailored company-specific proposals
- •Interview prep: (1) fit/behavioral, (2) PM fundamentals, (3) AI project depth + edge cases
