Transition from Product Manager to AI Product Manager

What This Lesson Is About

The Model Layer is the ground floor of the Stack - the fuel everything else runs on. This lesson installs it properly: what an LLM actually is (one idea, not twenty-six scary words), the one property that changes everything (probabilistic, not deterministic), and the professional posture for working with models across a career where a new one drops every three months. It also plants all four consequences of probabilistic material - the map that threads Lessons 3 through 6.

What You'll Walk Away With

• What an LLM actually is - one clean mental model (pattern-prediction machine) that makes the jargon manageable

• Ten Model Layer terms defined - tokens, parameters, transformer, embeddings, temperature, chain-of-thought, multimodal, mixture of experts, distillation & quantization, fine-tuning - each parked on the right shelf

• Probabilistic vs. deterministic - felt, not just described; you'll run the same prompt twice and watch the dice roll

• The four consequences - the full map of why the Stack has five layers, planted here so Lessons 3–6 each feel inevitable rather than arbitrary

• Five professional moves for models - pick a default; keep one or two in reserve; trust your evals over leaderboards; watch cost & latency as seriously as capability; stay one model back for production

• Ramin's Rule #2 - Never confuse a Model Layer update with a Stack change.

  
  

Tools & Setup You'll Need to Follow Along

• Any frontier AI assistant (Claude, Gemini, ChatGPT) - you'll open the same prompt in two separate chats to feel the probabilistic output with your own eyes

• No coding, no setup - this lesson is conceptual with one live experiment

  
  

What's Provided / External Resources

• Lesson 2 Cheatsheet - the full jargon wall demystified on one page; the place to come back when a new term surfaces in a meeting or a paper

• AI Tools Database - organised by model category so you can compare frontier options and track what changes as new models drop

  
  

  All of the above resources are included in the AI-Native Product OS — your installable, living workspace for this course and beyond.

  
  

How This Fits the Arc

Lesson 2 is the first layer install. It cashes Consequence One (Part A) - you can't just prompt and hope; you have to understand the model - and plants Consequences Two, Three, and Four as the roadmap for Lessons 4, 5, and 6. The Context Layer (Part B of Consequence One) follows immediately in Lesson 3.

What This Lesson Is About

The Context Layer is the private floor of the Stack - the one you own, the one that compounds, the one that turns a generic model into something that sounds like a teammate. This lesson gets your AI-Native Product OS running on your actual machine, loaded with your world. The running example - the nsso Intros feature - starts here and carries through Lessons 4, 5, and 6.

What You'll Walk Away With

• The five context files - Identity & Voice, Product & Company Context, User Context, Strategy & Priorities, Templates & Workflows - and what belongs in each

• System prompt - what it is, why it matters, and how it lives in the Identity & Voice file

• MCP (Model Context Protocol) - the open protocol that lets your AI workspace reach your tools and data sources; Notion MCP and Figma MCP connected live

• RAG & memory - what they are and where they sit in the Context Layer (without needing to understand the plumbing)

• Platform choice - Google Antigravity (default) vs. Claude Code (builder alternative), and why the choice matters less than just picking one

