Learning path: AI Product Lead
Last reviewed: 2026-10 · Volatility: medium
TL;DR
This path covers the layers between a model and a product: grounding, context, memory, tools, agents, workflows, trust and cost. It is wider and deeper than the Senior PM path. It stays at the decision level. You read enough mechanics to ask sharp questions, not to build.
Who it is for: a product leader who owns an AI product line or a team of PMs shipping AI features.
Outcome: You set direction for how the product grounds its answers, remembers, acts, stays safe and stays affordable. You can review a design with engineering and ask informed questions.
Before you start: This path builds on the Senior PM path, stages 1 to 3, or equivalent experience. Lessons marked ↺ repeat that path, so skip them if you did it. You have shipped or closely reviewed one AI feature.
Length: about 31.5 hours, across 5 stages. If you did the Senior PM path, about 18 hours, because lessons marked ↺ repeat it. The time is a rough estimate (see Under the hood).
Terms: a large language model (LLM) is a model like those behind chat assistants; the plural is large language models (LLMs); machine learning (ML) is the practice of training models from data.
🎯 For the AI product lead
Why it matters — At this level your decisions set the architecture. A weak call on grounding or autonomy is expensive to reverse.
What it changes in your decisions — You choose retrieval, memory and agent scope on purpose. You set the autonomy dial per task. You fund evals and guardrails as roadmap items.
Ask your eng team — "Which layer fails first, and how would we see it in production?"
Risk if ignored — You ship an agent with the wrong autonomy or a memory that leaks. You find out from a customer.
The path at a glance
Each stage ends with a checkpoint. Move on when you can do what the checkpoint says.
| Stage | Focus | About |
|---|---|---|
| 1 | Model and data foundations | about 9.5 hours |
| 2 | Context and memory | about 5 hours |
| 3 | Action: tools, agents, workflows | about 5.5 hours |
| 4 | Trust, access and cost | about 5.5 hours |
| 5 | Run the product | about 6 hours |
Stage 1: Model and data foundations
You decide how the product grounds answers. That choice drives quality and cost. (about 9.5 hours)
- LLMs: 1. What an LLM actually is ↺ · 2. The context window ↺ · 3. Capabilities & the jagged frontier ↺ · 5. Temperature, sampling & determinism ↺ · 6. Choosing a model ↺ · 7. Prompting vs. RAG vs. fine-tuning ↺
- Generative AI: 3. Probabilistic software ↺ · 4. The generative AI product stack ↺ · 5. Build, buy, or fine-tune ↺
- Machine learning: 1. What machine learning is, and when to use it ↺ · 2. Data: features, labels, splits and leakage ↺ · 5. Measuring a model: metrics, thresholds and baselines ↺ · 7. ML in production: drift, skew and the lifecycle · 8. Learning and doing ML with Claude Code ↺
- RAG & vector databases: 1. When to use RAG, and when not to ↺ · 2. Why RAG? ↺ · 6. Retrieval quality ↺ · 7. RAG vs. long-context vs. fine-tuning ↺ · 8. Beyond flat RAG: GraphRAG & structured retrieval · 10. RAG terms, explained
- Knowledge graphs: 1. What is a knowledge graph? · 6. Knowledge graphs & LLMs · 8. Knowledge graphs as a product
Ready to move on when: You can compare prompting, retrieval and fine-tuning for a feature and pick one with reasons.
Stage 2: Context and memory
What the model sees is a product decision. So is what it remembers. (about 5 hours)
- Context engineering: 1. What is context engineering, for a product leader? · 3. The anatomy of a context pipeline · 4. Context as a spec-able requirement · 5. Context governance at scale · 6. Evaluating context quality · 7. Context engineering across the product lifecycle
- Memory & context: 1. Memory as a product decision ↺ · 2. Session, user & organizational memory · 3. Writing and maintaining memory · 4. Retrieval as memory · 5. When memory goes wrong ↺
- Prompt engineering: 10. Prompts in production: versioning, testing, and model upgrades
Ready to move on when: You can write the context spec for a feature: sources, owners, freshness and how quality is measured.
Stage 3: Action: tools, agents, workflows
The line between talking and doing carries the most risk and the most value. (about 5.5 hours)
- Tool calling: 1. What tool calling is ↺ · 2. Tool contracts & reliability · 3. Permissions, blast radius & the trust boundary
- AI agents: 1. What an agent is, and how much autonomy it needs · 2. Planning, reasoning & reliability across a run · 3. When not to build an agent · 4. Running an agent in production · 5. Choosing and acceptance-testing an agent
- Agentic workflows: 1. Choosing a workflow pattern · 2. Orchestrating more than one agent · 3. Making a workflow durable, and worth owning
- Agentic AI: 6. Reliability & evals · 8. Agentic AI as a product ↺
Ready to move on when: You can set the autonomy level for a task, justify it, and say what would make you lower it.
Stage 4: Trust, access and cost
Evals, security, permissions and spend decide whether the feature survives contact with real use. (about 5.5 hours)
- Visual explainers: 8. One model change: cost, speed and quality ↺ · 9. From one AI task to gross margin ↺ · 10. One eval regression, traced to its cause ↺
- Evaluation & observability: 1. Why eval investment is the job ↺ · 2. Building the eval stack in the right order ↺
- AI security & guardrails: 1. The threat model, and guardrails as architecture ↺ · 2. Red-teaming: testing your defenses · 3. Governance, audit & compliance ↺
- Access control: 1. Authentication, authorization and the access-control model · 8. Access control for AI agents
- Cost optimization: 1. The cost stack, and the build-vs-buy breakeven ↺ · 2. FinOps for AI: budgets, forecasting & the cost review ↺
- Technical product sense: 8. The economics of infrastructure
Ready to move on when: You can show a reviewer your eval results, your threat model and your cost per task.
Stage 5: Run the product
Turn the above into specs, launches and a response plan. (about 6 hours)
- Visual explainers: 7. One AI feature, from idea to launch ↺ · 11. One user story becomes an agent spec · 12. One AI incident, from alert to postmortem
- Technical product management: 3. Specs, PRDs & RFCs · 6. Metrics & experimentation · 7. Launches, rollouts & migrations · 8. Incidents & postmortems · 9. Technical product management for AI ↺
- Product sense: 7. Product sense for AI products ↺
- Building AI-native products: 1. Designing for ambiguity · 2. Practice: the AI feature spec · 5. From pixels to evals · 6. Practice: hill climbing · 8. Practice: the agent spec and risk register · 11. Capstone: ship one AI-native feature
Ready to move on when: You can write the spec, the launch gate and the incident plan for an AI feature.
Skip-ahead rules
- If you ran the Senior PM path, skip the LLMs and generative AI lessons you have already read.
- If your product has no agents yet, read the agent lessons in stage 3 as risk reading, not as design reading.
- If you do not work with regulated customers, skim the governance lesson.
Worked example: a week-by-week plan
This example is invented, to show the method.
An AI product lead with four hours a week plans 6 weeks of work. Each week ends with something you can show. At this pace the full path (about 31.5 hours) takes about 8 weeks.
| Week | Stage | What you do |
|---|---|---|
| 1 | Stage 1 | Pick one feature and write which of prompting, retrieval or fine-tuning it should use. |
| 2 | Stage 2 | Write its context spec. |
| 3 | Stage 2 | Review its memory design with a privacy owner. |
| 4 | Stage 3 | Set its autonomy level and the trigger to lower it. |
| 5 | Stage 4 | Run a tabletop review of its threat model, evals and cost. |
| 6 | Stage 5 | Write the launch gate and incident plan. |
Tradeoffs
- Coverage vs. time. This is a long path. Each stage ends with a checkpoint, so you can stop at the layer you own.
- Product depth vs. engineering depth. You read mechanics only to ask better questions. The engineer path covers building.
- Standards vs. speed. Stage 4 slows early work and speeds later work.
Failure modes
- Treating agents as the default. Read "when not to build an agent" before you commit.
- Memory without a privacy owner. Memory is a data product with a retention policy.
- No eval owner. Every layer in this path needs a quality measure and a person who owns it.
- Reading without reviewing. Take each stage to a real design review.
Practitioner checklist
- Does every AI feature have a grounding choice with a written reason?
- Is there a context spec for each feature?
- Is the autonomy level of each agent written down?
- Can I show evals, a threat model and a cost per task for each feature?
- Is there a launch gate and an incident plan?
Under the hood: how this path was built
Lesson links come from the track build configs, so a renamed lesson is caught by the link check. Time is the number of lessons times 25 minutes for a reading lesson, times 60 minutes for a harness lesson that you build, and 120 minutes to skim a harness phase. Add time for exercises. Modules marked "coming soon" are planned and not counted.
Related lessons
Sources
Lesson counts and titles come from the track overview pages and build configs in this repository. The time estimates are this course's rule of thumb, not measured results. The week plan is invented.