AI agent skills for product teams

Design an eval harness for AI agent trajectories: offline regression suites, trajectory scoring, and production sampling.

Audit a live AI agent for reliability: termination caps, runaway cost, tool-error recovery, context bloat, and gating on irreversible actions.

Design a multi-step AI agent: the tier decision, tool surface, loop and termination, state, context management, and failure recovery.

Design evaluation criteria and test harnesses for an AI-powered feature -- quality rubrics, golden datasets, eval pipelines, and pass/fail thresholds.

Design layered defenses for an AI feature: input validation, output filtering, jailbreak and abuse detection, calibrated against false-block cost.

Run a structural health check of an AI system. Use when an AI feature is live or near launch and you need to find risk, quality, and alignment gaps before they bite.

Spec an AI-powered feature covering model requirements, prompt architecture, quality bar, cost projections, and guardrails.

Build and maintain a living AI risk register across accuracy, bias, security, privacy, cost, and compliance.

Build a risk-adjusted AI business case: value against a real baseline, run cost at scale, payback, and an honest do-nothing comparison.

Build a phased AI transformation roadmap that reaches production, not pilot purgatory.

Evaluate an AI vendor or model provider before buying: data handling, lock-in, pricing risk, and compliance fit.

Engineer the context environment so AI coding agents work reliably: repo layout, instruction files, tools, and memory.

Assess an AI system against the EU AI Act and produce a readiness and remediation plan.

Design an AI literacy program for leadership: capabilities, limits, risk, governance, and ROI judgment. Use when execs need to make AI decisions, not prompt.

Structure a fractional Chief AI Officer engagement: mandate, first 90 days, governance, portfolio, and pricing.

Plan monitoring for LLM-powered features in production -- quality metrics, cost tracking, drift detection, and alerting.

Plan an MCP integration: server vs client, tool design, auth scopes, and the security threats unique to MCP.

Coordinate multiple AI agents: topology, handoff contracts, shared state, and system-wide cost and failure control.

Choose the right AI model for each job in a product -- model mapping, routing, cost modeling, and migration planning.

Ground an LLM in your own documents: RAG vs fine-tune vs long-context, chunking, embeddings, retrieval, and evaluating retrieval on its own.

Draft an internal responsible-AI policy: principles to concrete do/don't, human oversight, transparency, fairness, and a named enforcement owner.

Write an executable spec that drives AI-assisted implementation, with checkable acceptance criteria.

Harden a vibe-coded prototype into something shippable: what to keep, rewrite, or delete, plus tests, types, security, and observability.

Evaluate whether an initiative is a 10% optimization or a 10x trajectory change.

Evaluate AI adoption readiness and progress.

Run an individual AI maturity assessment.

Profile an organization's AI maturity with capability benchmarks and an adoption roadmap.

Facilitate an annual strategy review.

Choose and implement the right marketing attribution model.

Identify cognitive biases in decisions or documents.

Evaluate brand health across identity, perception, and consistency.

Analyze campaign performance with actionable next steps.

Map security controls to compliance framework requirements with gap analysis and audit prep.

Evaluate pages for conversion optimization opportunities.

Synthesize insights across multiple engagements.

Diagnose root causes when a team is stuck.

Mine accumulated feedback and corrections to surface actionable patterns.

Score options against a chosen framework.

Extract recurring patterns from engagement data.

Tear down a founder's VC pitch deck with honest, specific feedback before investors see it.

Assess product-led growth readiness.

Drive continuous improvement through external signal scanning and internal feedback analysis.

Assess product operations maturity.

Health-check a product ops function -- maturity, value, and role overlaps.

Facilitate role clarity discussions within a team.

Evaluate social presence, performance, and competitive position.

Score and compare 2-4 technology vendors with a weighted criteria scorecard.

Assess a vendor's security posture before procurement or during periodic review.

Generate a comprehensive brand book codifying visual identity, voice, and application rules.

Build a prototype aligned to a client brand.

Compare competitor products side-by-side with a feature matrix.

