How I AI“Vibe analysis”: How Faire uses Cursor, enterprise search, and custom agents to analyze data
CHAPTERS
- 0:00 – 8:47
Vibe analysis starts with context: using enterprise AI search to generate hypotheses fast
Tim frames “vibe analysis” as the new way to rapidly gather context before touching any data. He demonstrates starting from a metric drop and using Notion’s enterprise AI search across Slack/Notion/Jira to quickly surface plausible launch/experiment culprits.
- •Analytics is more than crunching numbers—context and hypothesis generation are the hardest parts
- •Enterprise AI search can scan internal tools (Slack/Notion/Jira) to propose likely causes of metric shifts
- •A focused query scoped to a date range prevents “cheating” with future info
- •Quick follow-up questions (e.g., “What is EORI?”) deepen understanding without manual digging
- 8:47 – 9:48
From PRD to reality: investigating what actually shipped by querying the codebase
Tim explains why documentation alone is insufficient: implementation details and rollouts often differ from PRDs. He introduces using AI to “talk to the codebase” so non-engineers can trace real changes and retailer impact.
- •Between PRD and code, many changes can alter the customer experience
- •Non-technical roles can now access technical truth via AI-assisted code search
- •Forensic code investigation helps identify which changes align with metric drops
- •Code history becomes a primary data source for product analysis
- 9:48 – 12:43
Demo: ChatGPT Deep Research for GitHub forensics (incident-style tracing)
Tim runs a Deep Research prompt in ChatGPT with GitHub connected to produce a time-sequenced report of EORI checkout changes. Claire highlights the incident-response value: quickly tracing what changed, when, and by whom, even during sev events.
- •Deep Research can search private GitHub repos when connected and authorized
- •Prompt structure: role assignment, time window, and report format requirements
- •Outputs aim to translate commits/PRs into user-experience impact in plain language
- •PMs can contribute during incidents by generating background change timelines
- 12:43 – 14:10
Cursor as the “ultimate context engine”: faster code analysis + MCP extensibility
Tim shows the same forensic prompt in Cursor and argues it often produces quicker, higher-quality results. The key claim: Cursor shines as a context engine—especially when combined with MCP connections to internal systems.
- •Shift from prompt engineering to context engineering
- •Cursor can rapidly assemble PR/commit tables with links and interpreted impacts
- •MCP hookups expand Cursor beyond code into business systems and data tools
- •Using AI output, teams can jump straight to targeted conversations with owners
- 14:10 – 19:20
Onboarding and access: why PMs/designers need GitHub read access now
Claire and Tim discuss operational implications: code is now a broadly useful data source, not just for engineers. They argue onboarding should include repo access and tooling setup so cross-functional partners can self-serve context during analysis.
- •GitHub/local repo/MCP setup should be part of non-engineer onboarding
- •Broad system access accelerates learning and reduces dependency bottlenecks
- •AI tools turn codebases into queryable knowledge bases for the whole org
- •Faster context gathering improves depth and speed of product decisions
- 19:20 – 25:13
Feature performance analysis end-to-end: Cursor to understand the flow and event instrumentation
Alexa walks through evaluating a redesigned signup flow without an A/B test (before/after comparison). She uses Cursor to read the codebase, identify eligibility rules, step ordering, and the exact analytics events needed for funnel measurement.
- •Cursor translates code into natural language: who sees the flow, steps, success criteria
- •Understanding event emission and step order is essential for valid funnel analysis
- •AI reduces reliance on outdated docs or pinging engineers for implementation details
- •Follow-up idea: use AI to audit whether tracking is sufficient and schemas are normalized
- 25:13 – 26:14
Generating, running, and QA’ing SQL with Snowflake MCP (and why comments matter)
Alexa uses Cursor to generate a funnel SQL query and run it directly via the Snowflake MCP, avoiding copy/paste and context switching. She emphasizes analyst responsibility for QA and explains her practice of forcing the agent to comment each CTE for reviewability.
- •Snowflake MCP enables write → execute → inspect results inside Cursor
- •Agent can self-QA via output sniff tests, but humans remain accountable
- •Cursor rules can enforce conventions like commenting every CTE
- •Over-commented AI-generated code can improve handoffs and future AI edits
- 26:14 – 34:17
Why semantic layers supercharge AI analytics (zero-shot SQL that actually works)
Alexa explains how Faire’s semantic layer translates business concepts into structured definitions LLMs can use (tables, joins, metrics, filters). A general layer enables company-wide self-serve, while specialized layers improve deeper analysis within a domain.
- •Semantic layers map business terms to canonical tables/fields/metrics for LLM comprehension
- •General semantic layer democratizes basic data questions across the company
- •Specialized semantic layers per scope increase accuracy for complex domain analysis
- •LLMs can help generate semantic layers from prior queries and warehouse knowledge
- 34:17 – 37:19
Mode MCP: AI reads dashboards and drafts takeaways + next steps
After building dashboards in Mode for legacy vs. new flows, Alexa uses the Mode MCP so Cursor can inspect the dashboard and underlying SQL. The agent produces structured insights, concerns, and actionable next steps as a first-pass analysis.
- •Mode MCP lets AI view and reason over dashboards directly
- •Agent can synthesize funnel results into narrative takeaways and recommendations
- •Dashboards become inputs to higher-level analysis, not just outputs
- •This workflow pushes analysts toward strategy rather than query mechanics
- 37:19 – 44:55
Notion MCP: turning analysis into exec-ready docs (with human revisions)
Alexa uses Notion MCP to create a structured document following Faire’s writing principles and templates. She notes AI speeds drafting and iteration, but executive-ready narratives still require multiple human revision passes and judgment.
- •Notion MCP automates publishing analysis in the org’s preferred doc format
- •Embedding style guides/templates improves consistency and readability
- •AI helps analysts step back, find gaps, and refine the story
- •Human “je ne sais quoi” still needed for final exec-quality output
- 44:55 – 53:33
Custom agents for experiment write-ups: Eppo + Notion automation at scale
Tim demonstrates a Cursor agent driven by a rules (MDC) file to automate experiment result documentation. The agent pulls experiment results from Eppo, gathers context from Notion, formats the write-up consistently, and posts a shareable doc (plus a Slack snippet).
- •Rules files (MDC) provide step-by-step agent behavior in plain English
- •Agent workflow: ask for experiment name → pull Eppo metrics → fetch context docs → draft write-up
- •Standardized format includes confidence intervals, key metrics, and rollout recommendation
- •Automation reduces low-value formatting work and prevents analytics becoming a velocity bottleneck
- 53:33 – 1:00:41
Survey design + analysis speedrun: ChatGPT Projects turns hypotheses into Qualtrics + insights
Tim shows using ChatGPT Projects to design a 10-minute customer survey from a set of hypotheses, generate a Qualtrics coding file, and outline an analysis plan. He then demonstrates AI-assisted analysis of messy Qualtrics exports to evaluate hypotheses with confidence ratings.
- •Projects provide persistent context via uploaded strategy docs and hypothesis lists
- •AI can generate survey questionnaires, platform coding files, and analysis plans together
- •Raw survey exports are messy; AI can rapidly summarize and map results back to hypotheses
- •Outputs include a proved/neutral/disproved table with confidence scores to guide deeper follow-up
- 1:00:41 – 1:03:28
Lightning round: troubleshooting prompting failures + hiring and wrap-up
Alexa shares her go-to fix for long, drifting chats: summarize and restart with the summary for renewed context. Tim describes running the same prompt across multiple models/chats to compare outputs, and the team closes with where to find them and Faire hiring.
- •When models get “wonky,” summarize the thread and restart with distilled context
- •Parallel prompting across models can function like an A/B test for quality
- •Emphasis on democratizing analysis—more people can write SQL and produce insights
- •Closing: LinkedIn contacts, Faire careers, and final show outro
