I spend my days partnering with technical leaders who bridge invention and impact. The role of a Senior Software Engineer at Amplitude working on AI-powered products epitomizes how engineering and product fuse to ship customer value with speed, safety, and conviction. In my world, that fusion isn’t accidental—it’s designed, measured, and relentlessly improved.
When I form product trios—engineering, product, and design—we clarify the problem, the target users, and the measurable outcomes before a single line of code ships. This is how empowered product teams operate: we trade feature wish-lists for hypotheses, align on success metrics, and commit to learning loops that turn ambiguity into progress.
On the technical front, modern AI systems demand a retrieval-first pipeline, robust data contracts, and a thoughtful orchestration layer for LLMs. I expect eval-driven development to be first-class: offline unit-style evals for prompts and policies, and online evals that track behavior changes and quality at scale. This rigor gives us confidence to ship, learn, and iterate without burning cycles on guesswork.
Velocity matters, and so does reliability. I look for CI/CD that makes small, safe, frequent releases the default, and for DORA metrics to shine a light on delivery health. Pair that with platform scalability, clear SLOs, and pragmatic SRE practices, and teams earn the right to move fast without breaking trust.
Responsible AI is non-negotiable. We operationalize AI risk management with guardrails, input/output filters, red-teaming, and human-in-the-loop review where stakes are high. Data governance and privacy-by-design ensure that our creativity never outruns our compliance—because durable products are built on durable trust.
Impact comes from evidence. I advocate for disciplined A/B testing, careful minimum detectable effect (MDE) planning, and retention analysis that ties feature work to real business outcomes. Clear analytics pipelines and transparent dashboards keep stakeholders aligned and make good decisions repeatable.
Ultimately, the Senior Software Engineer I want to collaborate with is a builder who balances systems thinking with customer empathy: someone who can design reliable architectures, instrument the work with meaningful evals, and co-lead discovery to de-risk the roadmap. When we combine that mindset with crisp execution, AI-powered products stop being demos—and start becoming indispensable.
Inspired by this post on Amplitude – Perspectives.
Every week, retail and ecommerce leaders ask me the same thing: which product metrics truly separate the winners from the rest? As a VP of Product Management at HighLevel, Inc., I rely on benchmarks to translate strategy into measurable, repeatable outcomes—so I built a simple way to use them to guide roadmaps, experiments, and executive alignment.
Discover exclusive data and strategies from our Product Benchmark Report. Compare the ecommerce industry’s performance across key product metrics.
Benchmarks aren’t just numbers on a chart; they’re context. They help me calibrate goals, set outcomes vs output OKRs, and focus our product-led growth efforts on the handful of inputs that actually move revenue, loyalty, and lifetime value in retail and ecommerce.
The metrics I prioritize map to the customer journey: acquisition efficiency (visit-to-signup), activation and time-to-first-value, product-to-checkout conversion, order completion rate, repeat purchase and subscription retention, average order value, and LTV/CAC. I also track friction signals like cart abandonment, returns, and refund rates to surface hidden points of failure.
Here’s how I use the report in practice. First, baseline performance against peer benchmarks so we know whether we have a strategy or an execution gap. Second, segment by cohort (new vs. returning, mobile vs. desktop, subscription vs. one-time) to reveal where the experience is underperforming. Third, instrument clean funnels and events in our unified analytics platform—Amplitude analytics or Pendo—so every metric is observable and trustworthy.
From there, I translate gaps into a focused experimentation plan. We run A/B testing with proper guardrails, size tests using minimum detectable effect (MDE), and predefine success metrics to avoid p-hacking. Each experiment ties directly to an outcome metric, not an output, so we can attribute impact and iterate with confidence.
Strong execution requires strong alignment. I bring product, marketing, and CX together as a product trio to turn benchmark deltas into a crisp value proposition, targeted onboarding, and lifecycle messaging. That cross-functional focus turns insights into conversion, retention, and customer lifetime value—fast.
Data integrity underpins all of this. We establish clear event taxonomies, privacy-by-design practices, and governance to keep analytics reliable at scale. When the data is clean, decisions get faster, and experimentation becomes a compounding advantage.
If you’re ready to pressure-test your roadmap and accelerate growth, start with the benchmarks. Use them to prioritize opportunities, prove impact with disciplined experiments, and communicate strategy in language the business understands. That’s how retail and ecommerce teams move beyond vanity metrics and win their market.
Inspired by this post on Amplitude – Perspectives.
When a customer reports a stolen credit card, the frontline play seems straightforward—freeze it. But that’s just the visible tip of a much larger customer support iceberg. Underneath sits the real work: dispute filings, fraud investigations, merchant communications, proactive outreach, and follow-ups that unfold over days across multiple systems. Most AI support tools only touch the surface; they don’t coordinate or close the loop. That gap is exactly where my product instincts kick in—and why this story matters.
I recently listened to a conversation with Jack Taylor (Product Engineer) and Ibrahim Faruqi (AI Engineer) from Gradient Labs, an AI-native startup building agents that automate the full scope of customer support in fintech. Their approach resonated with the challenges I see every day in customer support automation: fragmented workflows, regulatory complexity, and the need for human-in-the-loop moments. Gradient Labs has architected a platform with three coordinating agents—"inbound, back office, and outbound"—all built on a shared foundation of "natural language procedures, modular skills, and configurable guardrails."
What impressed me most was how they "Let non-technical subject matter experts define agent behavior through natural language procedures—no coding required." That’s a powerful way to remove engineering bottlenecks, accelerate iteration, and keep the domain experts—those closest to fraud, disputes, and compliance—directly in control. In my experience, this design choice alone can compress lead times from weeks to hours and aligns perfectly with continuous discovery and eval-driven development.
At the heart of their platform is orchestration. They "Architected a state machine orchestrator that manages turns, triggers, and skill selection across long-running conversations." That "turn" architecture is built for the messy reality of async, multi-day support. They treat "Skills as modular agent capabilities—and how they're scoped deterministically per turn," ensuring the system stays predictable and auditable. They also confront a nuanced challenge most teams dodge: "Defining "done" for outbound agents when the customer isn't the one ending the conversation." That’s where deterministic criteria, timers, and clearly scoped outcomes matter as much as the model beneath.
Compliance is not an afterthought—it’s baked into the core. Gradient Labs "Built guardrails as binary classifiers with eval pipelines, tuning for high recall on critical regulatory checks." In regulated domains, optimizing for recall on high-stakes checks is the right call; you can tolerate a few extra reviews, but you can’t miss a potential fraud signal. More broadly, they frame "Guardrails as classification problems: balancing recall and precision for regulatory compliance." That mindset is exactly how I like to merge AI risk management with product velocity.
Crucially, they avoid the trap of fully autonomous optimism. "Ask a Human: a tool call that brings humans into the loop for approvals or missing APIs" gives the system a safety valve for novel or high-risk cases. I also appreciated the explicit "Ask A Human Tool" pattern, which cleanly integrates approvals, policy exceptions, or data gaps without derailing the workflow.
Quality doesn’t happen by accident. They "Designed an auto-eval system that samples conversations for human review to catch edge cases and build labeled datasets" and built "Auto-eval pipelines that flag conversations for manual review and feed labeled datasets." That closed-loop evaluation flow is the backbone of sustainable performance in agentic AI. Combine this with targeted instrumentation—think CSAT, first contact resolution, deflection rate, time to resolution, and escalation rate—and you get a real Agent Analytics discipline, not just logs and dashboards.
The "iceberg" metaphor is more than a catchy visual. It’s a blueprint for scoping multi-agent platforms that work across the entire customer journey. With "inbound, back office, and outbound" agents coordinating on complex tasks like fraud disputes, the system can transition cleanly from intake to investigation to resolution—without dropping context or asking customers to repeat themselves. This is what genuine customer support automation looks like when it’s grounded in real operations.
Under the hood, the team leans into robust design choices that matter at scale: the "Complexities of Natural Language Input" are managed with explicit state and skill scoping, "Deterministic Skill Execution" reduces flakiness, and "Customer-Specific Guardrails" ensure compliance remains aligned to each client’s policies. Add their focus on "APIs and Customer Tools Integration" and the result is a platform that can actually take action—not just answer questions.
If you’re building in this space, here’s how I’d apply these lessons. Start by mapping the iceberg: enumerate back-office steps, approvals, and SLAs that follow the initial customer touchpoint. Capture those steps as "natural language procedures" owned by SMEs. Implement a "state machine orchestrator" to manage "turns, triggers, and skill selection" across multi-day workflows. Treat "guardrails as classification problems" and tune for high recall on high-stakes checks. Introduce "Ask a Human" early to handle missing APIs or policy exceptions. Finally, operationalize learning with "auto-eval pipelines" and tight, eval-driven development loops. That’s how multi-agent platforms deliver measurable outcomes in fintech support.
If you want to hear the full conversation, you can listen on Spotify or Apple Podcasts. You’ll also hear a nod to the "Incident.io episode – Referenced in the conversation," and a thoughtful take on the "Future of Multi-Agent Systems."
In short: this is a shift from simple Q&A bots to agents that can coordinate, comply, and complete. It’s the kind of multi-agent platform work that moves the needle for customer support in fintech—and a compelling template for any product leader scaling agentic AI and AI workflows beyond the tip of the iceberg.
Every week I review dozens of applications for PM roles, and in under 30 seconds I decide whether to keep reading. In 2026, the bar is higher than ever: clarity, outcomes, and customer insight beat buzzwords every time.
Learn how to write a standout product manager cover letter with steps, examples, templates, and smart AI workflows to make your application stand out.
I start with a crisp opening that communicates my value proposition in one sentence: the product problem I love solving, the customer I serve, and the measurable outcomes I drive. Then I connect my experience to the role’s core responsibilities—product discovery, product positioning, go-to-market strategy, and stakeholder management—without rehashing my resume.
A strong PM cover letter follows a simple structure: a hook with context, one paragraph proving product management leadership through outcomes vs output OKRs, a paragraph on how I partner with empowered product teams and engineering to ship, and a closing line that shows I understand the company’s roadmap and where I can help now.
To make this concrete, I include brief examples that show decisions, not duties: how I translated ambiguous customer signals into a roadmap, how I balanced platform scalability with speed, and how I measured success with activation, retention, and adoption—not vanity metrics.
Templates help me move fast, but I always tailor. I mirror the job’s language, highlight the few experiences that map 1:1, and cut everything else. I quantify impact where possible, link outcomes to business value, and keep it to 200–300 words so hiring managers can scan.
I also use smart AI workflows to accelerate the craft without sacrificing authenticity. My LLMs for product managers playbook: extract the role’s competencies, generate a draft outline, compare multiple versions with light A/B testing, and refine tone and clarity. Tools should augment judgment; the final voice is mine.
If you’re applying now, assemble your core template, slot in two role-specific examples, and close with a confident ask for next steps. With the right structure, clear outcomes, and a little AI leverage, your product manager cover letter will stand out in any stack.
I’m curating a living list of 2026 product conferences to help product managers, product leaders, and empowered product teams plan ahead with confidence. I use this calendar to align my team’s discovery work, roadmapping, and go-to-market strategy—and to prioritize conference networking and learning that moves the needle on product-led growth.
This list is not exhaustive. If there’s a product conference missing that should be here, please send it to conferences@producttalk.org. I’ll keep updating this as new events are announced so you have a reliable guide throughout the year.
I’ll be teaching a workshop and speaking at the Product at Heart conference in June in Hamburg, Germany. If you plan to attend, be sure to say hi.
Are you looking for the 2025 Product Conferences list? Find it here.
How I use this guide: I map events to our quarterly OKRs (outcomes vs output OKRs), focus on sessions that sharpen product discovery, stakeholder management, and product roadmapping and sprint planning, and bring a clear plan for takeaways I can apply the day I’m back. If you’re exploring AI Strategy and LLMs for product managers, you’ll find several strong options below.
January
Jan 28 — Product-Led Summit — Washington, DC, USA
Jan 30–31 — Prdkt+ — Cairo, Egypt
February
Feb 1–4 — WebSummit — Doha, Qatar
Feb 2–20 — DeveloperWeek Hackathon — San Jose, CA, USA & Virtual
Feb 4 — DDX Innovation & UX Conference — Tokyo, Japan
If you’re attending any of these, let me know—conference networking is always better with a plan and a friendly face. And if you’ve got a must-attend event on your radar, send it to conferences@producttalk.org so I can keep this guide comprehensive for the community.
AI isn’t a side quest for product managers anymore—it’s the skill stack that will define how we discover problems, prototype solutions, and ship value in 2026. Over the last few cycles, I’ve watched teams that embrace AI Strategy outperform on speed, signal, and stakeholder confidence. This roadmap is the approach I use to build capability in a structured, outcome-driven way—so we ship smarter, faster, and more impact-driven products.
"AI for PMs in 2026: why it matters, what to learn, and a 12-month AI roadmap to master product skills and ship smarter, faster, impact-driven products."
Here’s how I frame what to learn and why: focus on enduring capabilities first (problem discovery, experimentation, ethics), then layer the AI product toolbox (LLMs for product managers, retrieval-first pipeline patterns, AI workflows), and finally operationalize with outcomes vs output OKRs. The goal isn’t to sprinkle gen ai on everything—it’s to make better decisions, reduce cycle time, and unlock product-led growth in measurable ways.
Months 1–3: Foundations. I build literacy around model behavior and constraints, context window management, and prompting patterns. I pair this with data governance and privacy-by-design basics so we avoid rework later. Practically, I assemble an AI product toolbox (evaluation checklists, prompt libraries, retrieval-first pipeline templates) and apply them to product discovery—summarizing research, clustering feedback, and sharpening value propositions without losing critical nuance.
Months 4–6: Prototyping and evaluation. This is where ideas become testable artifacts. I use gen ai for product prototyping to create UX mocks, PRDs, and in-app guides rapidly, then validate with eval-driven development. I run lean experiments (A/B testing with a clear minimum detectable effect), wire up analytics to Amplitude, and track activation and retention signals. The mantra: instrument early, measure causally, and iterate based on evidence.
Months 7–9: Shipping AI-enabled workflows. I partner with product trios to integrate AI into real user journeys—customer support ai strategy, CRM integration, and guided onboarding are common wins. We explore agentic AI for complex multi-step tasks, add safeguards for AI risk management, and pressure-test systems with threat detection and response playbooks. As features reach production, we monitor deployment frequency and tighten feedback loops to protect quality while accelerating learning.
Months 10–12: Scale and governance. I operationalize what works with product roadmapping and sprint planning aligned to outcomes vs output OKRs. We codify playbooks for continuous discovery, define eval gates for new AI features, and unify analytics so teams can compare lift apples-to-apples. Stakeholder management matures into clear narratives: what shipped, what moved, what’s next—so leadership sees compounding value, not just activity.
Throughout the year, I keep the focus on real users and real metrics: fewer hops from insight to iteration, tighter loops between problem and prototype, and crisper communication around trade-offs. The result is a team that can translate AI capabilities into differentiated product experiences—reliably and responsibly. If you follow this path, you’ll enter 2026 with the confidence to lead, the systems to scale, and the evidence to prove it.
I’ve learned that in financial services, intuition isn’t enough—rigorous product benchmarks are what separate signal from noise. When my team and I evaluate portfolio performance, we anchor our decisions to the metrics that correlate with customer trust, compliant growth, and durable revenue.
Discover exclusive data and strategies from our Product Benchmark Report. Compare the financial services industry’s performance across key product metrics.
Here’s how I use a benchmark report in practice: I calibrate our baseline against peers, identify the few levers that disproportionately drive outcomes, translate those findings into outcomes vs output OKRs, and align stakeholders across product, risk, operations, and go-to-market. Benchmarks turn debate into data and surface the opportunity cost of not fixing broken journeys.
The product metrics I zero in on typically include user activation rate, time-to-first-value, onboarding completion, funnel conversion (for example, from signup to funded account or application to approval), cohort-based retention analysis (D7/D30/D90), depth of feature adoption, weekly-to-monthly active ratios, support contact rate, and cost-to-serve. In financial services, these signals tell a clear story about trust, reliability, and product-market fit.
To operationalize these insights, I combine Amplitude analytics with Pendo in-app guides to instrument end-to-end journeys, segment by customer profile, and run disciplined A/B testing with clear guardrails. This lets us move from anecdotes to statistically defensible changes and iterate confidently on onboarding, product tours, and moments that drive activation and engagement.
Because the trust and regulatory bar is higher in financial services, I also watch for friction in verification flows, error states that erode confidence, and any gaps between intent and completion. When benchmarks show we’re lagging, I pair discovery with rapid experiments to improve the experience while maintaining privacy-by-design and strong governance.
Use this benchmark report to pinpoint where you outperform and where you lag, prioritize roadmap bets, and focus your product-led growth motion. When teams rally around a shared set of product benchmarks, execution speeds up, trade-offs become clearer, and the value proposition sharpens for both customers and the business.
Inspired by this post on Amplitude – Perspectives.
"The best AI products improve more through context engineering than prompt tinkering." I’ve seen this play out repeatedly in high-stakes, enterprise use cases: substantive gains come from how we curate, structure, and deliver context to models—not from wordsmithing. When we started treating context as a product surface, performance climbed, hallucinations dropped, and teams shipped with more confidence.
Here are four key decisions we made to improve our AI context.
First, we moved to a retrieval-first pipeline. We unified trusted sources—CRM records, support knowledge bases, product telemetry, and governance-approved docs—behind hybrid retrieval (semantic + keyword) with strong metadata ranking. This let us constrain generations to verifiable facts, apply privacy-by-design rules at the edge, and practice disciplined context window management so every token carried its weight. Freshness policies, source-level confidence scores, and lightweight schemas kept the system precise and auditable.
Second, we made eval-driven development non-negotiable. Every change to context assembly goes through offline evals and online A/B testing with clear acceptance thresholds (e.g., task success, groundedness, time-to-first-answer, and deflection rate). We sized tests with minimum detectable effect (MDE) and tied them to outcomes vs output OKRs so we weren’t just shipping more prompts—we were shipping measurable improvements that mattered to customers.
Third, we personalized context based on intent and role. We built AI workflows that detect user intent, segment by persona, and dynamically assemble context: recent account activity for customer success, policy-safe excerpts for finance, and fine-grained reasoning chains for product teams. For conversational and voice AI agent experiences, we combined short-term conversation memory with scoped, long-term account memory to preserve relevance without bloating the prompt. This agentic AI pattern ensured faster, safer, and more helpful responses.
Fourth, we operationalized context as a first-class platform capability. We invested in data governance (ownership, lineage, and redaction), instrumentation (Amplitude analytics for usage, retrieval hit rates, and failure modes), and CI/CD guardrails for context updates. Product trios partnered with SRE to monitor drift, while side-by-side comparisons and human-in-the-loop reviews turned frontline feedback into structured improvements. The result: a durable system that improves continuously instead of relying on one-off prompt tweaks.
Context engineering isn’t glamorous, but it compounds. By prioritizing retrieval-first design, rigorous evaluation, intent-aware assembly, and operational excellence, we transformed our AI features into dependable, enterprise-ready capabilities. If you’re serious about LLMs for product managers and sustainable AI Strategy, shift your energy from clever prompts to robust context—and watch adoption and trust follow.
Inspired by this post on Amplitude – Perspectives.
I’ve spent years trying to bottle the judgment of a great product analyst and pour it into our AI workflows. The hardest part isn’t access to data; it’s encoding the nuance of analytical reasoning. That’s why Amplitude’s approach resonated with me—turning expert analysis into a repeatable, stepwise process AI can run with discipline and speed.
Learn how Amplitude turned its data analysis expertise into a structured, iterative process that AI can execute in moments.
In practical terms, I translate that one line into an operating model: define the decision, formalize the metrics, map the data, decompose the questions, iterate on evidence, and converge on a recommendation with clear trade-offs. This is the backbone of agentic AI for product managers—giving an LLM not just data, but a procedure that mirrors how our best analysts think.
Here’s the analyst-to-AI loop I use. First, frame the business question in decision language (what will we do differently?). Second, anchor on success metrics and guardrails, including statistical sensitivity and minimum detectable effect (MDE). Third, locate trusted sources—your unified analytics platform, experiment logs, and product instrumentation—so the AI never guesses. Fourth, generate hypotheses and segment the data (cohorts, channels, plans, geos), prioritizing signal over noise. Finally, synthesize findings into options with expected impact, risks, and next steps.
To operationalize this, I build a retrieval-first pipeline that binds Amplitude analytics to structured prompts and function calls. The AI receives exact metric definitions, event taxonomies, and governance rules, then returns a predictable schema—headlines, evidence, segments, caveats, and recommended actions. That combination of clear constraints and consistent output makes eval-driven development possible: I can test prompts and tooling against a gold set of analyses and steadily improve quality.
Consider retention analysis on a new onboarding flow. I’ll ask the system to pull activation rate, time-to-value, and day-7 retention from Amplitude, then compare cohorts by channel and plan. The AI proposes hypotheses (e.g., tooltip engagement correlates with activation), runs segmentation to validate them, and lays out product-led growth levers—like simplifying the first-run checklist or moving guidance in-app. What used to take hours of manual slicing now becomes an iterative loop that lets me spend more time on prioritization and less on tab wrangling.
Of course, speed without rigor is a trap. I guard against metric drift and hallucinations with strong definitions, lineage checks, and human-in-the-loop approvals for consequential decisions. I also log analysis steps and outcomes so we can audit reasoning, catch regressions, and keep AI grounded in our true north metrics—not just what’s easy to compute.
The big unlock isn’t a clever prompt; it’s codifying the analyst’s craft. When we treat analysis as a structured, iterative process, AI can execute it with consistency, and product teams can move faster with more confidence. If you’re building AI workflows for product insight, start by formalizing your analyst loop, connect it to your Amplitude analytics, and evaluate continuously. The result is smarter, faster decisions—and a repeatable path from raw data to action.
Inspired by this post on Amplitude – Best Practices.
I spend my days shaping core analytics product experiences that help teams see their business with greater clarity. When I design an analytics workflow, my goal is simple: make it effortless to ask better questions, uncover meaningful patterns, and turn insight into action. In this brief reflection, I’ll share how I approach product discovery, experimentation, and roadmapping to create analytics tools that truly move the needle.
Everything starts with outcomes. I anchor roadmaps to a clear north star and use outcomes vs output OKRs to align problem statements with measurable impact. That means instrumenting a precise event taxonomy and building guardrails for data quality so retention analysis and user activation metrics are trustworthy. When the foundation is sound, product-led growth becomes repeatable because we can connect feature usage to value creation without guesswork.
Experimentation is where conviction meets evidence. I rely on A/B testing with a disciplined view of minimum detectable effect (MDE) so we size experiments responsibly and ship with confidence. Self-serve analysis—and, when appropriate, tools like Amplitude analytics within a unified analytics platform—lets teams quickly validate hypotheses, monitor cohorts, and understand lift. The result is faster learning cycles without sacrificing statistical rigor.
On the delivery side, I practice continuous discovery and translate insights into product roadmapping and sprint planning that teams can execute. I work closely with design and engineering to reduce cognitive load in the UI, standardize tooltips and in-app guides, and ensure every chart, filter, and segment supports a clear decision. This collaboration empowers the team, shortens feedback loops, and keeps us oriented toward customer outcomes rather than feature checklists.
Great analytics products give people confidence. By aligning on outcomes, instrumenting clean data, testing with discipline, and shipping thoughtfully, I’ve seen teams unlock deeper understanding and sustained growth. If you care about building products that illuminate the path forward, start with the questions customers need to answer—and let your analytics experience make those answers obvious.
Inspired by this post on Amplitude – Best Practices.
I’ve been closing the year with a deliberate reflection ritual for more than a decade, and this season I found fresh energy for it after listening to an insightful conversation with Teresa Torres and Petra Wille on All Things Product. Their approaches mirror the evolution many product leaders experience: moving from rigid annual goal-setting to values-led themes, longer time horizons, and a healthier respect for spaciousness. In my own practice, that shift has created better focus, less pressure, and far more meaningful outcomes.
Prefer to listen? You can find this episode here: Spotify | Apple Podcasts. I took notes with my team in mind and translated the discussion into a simple, values-driven framework that any product organization can adopt.
Why does annual reflection matter for product people? Because our work lives at the intersection of ambiguity, trade-offs, and time. If we only measure ourselves by shipped output or quarterly OKRs, we overlook the compounding value of learning, relationships, and judgement. I treat this ritual as a strategic reset: a chance to surface patterns, adjust expectations, and recommit to outcomes over output.
My own reflection habit started scrappy—paper notebooks, messy timelines, and even artful visualizations inspired by Dear Data by Giorgia Lupi & Stefanie Posavec. Like Petra, I’ve found that tactile, analog artifacts unlock insights I miss in a spreadsheet. Over time, I’ve kept the spirit and simplified the mechanics: a “what went well” review, a short list of hard lessons, and a handful of decisions that paid off—or didn’t.
The biggest evolution for me has been moving from rigid annual goals to values and themes. I still run OKRs, but I use them to track progress, not identity. The lens of process vs. outcome goals—reinforced by ideas from Atomic Habits—helped me set fewer, better commitments. For example, instead of “launch X by Y,” I’ll emphasize the cadence of customer discovery, the health of the product trio, and the quality of decisions made along the way.
One exercise that changed my practice is the “100 wishes” list. It’s powerful—and surprisingly difficult. Pushing past 30 or 40 wishes forces me to name latent interests and long-range intentions I rarely say out loud. Combined with decade-level themes, the list helps me balance ambition with patience. I don’t try to do it all next year; I use it to spotlight direction, not deadlines.
I also review patterns across years: Where did over-scheduling create hidden costs? When did I protect focus time and what did that unlock? Paul Graham’s Maker’s Schedule, Manager’s Schedule remains a useful calibration tool here. And when I feel the pull toward constant throughput, I revisit Stefan Sagmeister’s The Power of Time Off (TED Talk) to remind myself why strategically creating space often yields the most valuable ideas.
Of course, not every year follows plan—and that’s normal. Reflection helps me spot unrealistic expectations early and let them go. When setbacks hit, I’ll rewatch Dealing with Setbacks and re-ground in continuous discovery. The question isn’t “Did we do everything?” but “Did we learn fast, protect customer value, and make trade-offs aligned with our values?” That’s how empowered product teams compound impact.
My sharing philosophy has become more nuanced over time. Some reflections are public to invite dialogue and accountability; others stay private so I can process honestly. I’ve found it helpful to publish what I’m saying no to, capture a theme for the year ahead, and keep the rest for myself and my team. This balance preserves motivation while still contributing to the broader product management leadership community.
If you’re designing your own ritual, consider this lightweight flow: review wins and tough calls, write your “100 wishes,” extract a few values-based themes, then translate those into process goals for Q1. Revisit monthly, not just annually. If you like structured prompts, Chris Guillebeau’s How to Conduct Your Own Annual Review from The Art of Nonconformity offers a practical template you can adapt to your context.
For deeper dives and complementary ideas, I bookmarked these as part of my year-end reset: What I’m Saying No to This Year—And Why, Ask Teresa: My Leaders Still Want Roadmaps with Timelines—What Should I Do?, Scaling Impact: A Look at the Year Ahead (2022), Let’s Connect in 2025: A Look at the Year Ahead, The Interview Coach, and Petra’s own year-ahead reflections (here and her 2026 version). I also recommend revisiting the prior conversation on leadership and change: Role of Leadership in Transformations.
I’d love to hear how you approach your end-of-year reflection. What questions bring you the most clarity? Which practices help you set an intentional, values-driven path for the next year? Share your process—I’m always looking to learn from other product creators and leaders.
In product design, AI has shifted from novelty to non-negotiable. I’ve watched teams accelerate discovery, compress prototyping cycles, and turn ambiguous ideas into validated experiences faster than ever—without sacrificing quality or customer trust.
AI in product design has quickly moved from new to necessary. Here are the AI product design tools and approaches you need to stay relevant in this decade.
From my vantage point leading product teams, “necessary” means AI is woven throughout the product lifecycle—discovery, prioritization, prototyping, validation, and iteration—not bolted on. The goal isn’t to chase hype; it’s to build durable advantage with clear AI Strategy, disciplined execution, and measurable outcomes.
First, anchor the work in strategy. Tie every AI initiative to a specific customer problem and value proposition, then express that linkage with outcomes vs output OKRs. This keeps teams focused on real impact and avoids feature-chasing. It also sharpens product positioning and clarifies where AI can deliver competitive differentiation versus simple points of parity.
Second, upgrade discovery. I rely on AI workflows to synthesize interviews, cluster themes, and surface insights at scale. A retrieval-first pipeline—grounding models in our own data—improves factuality and reduces hallucinations. Combine this with strong data governance and privacy-by-design so insights are trustworthy and compliant from day one.
Third, make quality measurable. Adopt eval-driven development: define evaluation sets and acceptance thresholds that reflect real user tasks before you ship. Pair that with A/B testing and minimum detectable effect (MDE) discipline, so you learn quickly and confidently. Add safety guardrails (red-teaming prompts, content filters, and bias checks) to manage AI risk without slowing the pace.
Fourth, enable empowered product teams. Product trios (PM, design, engineering) should co-create prompts, prototypes, and evaluation criteria. Give designers and PMs practical tools—LLMs for product managers, structured prompt templates, and reusable components—so AI-augmented work becomes the default, not a special project.
Where does AI shine in product design today? Concept exploration and market scans, turning fuzzy opportunity spaces into crisp problem statements. Rapid wireframes and interaction ideas, using gen ai for product prototyping to explore multiple design directions in minutes. UX writing that adapts tone and reduces friction across onboarding, tooltip design, and microcopy.
It also excels at guided experiences. I’ve seen strong lifts in user activation when we pair in-app guides and product tours with context-aware suggestions. For support and education use cases, a retrieval-grounded assistant can deflect tickets, shorten time-to-value, and reinforce the product’s value proposition at the exact moment a user needs help.
Voice is another frontier. A well-scoped voice AI agent can accelerate complex workflows (think data entry or multi-step configurations) when hands-free is faster or more intuitive. Just be intentional about when agentic AI adds net value versus when a simple UI tweak would do.
On the tooling side, my AI product toolbox is pragmatic and modular. For analytics and learning loops, Amplitude analytics and Pendo help quantify behavior changes and retention analysis. For in-product engagement and feedback routing, Intercom and HubSpot integrate cleanly with LLM-driven tagging and summarization. For ideation and automation, I use a ChatGPT connector and Claude Code for quick scripts, data wrangling, and prompt experiments. The constant: a retrieval-first pipeline that grounds models in approved knowledge and maintains context window management at scale.
Risk management is built in, not bolted on. Set clear AI risk management policies, catalog model and data dependencies, and document decisions. Align with regulatory compliance requirements early, and keep an audit trail of prompts, datasets, and eval results. That’s how you move fast without breaking trust.
If you’re getting started, begin small: pick one high-friction workflow, add a retrieval-grounded copilot, and measure the lift. Use the results to inform product roadmapping and sprint planning, then scale to adjacent use cases. With disciplined discovery, sharp evaluation, and the right tooling, AI becomes a force multiplier for product teams and a clear win for customers.
