Building AI-native products
Five skills for the AI product leader: opinionated UX for ambiguous interaction, model intuition, the loop from pixels to evals to hill climbing, agentic flows, and how users really behave with agents. Each skill has a judgement lesson and a practice lesson with templates.
An AI-native product is designed around uncertainty: you decide what the model should do, measure it with evals, and shape the flow so people can trust and correct it.
Most software has a fixed flow. The user clicks, the system does one thing, and you can test it. An AI-native product works differently. The user states a goal in their own words. The model answers in a way that is different each time. Sometimes it acts for the user. You cannot list every path in advance.
Building that kind of product takes five skills. This track teaches them in order, with two lessons for each. The first lesson of a pair builds judgement: what good looks like, and why. The second lesson is practice: a method, a fill-in template and a worked teardown you can copy.
- Vision and opinionated UX design. Balance what a language model can do with what users need, in interactions that are open-ended and conversational.
- Model intuition. Know which model to use, how to prompt, and where the limits are.
- From pixels to evals to hill climbing. Link interface decisions to measurable model quality, and improve it step by step.
- Agentic flows. Design systems that take actions, keep context and stay safe.
- Deep user understanding for agent interactions. Learn how people really behave when an agent works for them.
You build one feature across the whole track. Each practice lesson ends with a capstone step. By the end you have a feature plan with a launch gate.
A note on scope. The track teaches the product craft. It does not repeat the engineering basics that other modules cover in full. It links to them instead. The products in the teardowns are invented. They are composites made for teaching, so they have no company facts to check. The track has no runnable code. Its practice artifacts are templates and worksheets.
Where the depth lives
| If you want the full depth on | Read |
|---|---|
| How to write a good prompt | Prompt engineering |
| What models can and cannot do | Capabilities and the jagged frontier and Choosing a model |
| Why AI output varies | Probabilistic software |
| Building the eval stack | Evaluation and observability |
| How agents work and how far to trust them | Agentic AI and AI agents |
| Threats, guardrails and red-teaming | AI security and guardrails |
| Running interviews and reading users | User research |
| Running a launch or an experiment | Technical product management for AI |
The knowledge graph
Five skills, one loop
What you learn from real users reshapes the design.
1Vision and UX
lessons 1 and 2Opinionated design for ambiguous input.
2Model intuition
lessons 3 and 4What the model can really do.
3Pixels to evals
lessons 5 and 6Measure it and climb the hill.
4Agentic flows
lessons 7 and 8Tools, limits and review.
5Users and agents
lessons 9 and 10How people really behave.
6Capstone
lesson 11Ship one feature with a launch gate.
Findings from users send you back to the design.
Read it as a loop. Vision says what the feature is for. Model intuition says what the model can really do. Evals show whether it does it. Agentic design adds actions and the controls around them. User research shows what happens when real people use it, and sends you back to the design.
The lessons
- Designing for ambiguity — judgement for AI product design: ambiguous input, opinionated defaults and uncertainty as a design material.
- Practice: the AI feature spec — a one-page spec and an interaction-pattern library.
- Model intuition — judgement about what models do well, badly and not at all.
- Practice: probing and choosing models — a probe worksheet and a bake-off template.
- From pixels to evals — judgement for linking interface choices to model quality.
- Practice: hill climbing — an eval set, an error-analysis loop and a hill-climb log.
- Designing agentic flows — judgement for tools, autonomy and failure modes.
- Practice: the agent spec and risk register — a spec, a risk register and an approval design.
- How users behave with agents — judgement about delegation, trust and reliance.
- Practice: researching agent interactions — methods and an interview guide that fit agents.
- Capstone: ship one AI-native feature — assemble the plan and the launch gate.
Then the recap and real-world examples, with a self-test.