I spent a week pointing a "Ralph Wiggum loop" at my product to see how far an agentic AI could take pragmatic, everyday improvements without human micromanagement. It was equal parts exhilarating and nerve-wracking. The short version: the loop moved fast and broke assumptions, but Amplitude analytics kept it from going off the rails—and turned chaos into controlled acceleration.
By "Ralph Wiggum loop," I mean a deliberately naive, endlessly curious cycle: try something small, ship it behind a flag, watch the data, then try again. It is the product equivalent of a fearless intern who experiments constantly. That energy is invaluable for discovery, but it absolutely demands strong guardrails and a clear definition of success.
Before I started, I framed the outcomes I cared about: user activation within the first session, reduction in time-to-value, and early retention indicators. I set baselines and a minimum detectable effect (MDE) for A/B testing so the loop could distinguish noise from signal. I also documented a driver tree of behaviors we wanted to influence and ensured every event was cleanly instrumented in Amplitude analytics to support reliable behavioral analytics.
The guardrails mattered most. I put every change behind feature flags with instant rollback. I defined "off the rails" conditions upfront, including regression thresholds for activation and retention analysis, and enabled anomaly detection to surface unexpected spikes or drops. Session replay was ready to diagnose confusion fast, and I kept a daily evaluation cadence so the loop never ran unattended for long.
Day by day, the loop proposed micro-experiments: onboarding copy variants, tooltip timing, in-app guide sequencing, and subtle changes to progressive disclosure. Each iteration shipped behind a flag to a small cohort. I watched leading indicators in real time, then zoomed out to cohort views to guard against short-term gains that might erode longer-term value. When something looked promising, we expanded exposure methodically; when something looked risky, we paused immediately.
We had a pivotal moment where the loop suggested a bolder call-to-action that spiked activation. On the surface, it looked like a win. Amplitude cohorts told a fuller story: downstream engagement softened, and anomaly detection flagged a pattern that hinted at premature conversion rather than genuine intent. A quick rollback through feature flags saved the week—and reminded me why eval-driven development should be the default for agentic AI workflows.
The most surprising part was how quickly the loop unlocked small compounding gains once the measurement scaffolding was in place. With a unified analytics platform and crisp guardrails, the system became a safe sandbox where the AI could explore aggressively while we stayed anchored to outcomes. The combination of behavioral analytics, A/B testing discipline, and daily human review turned raw speed into durable learning.
My takeaways are direct. Agentic AI can accelerate discovery, but only if you define stop conditions and wire strict feedback loops into your stack. Measurement is product strategy here—without it, you get noisy activity instead of progress. Invest in instrumentation first, treat feature flags as non-negotiable, and let anomaly detection and session replay be your early warning system. Most of all, tie every experiment to activation, engagement, or retention, not vanity metrics.
If you’re considering your own week with a "Ralph Wiggum loop," start painfully small, constrain the blast radius, and insist on decision-quality data. Do that, and you’ll turn a chaotic agent into a compounding engine for product discovery—one that moves fast, learns faster, and stays on track.
Inspired by this post on Amplitude – Perspectives.
When I consider where product development is headed, one statement captures the mandate perfectly: "Eric Carlson is a Principal AI Engineer helping to shape and build Amplitude's next generation vision of of agentic and data driven product development." That vision resonates deeply with how I lead teams—anchoring strategy in behavioral analytics while enabling agentic AI to act on insights with speed, safety, and measurable impact.
Translating that vision into execution starts with clarity of outcomes. I frame driver trees that connect customer value to leading indicators—activation, engagement depth, and retention—then instrument product telemetry with Amplitude analytics and behavioral analytics to surface the moments that matter. From there, we operationalize learning with A/B testing and feature flags, ensuring each hypothesis gets a fair, observable run and that we can safely ramp what works.
Agentic AI changes the operating model. Instead of static dashboards, we design autonomous workflows that observe signals, reason over context, and take action—grounded in a retrieval-first pipeline and governed by eval-driven development. For product managers, this demands fluency with LLMs for product managers and practical prompt engineering, plus rigorous AI Strategy around data governance, privacy-by-design, and risk scoring so agents remain trustworthy under real-world conditions.
Cross-functional cadence is everything. I partner closely with Principal AI Engineers and product trios to blend continuous discovery with execution: rapid user interviews to reveal intent, opportunity solution trees to prioritize, and outcomes vs output OKRs to align incentives. The result is a system where insights are unified, decisions are explainable, and agents improve through tight feedback loops across analytics, experimentation, and production telemetry.
If you’re building toward an agentic, data-driven future, invest in a unified analytics platform, shorten the path from signal to action, and measure learning velocity as carefully as feature delivery. With the right foundations, agentic AI becomes more than a feature—it becomes a force multiplier for product strategy, customer value, and sustainable growth.
Inspired by this post on Amplitude – Perspectives.
I just wrapped an all-out engineering sprint. That still sounds odd coming from me, because while I’ve written code on and off for years, I don’t self-identify as an engineer. I’m a product manager who used to be a designer. It’s been a long time since I wrote code for a living.
But AI has expanded what’s just now possible—for our products, and for us. It’s pushed me to do more than I imagined. In that spirit, I want to share a recent engineering story. It includes technical details, and a year ago I couldn’t have done any of it. I learned it with the help of AI, and my aim is to show what’s now within reach.
I’ve been building two services with a partner at Vistaly: AI-generated interview snapshots and AI-generated opportunity solution trees. We put out a call for alpha partners, received over 100 applicants, and selected eight design partners to start.
A clear, color‑coded map from desired outcome to opportunities, solutions, and assumption tests—showing how to structure discovery work and prompt AI to generate, compare, and validate product ideas.
Each team uploaded three customer interviews. I identified the key moments and opportunities and then generated an opportunity solution tree from those snapshots. I provide the AI services; Vistaly is building the UI and workflows around them.
Early feedback was strong. Teams immediately asked to upload more interviews—exactly the kind of demand signal you hope to see—so we got to work making that possible.
Go behind the scenes as AI turns raw feedback into a clear Opportunity Solution Tree. Linked cards reveal user needs—onboarding, support offload, and bot-readiness signals—so product teams can spot priorities and next steps at a glance.
Updating an opportunity solution tree with new interview content is far harder than generating a new tree from scratch. I initially underestimated the complexity. Our goal wasn’t to produce a tree and declare it truth. We wanted teams to engage, correct, and collaborate with the AI—scaffolding cross-interview synthesis instead of doing it for them.
To support that, we needed a way to communicate precisely how a tree would change after new interviews were added. We took inspiration from git diff and set out to build the equivalent for opportunity solution trees—step-by-step change sets that explain each proposed modification.
A clear visual of AI‑generated opportunity solution trees: outcomes feed opportunities that branch into sub‑opportunities, while evidence is preserved. The structure ensures updates stay traceable and never cause data loss.
That decision was right, but the lift was larger than I expected. It wasn’t enough to generate an updated tree; I also had to provide a clear, ordered walkthrough of what changed and why.
I often see the same pattern with AI: it’s easy to get to an impressive prototype, but much harder to reach a production-grade product. That was exactly my experience here. My service actually comprised two sub-services: generating a new tree from scratch and updating an existing tree with new interviews. The first worked well in alpha; the second had to be built before anyone could add a fourth interview.
Explore how an outcome expands into an Opportunity Solution Tree: Opportunities A and B stem from the goal, with C and D nested under B, while a concise change set tracks every node added along the way.
On the surface, these services look similar. In reality, updates must preserve existing structure unless new evidence requires a change. You have to account for compound operations—merges, splits, deletes—while guaranteeing no data loss. Every node has source opportunities (supporting evidence from interviews) and children (tree sub-opportunities), and neither can be dropped.
In classic AI fashion, I got a reasonable version working in a few days and shipped it to our design partners. One team quickly hit our beta limits and asked to convert to a paid subscription so they could keep going. They showed a willingness to pay, converted, and started uploading aggressively.
Watch an Opportunity Solution Tree evolve: the original parent A with x, y, z branches is split into A and B, shifting evidence while preserving links—mirroring how AI refines scope and structure in discovery.
At the 14th, 15th, and 16th uploads, the cracks appeared. We saw odd behavior in some trees. The Vistaly team noticed that the change sets—the step-by-step instructions emitted by my service—didn’t always reconstruct the final tree my service also emitted. We needed those steps to match exactly, so teams could review and accept, modify, or reject each change with confidence.
They flagged the issue the day I was flying to New Orleans for Jazz Fest. In hindsight, I’m glad I didn’t grasp the scope of what awaited me. I had roughly 80% of the work still to do to make tree updates rock solid. At least I got to enjoy the music first.
From fragments to focus: this diagram shows how Opportunities B and C are merged into a single Opportunity Solution Tree, removing duplicates and unifying context so AI can rank and explore five related opportunities with clarity.
Back home, I started diagnosing. My service was a pipeline: several LLM-driven steps followed by deterministic code to compare trees and produce change sets. As I dug in, I realized that approach was flawed. Tree diffs, unlike linear document diffs, are ambiguous.
In a document, if I add a sentence, the diff shows an addition. If I delete a paragraph and rewrite it, the diff shows a removal and an addition. Simple. But trees are different. Suppose I split opportunity A into A and B, and later merge B with C. The split can disappear from the final diff.
Peek inside our process: a simple opportunity solution tree maps an outcome to prioritized opportunities A and C with downstream options x-z and t-v. A clear snapshot of how AI organizes product discovery.
When the model splits an opportunity, it must distribute A’s source opportunities and children between A and B. For instance, if A has source opportunities 1, 2, 3 and children x, y, z, after the split A might keep 1, 2, and x, while B takes 3, y, and z.
Now suppose the model merges B into C. If C originally had source opportunities 4 and 5 and children t, u, v, then after the merge C now has source opportunities 3, 4, 5 and children t, u, v, y, z. When you compare the original and final trees, it looks like A somehow donated some evidence and children directly to C. The split and merge that explain why are invisible to a naive diff.
See how an AI-generated Opportunity Solution Tree unfolds: one Outcome flows to Opportunities A and C, then into options x–v. Clean colors and arrows reveal the hierarchy from goal to opportunities at a glance.
That was the core insight: we didn’t just need to show what changed—we needed to show why it changed. I had to reconstruct each move step-by-step. That meant getting the model to show its work, which opened a new can of worms.
I refactored my prompts so the model produced both the final output and the exact change set it used to get there. The action language was explicit: add, delete, reframe, merge, split, and so on. Crucially, I asked the model to describe its moves in user-meaningful terms—“split A into A and B, then merge B into C”—not as opaque reassignments of sources and children.
Watch an opportunity solution tree take shape: start with the outcome, add opportunities A and B, then extend B to C and D. The paired change set makes every edit transparent—ideal for AI-assisted product discovery.
For each LLM step, the model now emitted its recommendation and the corresponding change set. This helped, but it wasn’t perfect. After extensive testing and error analysis, two classes of errors emerged: (1) the model attempted an invalid move, and (2) the change set didn’t actually generate the recommendation.
Category 1 felt like designing a game while the model played it creatively. For example, what happens when the model tries to merge a parent with a child? If opportunity A has children B, C, and D and the model merges A with B, the merge is directional. If the instruction is “keep A, delete B,” that works—the parent absorbs the child. But if the instruction is “keep B, delete A,” then C and D become orphans. These puzzles were solvable and even fun.
Visual explainer from Product Talk on AI-generated Opportunity Solution Trees. It contrasts an allowed merge (B into A) with a not-allowed merge (A into B) that leaves child opportunities orphaned, guiding safe hierarchy edits.
Category 2 was harder. Despite prompt iterations, I could only push the discrepancy rate down to about 1 in 40 instances. With 10–20 LLM calls per run, that meant roughly half of all runs still failed. Not acceptable for production. I hit a wall. A paying customer was waiting, and more design partners were queued up.
Next, I tried to correct the model’s mistakes with deterministic code. I had promised that my change sets would generate the output tree, so I wrote verifiers: detect conflicts (e.g., delete a node, then try to use it later), guard against data loss, prevent orphaned nodes, and more. Detection was straightforward; correction was not. Fixing issues required guessing the model’s intent. If the sequence said “delete A, then merge A with B,” should I remove A entirely or salvage A’s sources and children by merging into B? There were dozens of such cases with no unambiguous answer.
A step-by-step loop shows how changes are validated: generate a change set, run a validation tool, review the result, then repeat on failure and exit on pass—mirroring iterative work behind AI-built Opportunity Solution Trees.
After 11 straight days of deep work—including weekends—I was exhausted. I dislike hustle culture; this isn’t how I design my life. But I was stuck, and then I had an insight.
On a walk with my husband (also an engineer), I realized I could have the LLM repair its own mistakes. My data contract with Vistaly requires that the change set must generate the output tree. I had already built robust validation code. I knew exactly when a change set failed—and why. No amount of prompt tuning alone was fixing it. So I turned the validator into a tool for the model and created a simple agentic loop.
The loop works like this: the model proposes a change set, calls the validation tool, and gets back a pass/fail plus specific feedback. If it fails, the model uses those instructions to repair the change set and calls the tool again. Iterate until success or a max number of turns.
I prototyped in Node.js with a single model call, a verifier pass, and a repair attempt. At first, the loop didn’t converge—it just accumulated compute. I experimented with how to communicate errors, how much context to include, and how to sequence feedback. Eventually, it clicked: the model began fixing its own mistakes and typically returned a valid change set in one or two repairs. It was, in practice, eval-driven development applied to LLM outputs.
I had already built an agent loop utility for another AI workflow, so I productionized quickly: model call, optional tool invocation, tool result returned to the model, repeat until the validator signals success or the loop times out. I integrated the new loop into the pipeline and shipped the revamped service to Vistaly on Monday at noon. They’re integrating now, and it will be in the hands of our design partners shortly. I’m relieved—and ready for a day off.
Reflecting on the last two weeks, a few things stand out. First, I shed limiting beliefs about being an engineer. To make this reliable, I had to solve legitimately hard problems, and that feels good.
Second, this was genuinely fun. Designing the action set and watching the model push those boundaries was like working through elegant puzzles. Models are incredibly creative, and harnessing that creativity with the right constraints is deeply satisfying.
Third, I learned when I can and can’t trust Claude to write code for me. Since Opus 4.6 came out, I gave Claude a much longer leash. After the past two weeks, Claude is back on a short leash. I found a lot of gaps in my implementation in areas where I simply trusted that Claude got it right, when in fact it didn’t. If you don’t have the right infrastructure—planning, testing, code review—this can be disastrous. I’ll be investing more here and sharing what I learn.
Finally, if this work had been spread over two months, it would have been thoroughly enjoyable. I’m discovering how much I like being an AI engineer. It feels like a new chapter where I can combine opportunity solution trees with modern AI engineering—and deliver real value to product teams doing continuous discovery.
I’m excited to share more of what we’re building with Vistaly and to onboard more design partners soon. If you’re interested, get on the waiting list. And if you’ve been hesitant to stretch beyond your current skill set, I hope this story nudges you to take the first small step toward what’s just now possible.
I’ve spent my career building products that move the needle, and as a Principal Product Manager and product leader at HighLevel, I focus on the work that compounds: clear strategy, rigorous discovery, and measurable outcomes. My role is to turn ambition into traction by aligning vision with execution, then proving impact with data, not anecdotes.
Great product strategy starts with customer value and ends with business results. I frame the narrative around a defensible value proposition, clarify points of parity and points of differentiation, and translate that into driver trees tied to outcomes vs output OKRs. This creates line-of-sight from our roadmap to metrics that matter—Net Recurring Revenue (NRR), activation, retention, and expansion—so teams know exactly why their work matters.
Discovery is continuous, not a phase. I partner in product trios to run continuous discovery through customer interviews, journey mapping, and an opportunity solution tree that separates signal from noise. By keeping a weekly cadence of learning, we reduce risk early, refine problem statements, and ensure we’re solving the highest-leverage jobs to be done for our customers.
Evidence beats opinion, so I obsess over instrumentation and experimentation. I rely on Amplitude analytics for behavioral analytics, cohorting, funnel health, and retention analysis, and I validate hypotheses with A/B testing designed around a minimum detectable effect (MDE). With feature flags, we decouple deployment from release, ramp value safely, and learn fast without exposing the entire base to risk.
Execution only works when planning is pragmatic and transparent. I run product roadmapping and sprint planning as living systems informed by discovery insights and real usage data. That means tighter stakeholder management, clearer trade-offs, and fewer surprises for go-to-market partners—so we ship confidently and tell a crisp story from beta through scale.
I also apply modern AI practices where they create real leverage. For exploration and prototyping, I use gen ai for product prototyping and practical workflows from LLMs for product managers to accelerate research synthesis, scenario mapping, and content generation—always with human-in-the-loop judgment, data governance, and privacy-by-design as non-negotiables.
The result is a disciplined, human-centered, and data-powered approach. I build empowered product teams that learn faster than the market, align on few-but-mighty bets, and compound outcomes over outputs. That’s how a Principal Product Manager consistently turns strategy into durable, product-led growth.
Inspired by this post on Amplitude – Perspectives.
In my role leading product teams, I’m relentless about freeing time for high-leverage work—clarifying strategy, sharpening positioning, and unblocking execution. Claude Cowork has become a reliable AI partner in that mission, helping me automate repeatable tasks while preserving judgment for the decisions that matter most.
Get 5 playbooks to automate common product management tasks with Claude Cowork and free yourself for higher-leverage PM work.
When I say “playbooks,” I mean structured, repeatable workflows that turn messy inputs into crisp outputs—without sacrificing rigor. With agentic AI, LLMs for product managers, and thoughtful prompt engineering, these playbooks plug directly into my product roadmapping and sprint planning process, accelerating discovery, analysis, and stakeholder alignment.
Playbook 1: Continuous discovery synthesis. I route raw customer interviews, support threads, and behavioral analytics into Claude Cowork to cluster themes, extract Jobs-to-Be-Done, and propose opportunity areas. It drafts an initial opportunity solution tree with clear problem statements, target outcomes, and candidate solutions, which I then refine with the team. This shortens the loop between customer interviews and actionable insights while preserving the nuance that continuous discovery requires.
Playbook 2: Strategy-to-roadmap alignment. Starting from our product strategy and target outcomes, I ask Claude Cowork to translate goals into a prioritized roadmap, calling out outcomes vs output OKRs and showing driver trees that connect initiatives to measurable impact. It flags dependencies and suggests stakeholder management touchpoints, making the narrative behind prioritization transparent and easier to socialize across product trios and leadership.
Playbook 3: Experiment design and A/B testing. To move from ideas to evidence, I have Claude Cowork generate testable hypotheses, success metrics, and guardrails for A/B testing. It produces experiment briefs, checks statistical assumptions like minimum detectable effect (MDE), and suggests instrumentation plans for tools such as Amplitude analytics. I use these drafts to speed up reviews without compromising on methodological rigor.
Playbook 4: Launch communications and in-product guidance. After we ship, I leverage Claude Cowork to assemble UX writing, release notes, and in-app guides tailored to user segments. It proposes short product tours, contextual tooltips, and support macros that keep messaging consistent across Pendo or Intercom while reinforcing our value proposition. The result is faster, more cohesive go-to-market execution with fewer round-trips.
Playbook 5: AI risk, governance, and quality checks. Before anything goes live, I use Claude Cowork to run structured reviews for data governance, privacy-by-design, and AI risk management. It helps draft acceptance criteria, red-team prompts for edge cases, and an eval-driven development checklist so the team can track model behavior and mitigate regressions over time. These safeguards maintain trust as we scale AI workflows across the product surface.
To make these playbooks sing, I seed Claude Cowork with a retrieval-first pipeline of canonical docs—vision, strategy, OKRs, analytics dashboards, and definition-of-done checklists—plus prompt templates tuned for our voice and review standards. Tight context window management, explicit role instructions, and lightweight evaluations keep outputs accurate, auditable, and on-brand.
The impact has been compounding: faster discovery-to-decision cycles, clearer roadmaps tied to outcomes, stronger experiments, and launch content that lands. Most importantly, the team spends more time on creative problem solving and stakeholder partnership, not manual synthesis or formatting. If you’re ready to reclaim your calendar and elevate your product strategy, start with these five Claude Cowork playbooks and iterate from there.
Inspired by this post on Amplitude – Perspectives.
When our cloud costs started outpacing growth, I knew we had to make a decisive call on “build vs buy.” Buying a FinOps platform would have been faster on paper, but it wouldn’t internalize our operational nuance. Building an agentic AI layer on top of our cost, telemetry, and product usage data promised not just dashboards—but compounding leverage. Less than a year later, our homegrown approach outperformed off‑the‑shelf alternatives on speed, precision, and organizational adoption.
The aspiration was clear from the outset: See how Amplitude scaled FinOps with AI agents—cutting manual work, accelerating insights, and turning a one-person function into a cost optimization engine. We set that as a bar for both outcomes and operating cadence, then translated it into a roadmap grounded in first principles.
Our build vs buy analysis hinged on three factors. First, cloud cost optimization is only as good as the context it carries; we needed deep hooks into our pricing, feature flags, and deployment frequency to reason about unit economics in real time. Second, we required agentic AI workflows that could detect anomalies, recommend actions, and close the loop—not just visualize waste. Third, governance mattered: privacy‑by‑design, data governance controls, and transparent decision logs were non‑negotiable under our AI Strategy and product management leadership standards.
We architected a retrieval‑first pipeline to blend billing exports, usage telemetry, and observability signals with product and GTM metadata. Agent workflows ran on top: one agent built driver trees that explained spend shifts by service, customer cohort, and environment; another specialized in anomaly detection with confidence scoring; a third agent proposed commitment strategy, rightsizing, and schedule adjustments. Each recommendation linked back to source data for auditability.
From a delivery standpoint, we treated the system like a product, not a tool. A product trio (PM, engineering, and FinOps) ran continuous discovery interviews with stakeholders, instrumented eval‑driven development for agent prompts, and shipped improvements via CI/CD weekly. We optimized prompt engineering for decision clarity over verbosity and codified acceptance criteria: time‑to‑insight, actionability, and measurable savings per recommendation.
The impact was immediate and then compounding. Manual effort on month‑end analysis shrank as agents pre‑triaged drift and surfaced root causes with suggested remediations. Insights arrived continuously, not as end‑of‑month surprises, which meant engineering could fold changes into regular sprints. What started as a one‑person FinOps function evolved into a cost optimization engine embedded across teams—product, SRE, and finance—all speaking a shared language of drivers, tradeoffs, and outcomes.
Along the way, we learned where building truly beats buying. If your architecture, pricing model, and growth loops are unique—and they usually are in consumption SaaS—agentic AI amplifies institutional knowledge in a way generic platforms can’t. Conversely, if you lack clean tagging, clear ownership, or basic observability, investing there first will raise ROI on any approach, built or bought.
My advice if you’re at this crossroads: define success in terms of decisions changed, not reports shipped. Start with a thin slice—anomaly detection plus one high‑leverage remediation path—then iterate. Keep humans in the loop for executive sign‑off until your confidence intervals and post‑action telemetry prove reliability. With the right guardrails and focus, in‑house AI FinOps can move faster than the market and pay for itself well within a year.
Inspired by this post on Amplitude – Perspectives.
Feature launches move fast, and the Slack channel is our command center. Recently, I leveled it up with agentic AI so every data question, feature flag decision, and post-launch readout lives in one trusted place—faster, clearer, and with less operational drag on the team.
Learn how to set up your launch Slack channel so agents handle your data questions, feature flags, and post-launch readouts in one place.
Here’s the strategy I use. I treat the launch Slack channel like a real-time control room: agentic AI handles the repetitive asks, experts handle the judgment calls, and stakeholders stay aligned through crisp, automated summaries. The result is tighter stakeholder management, quicker go/no-go calls, and fewer meetings—without sacrificing data quality or governance.
First, I set clear channel rituals. I name the space #launch-[feature], declare scope and SLAs, and pin the success metrics, dashboards, and rollout plan. Product, engineering, data, support, and GTM all join. I keep threads focused: one for metrics, one for incidents, one for enablement, one for feedback. This small bit of structure makes agent responses and human follow-ups easy to find.
Next, I add a data questions agent. The agent connects to approved sources and answers the most common queries—activation by cohort, conversion by segment, latency by region—directly in-thread with citations and timestamps. When the question requires nuance, the agent routes to an owner and posts a handoff note, preserving context. This keeps our AI workflows safe and reliable while giving the team quick visibility.
Then I wire in a feature flags agent. It exposes read-only status by environment, shows rollout percentages, and links to change history. When a toggle is requested, the agent enforces approvals and logs who asked, who approved, and why. We can pause, ramp, or roll back in seconds—with auditability intact. Feature flags become an operational muscle instead of a bottleneck.
Finally, I schedule post-launch readouts. The readout agent publishes T+1 hour, T+24 hours, and T+7 days summaries: adoption, performance, anomalies, and key learnings. It highlights A/B testing results, flags outliers, and threads follow-up actions to owners. The team gets a single source of truth for post-launch readouts without scrambling across tools.
Governance matters. I apply role-based access, protect PII, and make the agent cite sources so we can trust what we see. I use Agent Analytics to monitor response accuracy, deflection, and time-to-answer, then refine prompts and permissions. This is practical AI risk management: clear boundaries, human-in-the-loop for consequential decisions, and transparent logs.
The impact has been real: faster decisions during go-to-market, fewer pings to data and engineering, and higher confidence in our product management rituals. Centralizing “questions, flags, and readouts” in Slack doesn’t replace expertise—it frees it to focus on the hard problems.
If you’re rolling this out, start small: define the channel, pin your metrics, launch the data agent with a handful of approved queries, add the feature flags agent with strict approvals, and automate a simple daily readout. Iterate weekly. Within one or two launches, you’ll feel the compounding benefits.
Inspired by this post on Amplitude – Best Practices.
I lead Growth & AI at Amplitude, where I focus on viral and core growth strategies, user acquisition, and product engagement. My north star is to architect durable growth loops that compound over time while elevating the customer experience—from the first onboarding moment to deep, habitual use.
Day to day, I combine Amplitude analytics and behavioral analytics to power product-led growth. By instrumenting the right events, mapping activation journeys, and running disciplined A/B testing, I drive user activation and accelerate time-to-value. That work extends into onboarding, in-app guides, and retention analysis, ensuring we optimize not just for acquisition but also for sustainable engagement and expansion.
On the AI front, I define and execute the AI Strategy that responsibly applies gen ai and LLMs for product managers to increase experimentation velocity and personalize experiences at scale. This includes deploying intelligent nudges, next-best actions, and adaptive UX while honoring privacy-by-design and strong data governance practices. The outcome is a feedback-rich system that learns from user behavior and continuously improves product-market fit signals.
My playbook is simple but rigorous: align on a clear North Star, translate it into activation and retention metrics, size lift using minimum detectable effect (MDE), and iterate fast with product trios. I use an opportunity solution tree to prioritize bets, validate with continuous discovery, and then harden winning patterns into repeatable growth loops. This approach keeps teams focused on outcomes, not output, and creates a shared language across product, design, data, and engineering.
If you’re exploring how to scale product-led growth with AI, this is the path I follow: turn rich product analytics into actionable insights, test with scientific precision, and ship experiences that feel personal, timely, and trustworthy. The result is a growth engine that compounds—driving efficient acquisition, stronger activation, and enduring product engagement.
Inspired by this post on Amplitude – Best Practices.
Data has always been my compass for building products that customers love and businesses depend on. Few sentences distill that imperative as crisply as the one below—and it continues to inform how I prioritize, experiment, and scale outcomes across the roadmap.
Krista is a digital analytics leader, product strategist, and industry evangelist. She helps businesses use data to drive growth, retention, and monetization.
That mandate mirrors how I run product: leverage behavioral analytics to uncover patterns, translate those insights into hypotheses, and validate them through rigorous A/B testing. I start by instrumenting the user journey end to end, then use cohort analysis, funnel diagnostics, and retention analysis to pinpoint where activation, engagement, or monetization is stalling. From there, I map driver trees to connect inputs (feature adoption, time-to-value, onboarding friction) to outputs (retention, conversion, revenue), so every experiment has a clear line of sight to business impact.
On experimentation, I hold the bar high: define the minimum detectable effect (MDE) up front, ensure clean experiment design, and size samples to reduce noise. I combine Amplitude analytics with qualitative signals from continuous discovery to prioritize tests that move the needle, not just the vanity metrics. When a variant wins, I don’t stop at the lift—I track downstream effects on user activation, long-term retention, and monetization, ensuring we’re compounding gains rather than optimizing in silos.
For product-led growth, I focus on the moments that matter most: first-value, aha, and habit formation. Journey mapping helps me identify the shortest, clearest path to value, while targeted in-app experiences and contextual nudges accelerate activation without adding friction. Every iteration feeds a learning loop—measure, learn, and ship—so we can pursue step-change outcomes, not incremental tweaks.
Ultimately, the craft is in translating analytics into action. When teams can trace a feature idea to a specific behavioral pattern, test it with a well-powered A/B experiment, and observe durable improvements in retention and revenue, momentum takes care of itself. That’s how I operationalize data to deliver growth, retention, and monetization at scale.
Inspired by this post on Amplitude – Best Practices.
By the end of 2024, we were already all-in on Fin, and our customer support organization was deep in its own transformation. Resolution rates were strong, efficiency was improving, and for the first time, something new was emerging: capacity.
That newfound capacity wasn’t just a relief; it was a strategic opening. As we became less reactive day to day, I saw how support’s unique vantage point—rooted in customer needs and aligned with company goals—could evolve into a consultative function that actively drives value for customers and the business.
This is the story of how we built consultative support. I’ll walk you through how we got started, the results we achieved, and the lessons I’d carry forward if I were doing it again from scratch.
We didn’t begin from zero. A few years earlier, we partnered closely with research and data science to drive product adoption. In a project we called “next best step,” we tested offering proactive guidance inside already-established conversations. It worked well, and as Fin accelerated how we worked, we realized we were ready to push into broader, more ambitious opportunities.
Instead of dictating a solution from the top, I opened the floor. We hosted a support town hall and asked the team to share concrete ways support could directly drive company outcomes. The conversation was electric—practical, creative, and grounded in real customer moments.
Right there, we spun up campaign concepts. One idea was an always-on in-product banner offering a call with a member of our team to help customers set Fin up to the best of its ability. Another was the “Fin upsell campaign,” where, once a customer had a positive interaction with Fin and clicked the “that helped” button, a tailored message would share details about our own success with Fin and invite the customer to book a call to learn more and ask questions.
The energy from that session made one thing obvious: the team already knew how to help customers extract more value from the product. They just needed focus, permission, and a clear path to act.
We started small on purpose. I recruited a group of volunteers who dedicated part of their week to exploring new, proactive ways to support customers. We kept the group tight for two reasons: first, even with Fin freeing up significant capacity, we still had to deliver excellent day-to-day support; second, this was an experiment, and we weren’t going to overhaul a 100+ person organization without proof.
One of our first campaigns focused on proactive engagement with self-serve customers—those without a dedicated sales or success touchpoint. Our goal was to give this group direct access to teammates with first-hand experience in AI transformation and help them see the value they could get from Fin.
Early use cases included guiding customers through Fin trials, working with mature customers on optimization to get more out of Fin, and proactively identifying high-potential accounts that looked ready for Fin. None of this required a new team or a big budget—just attention and intention.
To make consultative support stick, we trained for a mindset shift. I encouraged the team to move beyond solving the immediate issue and instead probe deeper to understand each customer’s unique context. We leaned on our sales and success peers to refine our outreach—learning how to time our messages, frame value succinctly, and meet customers at the right moment rather than waiting for them to come to us.
To validate our approach, we needed data—not vibes. We built a simple but rigorous comparison: accounts we engaged with versus accounts we reached out to but didn’t hear back from. Over a six month period, we tracked feature adoption, Fin usage, and expansion revenue across both groups.
The result was clear: engaged accounts grew roughly twice as fast in both usage and expansion.
To further prove the value of proactive support, we also tracked direct Fin resolutions generated after consultative interactions, resolution and automation rate improvements across engaged accounts, and influenced expansion ARR across everything we worked on over the year.
Seeing those numbers was a turning point. This wasn’t a side project anymore—it was a repeatable motion with measurable business impact.
As results became visible, partnerships multiplied. Self-serve engineering teams saw the value of well-timed human touchpoints. Customer lifecycle marketing tapped us to handle responses to their campaigns. Product teams began partnering with us to identify high-impact engagement opportunities. We also deepened our collaboration with digital, scale, and high-touch success teams—stepping in where they lacked capacity and offering deep technical guidance to help customers get the best from the platform.
What began as simple outreach matured into targeted, strategic initiatives tied directly to company goals.
Within a year, our volunteer crew grew to ~16 teammates across regions—curious, motivated, and eager to try new things. We continued expanding the consultative support function and took on new projects end to end. Most recently, we assumed ownership of the new “sales assist” team to drive self-serve trial conversions and help new customers get the most from their first experience.
Here are the practices that mattered most in making consultative support real and durable:
Start with your team, not a strategy doc. The best ideas came from the people closest to customers. That town hall shaped our initial direction more than any top-down plan could have.
Don’t scale before you’ve proved it. A small, motivated group moved faster, learned quicker, and produced clearer results than a broad rollout. When you need organizational buy-in, a rigorous proof point beats a promising concept.
Train for a different mindset. Consultative work requires curiosity, commercial awareness, and the ability to hold broader context—not just product knowledge. Invest deliberately in coaching and frameworks that strengthen these muscles.
Measure against a control group. Without a control, you have a story. With it, you have a business case—and that’s what unlocks resources, headcount, and prioritization.
Lean into being different. It’s helpful to take cues from sales and success, but you don’t have to operate exactly like them. There’s real power in support’s distinct perspective and tone.
Building this consultative support function fundamentally changed how we think about our remit. Support is no longer just there to respond; it now drives adoption, influences retention, generates expansion revenue, and, for many self-serve customers, serves as the primary human touchpoint.
In an AI-first world, where Fin handles all of the transactional work, this kind of work becomes even more important. Because the question for support leaders is no longer “how do we handle more tickets?” but rather, “how do we use support to grow the business?”
I’m excited to share a resource I recommend to every product and growth team I mentor: the Amplitude Quickstart Series. It’s a concise, approachable way to build confidence in “Amplitude analytics” and turn behavioral data into decisions that actually move the needle.
Discover user-friendly videos that walk you through Amplitude’s most essential products and features.
In my role leading product teams, I’ve seen how a clear, opinionated path through a “unified analytics platform” reduces time-to-insight from weeks to days. The Quickstart format makes it easy for product managers, analysts, and marketers to align on a common language for “behavioral analytics,” so we spend less time debating definitions and more time shipping value.
What I appreciate most is how quickly these lessons translate into outcomes: crisper instrumentation practices, cleaner dashboards, and sharper questions that drive “product-led growth.” That foundation accelerates “user activation,” improves “retention analysis,” and ultimately leads to better prioritization and stronger roadmap bets.
My recommended workflow: watch the entire series once to map the mental model, then revisit each segment as you operationalize it. Pair the guidance with a lightweight tracking plan, establish clear event naming conventions, and document your first key use cases (e.g., activation funnel, onboarding drop-off, core feature adoption). This cadence helps teams institutionalize good habits without over-engineering.
For cross-functional leaders, the series is also a powerful alignment tool. Ask product, data, design, and customer success to watch the same modules, then run a joint working session to define success metrics and accountability. When everyone sees the same “north-star” dashboards, decision-making speeds up and the quality of trade-offs improves.
As your practice matures, amplify the impact by pairing insights with action: connect findings to experiments, “feature flags,” and iterative product tours; complement quantitative patterns with “session replay” for richer context. This closed-loop approach helps you move from reporting to repeatable, insight-to-execution cycles.
If you’re new to Amplitude or scaling a growing practice, this Quickstart Series is the shortest path I know from curiosity to competence. Watch it, implement one improvement per week, and share progress broadly—momentum compounds.
Inspired by this post on Amplitude – Best Practices.
Churn isn’t just a retention problem—it’s a product, go-to-market, and strategy signal that shows up everywhere in the customer journey. Over the past few years, I’ve evaluated and implemented churn prediction tools across high-growth SaaS environments, and the difference between reactive firefighting and proactive, data-driven retention is night and day.
Compare the top 8 churn prediction tools for SaaS teams. Features, use cases, and how each stacks up, so you can act before customers quietly leave.
When I assess churn prediction tools for product-led growth, I start with a simple question: will this help my team see risk early enough—and clearly enough—to intervene with precision? The best platforms combine behavioral analytics, retention analysis, and anomaly detection to surface leading indicators before Net Recurring Revenue (NRR) takes a hit.
First, signal coverage matters. Strong churn models draw from product usage events, CRM integration, support tickets, billing health, and even session replay to capture real-world behavior. I look for native connectors to systems like Intercom, Pendo, and Amplitude analytics, plus flexible ingestion for custom events. Without comprehensive signals, even the smartest models will miss critical moments such as stalled onboarding, shrinking active seats, or feature disengagement.
Second, I require transparent risk scoring and clear drivers. Black-box scores erode trust with Customer Success and Product teams; explainability builds alignment. Tools that expose driver trees, cohort-based retention analysis, and segment lift help me translate insights into prioritized experiments. When possible, I tie predicted churn segments to A/B testing with a thoughtful minimum detectable effect (MDE) so we can quantify impact quickly and avoid overfitting to noise.
Third, actionability is non-negotiable. Predictions must trigger targeted AI workflows, in-app guides, and product tours—not just dashboards. My ideal setup routes high-risk cohorts to tailored journeys (e.g., an onboarding rescue path) while notifying the right owner in CRM and Customer Success. Playbooks should be easy to operationalize, measurable, and reversible if the signals change.
Fourth, I evaluate platform scalability, data governance, and privacy-by-design. Enterprise readiness means clear role-based access, auditability, robust SLAs, and an architecture that can evolve into a unified analytics platform as the product and data footprint grows. I also weigh total cost of ownership, implementation time, and maintenance burden against expected gains in NRR and expansion.
In my experience, the winning tools are the ones that make it simple to connect predictions to outcomes: reduce onboarding drop-off, increase user activation, prevent seat contraction, and accelerate expansion. They align Product, Customer Success, and Growth around shared metrics, shorten time-to-value, and make proactive retention part of the operating rhythm—not a last-ditch effort at renewal.
In this 2026 comparison, I’ll outline how each tool handles data breadth, model quality, explainability, and workflow automation. I’ll also share implementation checklists and decision criteria so you can choose the right fit for your stage, stack, and motion—whether you’re primarily product-led growth, sales-led, or hybrid.
If you’ve ever felt like customers “quietly leave” despite solid top-of-funnel metrics, this guide will help you turn churn signals into concrete actions—and convert at-risk accounts into durable advocates.
