Aakash GuptaFAANG PM Reveals How to Build AI Agents (and Get Paid $750K+)
CHAPTERS
- 0:00 – 1:57
Why AI agents are the future of PM (and why the knowledge is gatekept)
Aakash frames agentic product development as the next major shift for PMs and highlights the rising demand and compensation for AI agent PM roles. Mahesh is introduced as a multi-FAANG PM who will demonstrate building agents end-to-end and share a job roadmap.
- •AI agents as the new default for building products
- •Agent PM roles are fast-growing and can reach $750K+ total comp
- •Episode promise: practical build demo + career strategy
- •Mahesh’s background across Meta/Amazon/Microsoft/Google
- 1:57 – 2:40
What makes an “AI Agent PM”: the 3 core qualification pillars
Mahesh explains the three main criteria companies look for in AI agent PMs: having built with AI, having handled AI-specific product transactions (data/models/evals/iteration), and strong general PM skills for ambiguity and experimentation. These are positioned as emerging table stakes.
- •Built-in-AI experience matters more than theory
- •AI PM ‘transactions’: data, model choices, evals, scaling via iteration
- •Classic PM strengths: ambiguity, experimentation, operating at scale
- •These skills are becoming table stakes for top roles
- 2:40 – 4:46
Tooling choices: Langflow for backend agents + v0 for frontend apps
Before the demo, Mahesh explains why he selected Langflow and v0: lowering barriers vs. coding from scratch, broad model-provider integrations, and a path to production code. He compares alternatives like n8n and discusses tradeoffs of abstractions.
- •No-code reduces barrier to entry for PMs and beginners
- •Langflow: capable integrations (Azure/AWS/Gemini/OpenAI) + access to underlying code
- •v0: prompt-to-UI web app builder (similar to Lovable/Bolt)
- •Tradeoff: abstractions can lag on new model support
- 4:46 – 8:10
Live build (backend): competitive analysis agent inputs, outputs, and flow design
Mahesh builds a competitive analysis agent in Langflow, starting from a simple agent template. He teaches an interview-style way to think in terms of inputs/outputs/tools, then wires two competitor inputs into a prompt template.
- •Start with I/O thinking: competitor names in, markdown table out
- •Add two text inputs (Competitor A/Competitor B) for user-supplied values
- •Use prompt templates with variables to create “ports” for external inputs
- •Design goal: reusable backend that can later plug into a UI
- 8:10 – 11:08
System prompt engineering: role, instructions, tools, guardrails
Mahesh breaks down a strong system prompt structure, emphasizing specificity and formatting requirements. He calls out signals interviewers look for: role framing, clear instructions, tool usage, and guardrails for reliability.
- •Prompt sections: role → instructions → tool usage → output schema → guardrails
- •Use bracketed variables to pass values dynamically (Company A/B)
- •Be explicit about output format (markdown, attributes, table structure)
- •Prompt structure is a tell of AI maturity in interviews
- 11:08 – 13:54
Adding a search tool: Tavily setup + why agent search needs content, not just links
The agent is upgraded with Tavily, a search tool designed for agents that returns extracted text from URLs. Mahesh walks through API key setup and explains why raw URLs aren’t sufficient for agent reasoning.
- •Tavily provides agent-friendly search with extracted page content
- •Tool wiring: set tool mode and connect tool to the agent’s tool section
- •Simple API key setup; practical “research layer” for competitive analysis
- •Why tools are central: agents need external grounding to perform tasks
- 13:54 – 17:25
Model choice and experimentation: cost, speed, and abstraction limits
They switch the backend model to GPT-4o mini for speed and cost efficiency and discuss when higher-end models matter. Mahesh notes the downside of no-code layers: you may wait for tool vendors to expose new model versions.
- •Use smaller models for prototyping to avoid runaway costs
- •Langflow model availability depends on vendor integration timelines
- •Quality differences often require targeted evals, not intuition
- •Abstractions trade flexibility for speed and simplicity
- 17:25 – 18:14
Testing in Langflow Playground: observability, timing, and outputs
Mahesh runs the flow in Langflow’s Playground and shows how to inspect step-by-step execution, logs, and timings. The agent produces a multi-attribute comparison output quickly, demonstrating end-to-end backend validation.
- •Playground lets you run flows, inspect steps, and view logs
- •Observe latency and execution breakdown across components
- •Validate output structure matches the requested report format
- •Backend testing precedes UI and production exposure
- 18:14 – 23:54
Monetizing the backend: publishing as an API, auth tokens, and Postman debugging
Mahesh publishes the Langflow agent as an API, generates a bearer token, and uses Postman to test requests. He demonstrates a real debugging moment around duplicate input fields and shows how to resolve it.
- •Publish → API access to expose the entire flow as an endpoint
- •Generate bearer token for external calls (basic security)
- •Use Postman to validate request/response formats and debug quickly
- •Common pitfall: duplicate/incorrect inputs causing API errors
- 23:54 – 29:59
Frontend with v0: prompt-to-app UI using real API request + response schema
Mahesh feeds v0 a detailed prompt plus the exact API call and response format so it can generate a working UI. He explains how this replaces traditional API-doc reading and accelerates full-stack prototyping for PMs.
- •Provide v0: task + requirements + resources (API call + response JSON)
- •v0 generates a responsive UI (often Tailwind) with inputs and a compare action
- •Key trick: include response format so UI can parse and render correctly
- •Massive speedup vs. reading extensive API docs and hand-coding UI
- 29:59 – 41:00
Vibe coding in practice: iterate, debug timeouts, and ship to Vercel
They test the UI, see intermittent 500/504 timeouts due to backend latency, and use v0 to improve error handling and timeouts. Mahesh then publishes the app via Vercel and explains domain/setup options.
- •Realistic failure modes: gateway timeouts when backend responds slowly
- •Use ‘fix with v0’ iteration loop instead of manual debugging research
- •Publish to production on Vercel; optionally attach a custom domain
- •PM takeaway: fast iteration beats perfect first builds
- 41:00 – 43:35
AI agent vs regular AI product: tools, goals, memory, guardrails, recovery
Mahesh defines what makes something agentic: it uses tools, pursues a goal (with retries), and can be extended with knowledge, memory, and guardrails. This contrasts with single-turn AI services like speech-to-text or simple Q&A.
- •Agents use tools to act in the world (APIs/search)
- •Goal-directed behavior: keep trying until the objective is met
- •Add knowledge and memory for multi-step, multi-interaction workflows
- •Guardrails and checks enable safer, more reliable autonomy
- 43:35 – 46:55
History and architecture of agentic AI: from ChatGPT to multi-agent, multimodal systems
Mahesh maps agentic AI’s evolution: ChatGPT-era chat, then copilots embedded in products, then tool-using agents, and now multi-agent and multimodal systems. He connects this to coding agents as a canonical multi-agent example.
- •2022: chat breakthroughs drove user adoption (users brought their own data)
- •2023: copilots embedded in products reduced friction and expanded use cases
- •2024: agents + tool-calling to change system state (APIs/search/code)
- •2025: multi-agent + multimodal systems (text, images, audio)
- 46:55 – 50:48
FAANG “vibe coding” interviews: what they actually evaluate for PMs
Mahesh explains that vibe coding interviews aren’t about raw coding ability—they’re a canvas to assess PM thinking. Interviewers want structured prompting, iteration taste, and evidence of evaluation and feedback loops.
- •Focus on PM fundamentals; vibe coding is a vehicle for product thinking
- •Demonstrate structured prompts and clarity of requirements
- •Show iterative improvement: user insights → changes → re-test
- •Signal evaluation mindset: feedback loops, data, and quality checks
- 50:48 – 53:54
Cart-before-the-horse AI development: prototype first, then refine the problem
Mahesh argues AI changes the classic PM sequence: cheap prototyping, unclear customer expectations, and competitive urgency favor building prototypes early. The new workflow is customer conversations → prototype → iterate → lightweight PRD + eval plan → engineering hardening.
- •Prototyping cost dropped ~100x, enabling faster exploration
- •Customers often don’t know what to expect from AI until they see it
- •Competitive FOMO makes long research cycles risky
- •New PM deliverables: UX clarity, prompts, and evaluation criteria
- 53:54 – 1:29:02
Breaking into AI and FAANG: Mahesh’s path (dev→AI→PM) + the 18-month roadmap
Mahesh shares how he broke into AI at Microsoft through relentless proximity to research teams and shipping a Vision AI dev kit, then transitioned to PM by obsessing over customers and business impact. He closes with job market data, compensation ranges, and a structured 18-month plan: learn fundamentals, build+eval with real users, ship to production, contribute to target-company communities, and demonstrate evaluative rigor.
- •Career story: create opportunities, ship end-to-end, and compound credibility
- •Dev→PM transfer: customer obsession, business orientation, and cross-team leadership
- •Market signals: AI job growth outpacing traditional PM; comp often $750K+ at L6/L7
- •18-month roadmap: build first agent → get users → productionize → contribute/eval in open communities to get hired