Spec a design system component with variants, states, and accessibility.

Facilitate a structured design critique session.

Create annotated design handoff documentation for engineering.

Critique a design before implementation.

Plan and facilitate a design sprint.

Audit a design system for coverage, consistency, and completeness.

Catalog and specify interaction patterns for consistency.

Spin up a fast UI prototype.

Generate a comprehensive style guide from brand inputs.

Synthesize usability test sessions into actionable findings.

Build design foundations from personas through prototyping to review.

Build or audit a design system from tokens through components to accessibility.

Validate designs through usability testing and polished handoff.

Write interface copy for product experiences -- button labels, error messages, onboarding flows, empty states.

Document an architecture decision with context, alternatives, trade-offs, and consequences in standard ADR format.

Build a testing strategy for an AI system: the testing pyramid, golden datasets, regression suites, red-teaming, and deploy gates.

Retrieve verified architecture context -- actual services, databases, event streams, and owning teams.

Run a full Event Storming to Boris to SNAP architecture discovery workflow.

Model service relationships from Event Storming outputs.

Evaluate build, buy, or adopt decisions with TCO analysis and scored comparison.

Produce structured review feedback tied to standards.

Extract evidence-based code dependencies and map the critical path and independent work streams.

Walk through a hypothesis-driven debugging flow.

Update docs and comments alongside a code change.

Assess developer experience -- tooling friction, CI/CD health, code review bottlenecks, knowledge access, on-call burden, and cognitive load.

Facilitate an Event Storming session.

Run a structured blameless postmortem for a production incident -- timeline, contributing factors, action items, and facilitation guide.

Create a security incident response plan with severity levels, playbooks, roles, and notification timelines.

Plan or audit SRE instrumentation for reliability and operational health.

Plan a system migration -- pattern selection, risk mitigation, data validation, cutover checklist, and rollback strategy.

Plan or audit product observability for user behavior and outcomes.

Write characterization tests to lock legacy behavior before changes.

Map verified services to code repositories, service root paths, and maintainers.

Run security-focused scenario and criteria analysis.

Design SLA frameworks with metrics, targets, measurement methodology, and governance.

Document APIs, data, integrations, events, stories, and risks per bounded context.

Run a cross-modal diagnostic review that maps code into sensory models to surface hidden architectural issues.

Generate a high-level architecture or system diagram.

Write the minimum implementation to make existing failing tests pass.

Plan a safe refactor path with test checkpoints.

Generate failing tests from acceptance criteria.

Assess, categorize, and prioritize technical debt with a remediation roadmap and stakeholder summary.

Decompose a feature description into structured technical signals -- systems, services, data entities, backend actions, and event triggers.

Evaluate site crawlability, speed, and indexation health.

Build a 6-18 month technology roadmap connecting business strategy to technical investments.

Build a STRIDE-based threat model with threat matrix and prioritized mitigations.

Run the full cycle of iteration ceremonies from IPM through demo and retro.

Prepare for and navigate a team conflict.

Categorize demo feedback into backlog actions.

Build a narrative and run-of-show for a demo.

Create a timed facilitation script for any workshop or meeting.

Reframe raw feedback into underlying problems and outcomes.

Facilitate an iteration planning session.

Run a structured naming process for a product, feature, or initiative with scoring criteria.

Chain the four daily PM skills together: wrapup, standup prep, facilitation, client summary.

Facilitate a retrospective session end to end.

Turn retro output into concrete action items.

Capture structured notes during or after standup -- changes, blockers, and commitments.

Help a team identify what is stuck and find the right intervention.

Prioritize features or initiatives on a 2x2 matrix (effort/impact, urgency/importance, or custom axes).

Plan, size, and structure an A/B test with statistical rigor.

Improve how new users reach their first moment of value.

Prototype a product feature using AI coding tools (Bolt, Lovable, v0, Replit, Cursor, Claude Code).

Design a dashboard with KPI hierarchy and alert thresholds.

Define actionable audience segments with activation criteria.

