Aakash GuptaClaude Code + Analytics Masterclass: Automate Product Analytics (2026)
CHAPTERS
- 0:00 – 1:31
Why Claude Code + MCP is a “gateway drug” for 10x product workflows
Aakash opens by asking for the most powerful AI PM workflow Frank has seen. Frank frames it as running the entire product process inside Claude Code/Cursor by piping in product analytics and other tools via MCP, enabling analysis, reporting, synthesis, spec writing, and even prototyping.
- •Managing end-to-end product work inside Claude Code/Cursor
- •MCP as the bridge between AI models and external tools/data
- •Core promises: faster chart analysis, automated reporting, feedback synthesis, PRD generation, prototyping
- •Positioning the episode as a masterclass for analytics in Claude Code
- 1:31 – 2:33
Who Frank Lee is and what MCP means in plain English
Frank is introduced as a principal PM at Amplitude leading agents/MCP efforts. He explains Claude Code as a terminal-based coding agent and MCP (Model Context Protocol) as a standardized way to connect AI clients to external tools, data, and actions.
- •Frank’s role: leading agents and MCP products at Amplitude
- •Claude Code basics: terminal agent with models and actions
- •MCP definition: easiest way to connect AI to external systems
- •Common AI clients: Claude, Cursor, ChatGPT
- •Why this enables complex product + coding workflows
- 2:33 – 3:48
What PMs can do once analytics + tools are connected via MCP
Frank enumerates what becomes possible: automating weekly reporting, investigating metric movements, drilling into user/account health, turning insights into PRDs, and routing work to tools like Jira/Linear—or even into code prototypes. Aakash reframes this as the entry point to modern “AIPM” workflows.
- •Automate WBR-style reporting and narrative generation
- •Investigate chart trends/anomalies with successive queries
- •Connect metric movement to underlying qualitative feedback
- •Draft PRDs directly from analyzed product context
- •Push outcomes into Jira/Linear or into coding agents for prototyping
- 3:48 – 5:10
Setting up the product-context repo in Cursor + introducing Skills
Frank demos his setup in Cursor: a dedicated ‘product repo’ with folders of initiatives, roadmap context, and specs in markdown. He introduces ‘Skills’ as reusable prompt packages with metadata, heuristics, and configured MCP tools to reliably execute tasks.
- •Create a dedicated product repository with structured folders per product line
- •Store roadmap plans, specs, terminology, and learnings as markdown
- •Skills = named prompts with descriptions, steps/heuristics, and tool access
- •Skills help models decide when/how to run workflows
- •Example: replicating Amplitude-style ‘Auto Insights’ via a custom skill
- 5:10 – 6:25
Building an ‘analyze chart’ skill: heuristics, evidence, and business meaning
Frank shows how a chart-analysis skill is designed: pull chart data via Amplitude MCP, look for anomalies/seasonality/spikes, consult related context (feedback, releases, annotations), and output a structured narrative with hypotheses and implications. He then switches to Claude Code to run it from the terminal.
- •Use chart URL as the entry point for automated analysis
- •Heuristics: spikes, anomalies, seasonality, pattern recognition
- •Enrich quant with qual: feedback, release notes, annotations
- •Standard output format: what happened, why, evidence, business impact
- •Claude Code terminal execution for repeatable investigation
- 6:25 – 9:37
Context management: avoiding context-window pain (refresh, tool overhead, /compact)
Aakash probes how to balance “enough context” vs context-window constraints. Frank explains session resets in Claude Code/Cursor, context overhead from loaded MCP tool descriptions, and Claude Code’s compaction feature; Aakash adds a practical fallback: exporting progress to a markdown file before compaction fails.
- •Session resets as a simple way to ‘refresh’ context
- •Tooling overhead: MCP tool names/descriptions/instructions consume context
- •Typical cost estimate: ~5–10% context for a couple MCPs (e.g., Amplitude + Linear)
- •Claude Code compaction to summarize long threads
- •Tactical tip: write progress to a markdown file before hitting failure states
- 9:37 – 14:08
Structuring context: PRD templates, reusable prompts, and ingesting meeting notes
Frank explains the concrete folder/file strategy: product-line folders, Q1 plan markdowns, and reusable templates (e.g., ‘draft short PRD’) to standardize outputs. He also demonstrates a workaround for tools without MCP (Granola) by scripting ingestion of meeting notes into the repo for easy @-reference in agents.
- •Product folders per initiative with planning docs and specs in markdown
- •Reusable PRD templates: problem, narrative solution, heuristics, acceptance criteria
- •Cursor/Claude Code ‘@’ referencing to pull docs into context fast
- •If no MCP exists (Granola), build scripts via Claude Code to ingest notes
- •Centralized repo becomes the single source of product context for agents
- 14:08 – 16:39
Conductor + Obsidian in the workflow: when they matter (and when they don’t)
Aakash asks about additional tools. Frank describes Conductor’s value for parallel coding agents via Git worktrees (avoiding conflicting changes) but notes it’s less critical for most PM tasks; Obsidian is mainly a preference-based markdown editor alternative to working directly in Cursor.
- •Conductor: orchestration for multiple coding agents in parallel
- •Git worktrees prevent conflicting changes across branches
- •PM workflows often don’t require heavy agent orchestration
- •Obsidian: nicer markdown editing UI, same filesystem access
- •Frank prefers staying in Cursor/Claude Code for unified editing + agents
- 16:39 – 19:29
Top 5 analytics + MCP use cases for PMs (the ‘vibe PMing’ stack)
Frank outlines five recurring workflows: anomaly/chart investigation, automated weekly dashboard reporting, qualitative feedback clustering, turning insights into action plans/specs, and routing execution (tickets or prototypes) via Linear/Claude Code/Cursor. This becomes the episode’s core operating model for AI-native PM work.
- •1) Deep chart/anomaly analysis with skills
- •2) Weekly business review automation and dashboard synthesis
- •3) Unified qualitative feedback analysis across channels
- •4) Convert insights into specs/PRDs using heuristics and templates
- •5) Route work: push to Linear/Jira or prototype/code directly
- 19:29 – 23:23
Demo: deep chart analysis from a link (faster than hours of manual slicing)
Frank demos an anomaly investigation: he drops a chart link and triggers his ‘analyze chart’ skill in Claude Code. The agent parses the URL, pulls chart data, explores properties and related charts, and returns hypotheses (e.g., feature flags, tool access changes), showing how taxonomy/context makes the automation robust.
- •Trigger skills via slash commands inside Claude Code
- •Agent navigates Amplitude taxonomy, events, properties, related charts
- •Human equivalent: manually building many chart variations and group-bys
- •Output includes time range, spike timing, evidence, and hypotheses
- •Value scales with semantic/taxonomy infrastructure in the MCP integration
- 23:23 – 29:17
Demo: dashboard summarization + scheduled agents that push insights to Slack/email
Frank shows an ‘analyze dashboard’ skill that fetches charts in batches to manage context limits, applies heuristics by visualization type, and optionally connects quant to qual (feedback, replays, experiments). He then explains Amplitude’s dashboard agents: scheduled monitoring and narrative reports delivered where teams work (Slack/email), reducing synchronous WBR overhead.
- •Dashboard skill: query charts in chunks (e.g., 3 at a time)
- •Heuristics vary by chart type (KPI deltas, bar concentrations, etc.)
- •Natural-language dashboard retrieval requires good search tooling
- •Amplitude dashboard agents can schedule recurring reports
- •Reports are pushed to Slack/email/Teams to meet users in their workflow
- 29:17 – 33:36
Demo: customer feedback analysis across Zendesk/Intercom/Salesforce/Gong (unified)
Frank demonstrates analyzing customer feedback via Amplitude’s AI Feedback product exposed through MCP. The agent can use both pre-processed insights and raw feedback to produce tailored TL;DRs (urgent issues, feature requests, praise, competitor mentions), replacing spreadsheet-based manual aggregation.
- •AI Feedback aggregates feedback from many systems into one place
- •MCP exposes both clustered insights and underlying verbatims
- •Prompts can steer analysis to specific lenses (praise-only, competitors, etc.)
- •Eliminates manual spreadsheet and copy/paste workflows
- •Creates a repeatable weekly feedback digestion routine
- 33:36 – 39:21
From insights to PRDs: generating, reviewing quality, and iterating in Cursor vs Claude Code
Using the feedback output, Frank generates draft specs/PRDs as markdown files, leveraging his repo and templates. They discuss quality tradeoffs (verbosity, model choice like Sonic vs Opus) and why Cursor can be better for targeted edits (highlight + inline instructions) while Claude Code can be more powerful for deeper work.
- •Convert feedback recommendations into PRDs/spec markdown files
- •Quality control: verbosity and prioritization need iteration
- •Model choice matters (speed vs quality)
- •Cursor strengths: IDE UX, line-specific edits, quick refinement commands
- •Claude Code strengths: powerful agent behavior and repo-wide operations
- 39:21 – 40:19
Routing execution: pushing to Linear, messaging engineers, or prototyping in code
Frank describes the final step: decide whether to route the work to a team (e.g., via Linear MCP) or prototype/build directly using coding agents (Cursor/Claude Code) or even Slack-based agent requests. They also cover using GitHub branches to manage changes and how a product repo enables work from mobile via the Claude app.
- •Options: file Linear tickets, message engineers directly, or prototype in code
- •Using Linear MCP for trackable, longer-running coordination
- •Slack-based interactions can remove ticketing overhead for small tasks
- •Branching: changes are local until pushed to GitHub
- •Keeping product context in GitHub enables mobile/asynchronous work via Claude
- 40:19 – 45:09
Biggest MCP mistakes + defending MCP as a standard (tools bloat, expectations, dynamic tool calling)
Frank names two major mistakes: expecting MCP to “do everything” (rather than connect systems) and connecting too many irrelevant MCP servers/tools that waste context and degrade outputs. He addresses common criticisms (hype, context waste, auth pain, config complexity) and explains mitigations like better client setup flows, tool optimization, dynamic tool calling, and Skills loading only when relevant.
- •Mistake #1: wrong expectations—MCP connects systems; it’s not the whole workflow
- •Mistake #2: tool overload—irrelevant tools increase latency and confusion
- •Optimize tool names/descriptions/instructions to reduce ambiguity
- •Ecosystem convergence: MCP is broadly adopted across major AI clients
- •Dynamic tool calling + Skills reduce context waste and improve reliability
- 45:09 – 49:54
What Amplitude is shipping: global agent, specialized sub-agents, MCP everywhere, Slack integration
Frank previews Amplitude’s upcoming agents launch, describing it as their “Cursor moment” for analytics—raising the floor for non-experts and the ceiling for power users. He outlines four pillars: an embedded global agent across the platform, specialized sub-agents (dashboards, replays, feedback, website optimization), MCP as the foundation for internal/external workflows, and availability in Slack so teams can query and act without living in the UI.
- •Global embedded agent across Amplitude with page/context awareness
- •Sub-agents: dashboard monitoring, session replay analysis, feedback analysis, website optimization
- •MCP underpins both internal agents and external client workflows
- •Power users mix Amplitude data with other systems for bespoke automations
- •Slack-first access: ask questions, get analysis, and take actions directly from chat
- 49:54 – 53:10
Where to learn more + closing: ‘vibe PMing’ as the future operating model
Frank shares where to find the launch and contact him; Aakash closes by summarizing the end-to-end workflow from analysis to action and urging teams to equip PMs with Claude Code/Cursor/GitHub access. He plugs follow-up resources (newsletter, other tutorials) and final subscription/bundle reminders.
- •Links: amplitude.com and amplitude.com/ai; Frank on Twitter/LinkedIn
- •Recap: chart analysis → reporting → feedback themes → PRDs → tickets/prototypes
- •Organizational enablement: get tools approved via IT/security
- •Positioning: this is how PM work shifts in the next few years
- •Wrap-up calls to subscribe/follow and check bundled tool offers