• Two paths to a starting PM OS - paid (Aakash Gupta's PM OS) or free (three prompts, built on camera)

• Ramin's Rule #3 - The model is rented. Your context is owned.

  
  

Tools & Setup You'll Need to Follow Along

• Google Antigravity or Claude Code - pick one before the lesson; either works

• A paid or free Notion account - for the Notion MCP connection

• A Figma account - for the Figma MCP connection (free tier works)

• Optional: Aakash Gupta's PM OS from Gumroad (~$49) if you want the paid starting shape; otherwise the three prompts in the lesson build it from scratch

• The Prompt Library (included with the course) - has the Interviewer, Organizer, and Voice Writer prompts pre-formatted

  
  

What's Provided / External Resources

• Prompt Library - includes the three context-building prompts used on camera, plus design system, product marketing doc, and strategic decision memo templates

• AI Tools Database - includes a full list of AI coders and platforms beyond Antigravity and Claude Code, including Chinese alternatives and local/offline options

• Vibe Coding: A Complete Guide to Building Apps with AI - the deeper guide for anyone who wants to go further than the PM OS and build full-stack products

• Aakash Gupta's PM OS - external resource on Gumroad; linked in the course description; the paid starting shape referenced in the lesson

All of the above resources are included in the AI-Native Product OS — your installable, living workspace for this course and beyond.

How This Fits the Arc

Lesson 3 completes Consequence One - you can't just prompt and hope; you have to load context - closing the loop that Lesson 2 opened. It also launches the running build (nsso Intros) that the next three lessons iterate on. Consequence Two lands in Lesson 4.

What This Lesson Is About

The Context Layer is the private floor of the Stack - the one you own, the one that compounds, the one that turns a generic model into something that sounds like a teammate. This lesson gets your AI-Native Product OS running on your actual machine, loaded with your world. The running example - the nsso Intros feature - starts here and carries through Lessons 4, 5, and 6.

What You'll Walk Away With

• The five context files - Identity & Voice, Product & Company Context, User Context, Strategy & Priorities, Templates & Workflows - and what belongs in each

• System prompt - what it is, why it matters, and how it lives in the Identity & Voice file

• MCP (Model Context Protocol) - the open protocol that lets your AI workspace reach your tools and data sources; Notion MCP and Figma MCP connected live

• RAG & memory - what they are and where they sit in the Context Layer (without needing to understand the plumbing)

• Platform choice - Google Antigravity (default) vs. Claude Code (builder alternative), and why the choice matters less than just picking one

• Two paths to a starting PM OS - paid (Aakash Gupta's PM OS) or free (three prompts, built on camera)

• Ramin's Rule #3 - The model is rented. Your context is owned.

  
  

Tools & Setup You'll Need to Follow Along

• Google Antigravity or Claude Code - pick one before the lesson; either works

• A paid or free Notion account - for the Notion MCP connection

• A Figma account - for the Figma MCP connection (free tier works)

• Optional: Aakash Gupta's PM OS from Gumroad (~$49) if you want the paid starting shape; otherwise the three prompts in the lesson build it from scratch

• The Prompt Library (included with the course) - has the Interviewer, Organizer, and Voice Writer prompts pre-formatted

  
  

What's Provided / External Resources

• Prompt Library - includes the three context-building prompts used on camera, plus design system, product marketing doc, and strategic decision memo templates

• AI Tools Database - includes a full list of AI coders and platforms beyond Antigravity and Claude Code, including Chinese alternatives and local/offline options

• Vibe Coding: A Complete Guide to Building Apps with AI - the deeper guide for anyone who wants to go further than the PM OS and build full-stack products

• Aakash Gupta's PM OS - external resource on Gumroad; linked in the course description; the paid starting shape referenced in the lesson

All of the above resources are included in the AI-Native Product OS — your installable, living workspace for this course and beyond.

How This Fits the Arc

Lesson 3 completes Consequence One - you can't just prompt and hope; you have to load context - closing the loop that Lesson 2 opened. It also launches the running build (nsso Intros) that the next three lessons iterate on. Consequence Two lands in Lesson 4.

What This Lesson Is About

The Governance Layer is what separates a demo from a product - it takes the Loop from works to safe to point at real users. This lesson wires five governance instruments into the live nsso Intros feature from Lesson 4, without taking the staging link down or restarting the Loop. Three failure categories (content, behavioral, economic) are named, demonstrated, and caught - live, on the same feature, in one session.

What You'll Walk Away With

• The three failure categories - content (hallucination, brand breakage), behavioral (misuse, prompt injection, scope creep), economic (cost runaway, rate-limit blowouts) - and how each maps to a governance instrument

• The five governance instruments - evals at scale (continuous, auto-blocking), guardrails (input classifier, output classifier, refusal layer, rate limits + cost cap), observability (traces, dashboard, alerts), fallbacks (pre-written behavior for every failure mode), audit trail (per-user logging, retention schedule)

• Exposure surface - the concept that governs how much governance you actually need at any given scale

• The GOVERNANCE.md template - a universal fill-in doc that Antigravity turns into a feature-specific governance spec from any PRD

• The eval script - how to go from a governance spec to a runnable Node.js test in one conversation; what a ✓ PASS and ✗ FAIL look like and what to do about each

• Intelligence management vs. risk management - the posture shift this lesson makes real: measuring the distribution of outcomes and shipping the ones that clear the bar

• The Air Canada story - the canonical case for why governance cannot be retrofitted after an incident

• Ramin's Rule #5 - Ship what you can measure. Hold what you cannot.

Tools & Setup You'll Need to Follow Along

• Google Antigravity (or Claude Code) with the Intros feature or your own feature from Lesson 4

• The eval suite from Lesson 4 - the 50-case functional eval saved in your PM OS Templates folder

• Node.js installed locally - to run the generated eval script (node intros-eval.js)

• A model API key (Gemini, Claude, or GPT) with access to your feature's model calls - for the live API-call portion of the eval

• Optional: a Slack workspace or equivalent for the cost-spike and guardrail-hit-rate alerts

  
  

What's Provided / External Resources

• GOVERNANCE-template.md - the universal governance document (included in your Templates folder); covers all five instruments, the full fallback table, eval case categories, refusal layer template, rate limit fields, audit log schema, and ship/hold checklist

• INTROS-GOVERNANCE.md - the completed, feature-specific version filled in during the lesson; use it as a reference while filling in your own

• Lesson 5 Cheatsheet - the three failure categories, five instruments, and Rule #5 on one page

All of the above resources are included in the AI-Native Product OS — your installable, living workspace for this course and beyond.

How This Fits the Arc

Lesson 5 cashes Consequence Three - probabilistic systems need guardrails and evals, not hope - and brings the Stack to four layers live. It also makes the intelligence-management shift from Lesson 1 Part 2 concrete for the first time. One layer remains: the Human Layer, Lesson 6.

What This Lesson Is About

The Human Layer is the only layer that doesn’t upgrade itself, and the one the other four exist to serve. This lesson activates it - not as a list of soft skills, but as a career identity and a professional posture. The question the lesson answers: what do you do with the hours the Stack just freed up? The answer is the job that was always supposed to be yours.

What You'll Walk Away With

• The five durable skills, deep-dived - Strategic Vision (choose the mountain, not the navigation), User Empathy (Bob Moesta’s JTBD frame), Product Taste (Butterfield’s “minimise thinking, not clicks”), Communication (storytelling and conviction), Judgment (Shreyas Doshi on naming the real problem) - each with a concrete Tuesday and a named anchor

• Outcome orchestrator - the self-description that replaces “task administrator”; what it means to point the Stack at an outcome rather than produce a deliverable

• The Builder PM vs. Experience PM fork - Marily Nika’s carving of the role; how to pick your track and what each Tuesday looks like

• The crab strategy - why “AI-in-your-domain” beats leaping to a frontier lab, and how domain becomes your moat

• The side-project portfolio - why the day-job portfolio is the one hiring managers can’t see, and the six-section README shape for the one they can; why a public GitHub is now required

• The AI PM interview framework - five assessment categories, eight product-sense patterns, and the five-beat answer shape (wrong frame → layer diagnosis → lived specific → Rule → receipts)

• Five behavioural stories - one per Rule #1–#5, already lived across the course; the interview kit that doesn’t need to be invented

• Marily Nika’s One-Hour Rule - 52 hours/year of deliberate frontier exposure; the minimum viable habit for staying fluent without chasing

• PM One vs. PM Two - two real trajectories, same window, different posture; the story the whole arc was building toward

• Ramin's Rule #6 - You are the Context Layer. (Four readings.)

• Rule #7 (unwritten) - the rule only you can write, from the next 12 months of doing the work

Tools & Setup You'll Need to Follow Along

No tools required for this lesson - it’s the Human Layer; it runs on you. But have these open for the handoff section:

• PM Database - job boards, remote boards, target-company lists, AI job-app tools, career coaching

• AI Tools Database - for the One-Hour Rule calendar slot

• Your PM OS - to start an interview prep folder if you want to use the Stack as your interview framework

What's Provided / External Resources

• PM Database - the full jobs kit: AI PM job boards, remote boards, US/UK/Dubai–Spain target-company lists, AI job-application tools, career coaching; the resource to open during the Lesson 6 handoff

• AI Tools Database - fuel for the One-Hour Rule; hundreds of tools organised by category with notes on what each is for

• Accelerators & Investors Database - for when the side project starts to look like a company

• Lesson 6 Cheatsheet - the five durable skills, the Builder/Experience PM fork, the interview framework, and all six Rules on one page

• Master Cheatsheet - the entire course distilled: the Stack, the Loop, the four consequences, all six Rules, the jargon index

All of the above resources are included in the AI-Native Product OS — your installable, living workspace for this course and beyond.

How This Fits the Arc

Lesson 6 cashes Consequence Four - probabilistic systems change what being a professional means - and closes the four-consequence arc that Lesson 2 planted. The Stack is now five layers live. This lesson is not the end of the course. It is the start of the practice.

What This Additional Lesson Is About

This additional lesson turns the AI PM course from a solo framework into a real conversation with an AI designer. Ramin interviews Jacob, a product designer working with AI design flows, to explore how product and design collaborate in the new AI-native workflow. Using the nsso Intros feature as the running example, the lesson shows how a designer thinks through user empathy, taste, PRDs, prototypes, Claude Code, design skills, and handoff to engineers. It is the Human Layer in practice: AI can generate and build, but the quality still comes from judgment, user understanding, and taste.

What You'll Walk Away With

• How AI changes the designer-PM relationship - why product, design, engineering, and analytics are blending, but still need different perspectives

• A live example of designer-led AI prompting - how Jacob asks Claude to plan, ask clarifying questions, and turn a PRD into a buildable prototype

• How to think about audience-specific profiles - using nsso Intros to explore recruiters, collaborators, clients, URL parameters, profile switchers, and privacy trade-offs

• How designers use Claude skills and command folders - reusable design instructions that help AI outputs look less generic and more product-native

• Prototype-to-engineering handoff in the AI era - why a shared prototype environment can replace or supplement a polished Figma-only handoff

• The human layer of design - why understanding users, iterating, and developing taste still matter when AI can produce the first draft

• Jacob's core advice - start building, learn by doing, and use side projects as the fastest way to become fluent with AI tools

Tools & Setup You'll Need to Follow Along

No setup is required to watch the conversation.

If you want to recreate the workflow afterwards, you can use:

• Claude Code or Google Antigravity - to work inside a codebase with AI

• A simple PRD for a feature you want to prototype

• A small prototype environment or demo app

• Optional design/front-end Claude skills or a commands folder to improve the quality of AI-generated UI

What's Provided / External Resources

• The cleaned interview transcript - this page, split into sections so you can revisit the ideas later

• nsso Intros as the example feature - the same feature thread used across the course to show Context, Orchestration, Governance, and Human Layer thinking

• AI PM OS concepts in practice - commands folder, context library, outputs, PRDs, prototype environments, and reusable design skills

This additional lesson sits inside the AI-Native Product OS as an applied conversation showing how the course ideas look when a PM and designer work through them together.

How This Fits the Arc

This additional lesson extends the core six-lesson arc by showing the Human Layer outside the main lecture format. Lessons 1–6 install the Stack; this conversation shows what it looks like in a real product-design collaboration. It connects especially to Lesson 4's Orchestration Layer, Lesson 6's Human Layer, and the course's larger claim that AI-native professionals are not just prompting machines - they are builders with taste, judgment, empathy, and the ability to direct AI toward better product outcomes.