Prepare stories for the upcoming iteration through refine, split, write, and review.

Clean, evaluate, or reorder backlog items.

Measure causal impact when a randomized experiment isn't possible.

Analyze retention patterns and diagnose churn by cohort.

Build a marketing-focused customer journey map across the full funnel.

Assess data quality across pipelines, metrics, and analytics surfaces.

Build a Now / Next-Later board of low-effort experiments to validate an early product or community before building it.

Define a test for a product hypothesis with clear success criteria.

Turn raw user feedback into reframed problems and segment hypotheses.

Diagnose conversion funnel drop-offs and prioritize fixes.

Model growth loops, levers, sensitivity analysis, and realistic projections.

Audit or create an information architecture.

Run a jobs-to-be-done analysis for a product or feature area.

Write a user story following the k8 standard format.

Build a metrics framework connecting product, growth, and revenue with KPI hierarchy and review cadence.

Categorize requirements into Must Have, Should Have, Could Have, and Won't Have for a release or scope boundary.

Define or validate a North Star Metric with input metrics and business games.

Design a multi-channel notification system with frequency controls and engagement metrics.

Build a stakeholder-ready roadmap divided into Now/Next/Later, optionally generate a branded deck and share via Slack, Miro, FigJam, or Notion.

Craft objectives and key results that are motivating, realistic, and measurable.

Prepare and facilitate an OKR workshop.

Connect a desired outcome to opportunities, solutions, and assumption tests using the Teresa Torres OST framework.

Diagnose and optimize conversion funnels from UX audit through experimentation.

Build a personalization strategy from basic rules to 1:1 dynamic content.

Create a PRD from scratch through discovery questions, interview-driven writing, and review.

Draft a PRD from a problem statement.

Draft a PRD through guided discovery questions.

Review a PRD against quality standards and flag gaps.

Identify risks and failure modes before committing to a plan.

Prioritize backlog items using structured methods (RICE, ICE, Kano).

Write a product-facing changelog entry.

Set up a visibility operating model for a product team.

Score features or initiatives using RICE prioritization.

Reframe a roadmap around outcomes instead of outputs.

Generate a clean iteration summary for stakeholders.

Generate a sprint summary from GitHub commits instead of self-reports.

Prepare concise stakeholder talking points and asks.

Prepare a fast status and blocker summary before standup.

Generate grab-and-go user stories for common MVP patterns.

Choose the right statistical test and interpret results correctly.

Organize stories into a visual story map showing the user journey with release slices.

Stress-test a story before planning or build.

Vertically slice a story that's too large for one iteration.

Facilitate a story writing session from persona to export.

Write a complete story with acceptance criteria, optionally generate a UI prototype, and push to Linear, Jira, Asana, or Notion.

Turn a live PM interview or working-session prompt into a Miro-ready whiteboard plan: a six-frame board layout, color-coded sticky clusters, a spoken talk-track, and a time-box so people can watch you think.

Run a structured WCAG 2.2 accessibility audit with severity-scored findings.

Identify and prioritize assumptions before committing to a direction.

Plan a card sort to understand how users organize content.

Benchmark UX quality across competitors with task-flow analysis.

Validate a concept with users before building it.

Plan a diary study to understand behavior over time.

Plan user interviews with a structured guide, capture template, and synthesis plan.

Write an interview script for user research.

Synthesize interview findings into structured insights.

Map the customer journey across touchpoints, pain points, and opportunities.

Create reusable persona artifacts from research for docs, steering, and presentations -- with optional visual outputs.

Prioritize research questions into a focused roadmap.

Present research findings to stakeholders.

Structure a research insight repository for reusable findings.

Extract themes and actions from raw research data.

Turn research questions into stakeholder-ready findings.

Design participant screening for research recruitment.

Design a survey with question flow and analysis plan.

Plan a usability test from objectives to moderator guide.

Create user persona profiles from research data.

Run a structured UX assessment with prioritized findings.

Feed user insights into planning through structured interviews and synthesis.