AI Product Strategy

Scope

• Defining an executable product strategy for an AI/LLM/agent product or AI feature portfolio
• Translating AI uncertainty (non-determinism, emergent risks) into an empirical plan with evals + instrumentation
• Choosing product form factor (assistant vs copilot vs agent), autonomy boundaries, and a safety/security posture
• Producing a strategy pack leaders and teams can use to align and execute

• “Define our AI product strategy / LLM strategy / agent strategy.”
• “Prioritize AI use cases and turn them into an AI roadmap.”
• “We’re adding AI to an existing product—what should we build and how do we measure it?”
• “We want to ship an agent; define autonomy, security, and rollout.”

• You need a long-term product/company vision (use

  defining-product-vision

  first).
• You need deep competitor research, battlecards, or win/loss (use

  competitive-analysis

  ).
• You need a feature-level PRD/spec/design doc (use

  writing-prds

  /

  writing-specs-designs

  after strategy).
• You’re doing model architecture research, training, or infra-level technical design (delegate to ML/eng).
• You don’t yet have a clear problem/ICP hypothesis (use

  problem-definition

  /

  conducting-user-interviews

  ).

Inputs

• Product context (what exists today) + target customer/user + their job/pain
• Strategy horizon (default: 3–12 months) + constraints (budget, latency, policy/legal, data access, platform)
• Intended AI surface and scope: assistant / copilot / agent; where it lives in the workflow
• Success metrics (1–3) and guardrails (2–5), including safety/trust, cost, and latency

• Ask up to 5 questions from references/INTAKE.md (3–5 at a time).
• If details remain missing, proceed with clearly labeled assumptions and provide 2–3 options (use-case focus, autonomy level, build/buy).

Outputs (deliverables)

1. Context snapshot (decision, users, constraints, why now)
2. Strategy thesis (value prop, why-now, differentiation, non-goals)
3. Use-case portfolio (prioritized opportunities with feasibility + risk)
4. Autonomy policy (assistant→copilot→agent boundaries + human control points)
5. System plan (build/buy, data plan, eval plan, cost/latency budgets)
6. Empirical learning plan (experiments, instrumentation, iteration cadence)
7. Roadmap (phases, milestones, exit criteria, owners)
8. Risks / Open questions / Next steps (always included)

Workflow (8 steps)

1) Frame the decision and boundaries

• Inputs: User request + constraints.
• Actions: Define the decision to make, strategy horizon, and audience. Decide whether this is for a single feature, a product line, or a platform capability. Write 3–5 explicit non-goals.
• Outputs: Draft Context snapshot + scope boundaries.
• Checks: You can state “We are deciding X by date Y for audience Z,” and list what’s explicitly out of scope.

2) Map the user workflow and role shift

• Inputs: Target user + current workflow.
• Actions: Map the workflow steps where AI changes the user’s job. Note “human control points” (where a user must review/approve). Identify failure modes that matter (hallucination, privacy, action mistakes).
• Outputs: Workflow notes + role-shift bullets (in thesis or appendix).
• Checks: Value is tied to a real workflow step (not generic “AI magic”).

3) Build a use-case portfolio and prioritize bets

• Inputs: Workflow map + constraints + risk appetite.
• Actions: List 6–12 candidate use cases. Score value vs feasibility vs risk. Select the top 1–3 bets and 1 “explore later” bet.
• Outputs: Use-case portfolio table + recommendation.
• Checks: Each selected bet has a clear user, measurable outcome, and known “must-not-do” constraints.

4) Define differentiation + “why us / why now”

• Inputs: Top bets + assets + market context.
• Actions: Draft the strategy thesis: value prop, why-now, and defensible differentiation (data, distribution, workflow integration, UX, trust). Write key assumptions and how you’ll test them.
• Outputs: Strategy thesis (copy/paste from template).
• Checks: Differentiation is not “we use AI”; it names compounding advantages or unique assets.

5) Choose form factor and autonomy policy (assistant → copilot → agent)

• Inputs: Bets + constraints + safety requirements.
• Actions: Decide the minimal autonomy needed for utility. Specify what the system can do, what it can suggest, and what it must never do. Define permission prompts, approvals, logging, and rollback for any action-taking behavior.
• Outputs: Autonomy policy table.
• Checks: Every action capability has explicit permissions + auditability + rollback.

6) Draft the system plan (build/buy, data, evals, budgets)

• Inputs: Autonomy policy + constraints + data access.
• Actions: Choose a strategy-level technical approach (e.g., RAG, tool use, fine-tuning) and a data plan. Define eval strategy (offline + online), quality targets, and cost/latency budgets.
• Outputs: System plan.
• Checks: There’s a plausible path to meet quality + safety + cost + latency with measurable evals.

7) Make it empirical (experiments + instrumentation + iteration)

• Inputs: Thesis + system plan + assumptions.
• Actions: Design experiments/prototypes and a “watch/listen” plan post-launch. Define instrumentation (events/logs), review cadence, and an iteration loop for both utility and risk.
• Outputs: Empirical learning plan.
• Checks: Every major assumption has a test + metric + owner + timebox.

8) Roadmap + quality gate + finalize

• Inputs: Full draft pack.
• Actions: Create a phased roadmap with milestones, exit criteria, and owners. Run references/CHECKLISTS.md and score with references/RUBRIC.md. Always add Risks / Open questions / Next steps.
• Outputs: Final AI Product Strategy Pack.
• Checks: A stakeholder can act on the pack without a meeting; trade-offs and unknowns are explicit.

Quality gate (required)

• Use references/CHECKLISTS.md and references/RUBRIC.md.
• Always include: Risks, Open questions, Next steps.

Examples

ai-product-strategy

ai-product-strategy