Video summary

Complete Course: AI Product Design

Main summary

Key takeaways

Educational

Main ideas, concepts, and lessons

1) How to design AI features (a 3-step process)

Define the product you’re building

  • Clarify the product goal and what “job to be done” the AI will support.
  • Identify the target users and the contexts they’ll use the AI in.

Design it

  • Design the UX for AI’s realities (e.g., non-determinism, hallucinations, varying confidence).
  • Plan how the AI output will be presented, verified, and corrected.
  • Work with research/evaluation teams to define what quality looks like.

Build it

  • Implement the feature and safeguards (model-side and UX-side).
  • Iterate using real-world testing, evals, and feedback loops.

2) AI products aren’t just “chat”—break out of linear conversational UX

Key critique: Chat interfaces produce linear exchanges that are hard to reference and limiting for tasks that need:

  • branching decisions,
  • visual coordination, and/or
  • more deterministic control.

Preferred alternative interaction patterns (examples given):

  • Use image/video as a central artifact Keep the photo/video visible while dialogue happens around it (like a “video mechanic” rather than a single text answer).

  • Use canvas/document-style co-creation Chat should behave more like a tool for collaboration (“co-create”) than the entire interface. Example mentioned: Cove, which provides a canvas rather than a single linear chat box.

  • Support “deterministic-ish” tasks carefully If the user needs controlled, structured outputs (e.g., itineraries), designs must handle regeneration failures and hallucinations.

3) Design for AI’s non-determinism using safeguards (model + UI + human review)

A recurring theme: AI output can be wrong even when it sounds plausible.

  • Model-side / AI research safeguards

    • Evaluate with AI evals (quality measurements).
    • Reduce hallucinations via testing and confidence handling.
    • Improve training/effective behavior by reviewing:
      • training data,
      • model biases, and
      • known failure modes.

  • UI-side safeguards

    • Make it clear what is original vs AI-generated (especially for “hybrid” outputs).
    • Consider confidence/visibility rules, e.g.:
      • don’t show AI search answers when confidence is low, or
      • present alternatives (A/B options) for sensitive scenarios.

  • Human-in-the-loop checks

    • The UI should enable human reviewers to quickly verify risky content.
    • Example: image expansion should provide clear delineation so reviewers can inspect what the AI filled in.

4) Concrete example of AI pitfalls: image expansion can create unintended consequences

Story summary:

  • At an AI conference, a person submitted a headshot.
  • Later, the conference promotional image looked different in a way that raised concern (appeared to show unintended personal details like “bra showing”).
  • Investigation found:
    • the image was cropped/squared,
    • then an image expander tool enlarged it to a portrait framing,
    • causing unintentional but “plausible” AI fill.

Lesson:

  • Hybrid image workflows can obscure what AI changed.
  • Real-person/human workflows require extra scrutiny beyond the “normal” assumption that edits are safe or obvious.

5) What “good AI product design” looks like in practice (examples of categories)

A) General-purpose AI assistants (ChatGPT as the example)

Design takeaways:

  • Start with a simple, universal core job Getting information/answers is intentionally approachable.

  • Keep the interface uncluttered Reduce “crap clutter,” but handle the “blank screen problem” for new users via suggestions/prompts/modes.

  • Offer multiple input/output modes Text, voice, voice-first usage.

  • Layer “level-ups” without overwhelming Users can specialize or build GPTs, but the default is usable immediately.

  • Get out of the user’s way Rather than heavy walkthroughs, provide suggested prompts and flexible interaction patterns.

B) AI-enabled editing tools (Descript and Riverside)

Design takeaways:

  • Bake AI into core editing jobs instead of sprinkling it superficially.

  • Editing-by-transcript Edit video via editable transcript (faster than scrubbing time).

  • Remove filler words Identify “um/uh/like” and reduce them with relatively seamless handling.

  • “Human-looking” presentation features Example: changing gaze to appear more like the speaker is looking at the camera.

  • Extract structure automatically Generate clips, titles/sections, and organizing metadata—turning a big recording into usable pieces.

Lesson statement from the discussion: The product doesn’t require users to “know AI”—it supports the full editing lifecycle.

C) AI image generation (Midjourney discussed alongside UI friction)

Design takeaways:

  • Even with a controversial/complex UI (historically Discord-based workflows), it can succeed if:
    • the experience is fast from idea → options,
    • output quality is consistently “good enough” for users, and
    • onboarding friction is manageable (e.g., web interface).

Operational constraint:

  • Image generation is expensive, so tools limit free usage and push subscription—design must account for exploration limits.

D) Voice-first AI UI

Design takeaways:

  • Design for context—often users won’t look at a screen.
  • Voice can feel magical because it supports natural conversation while visual attention is elsewhere (e.g., driving).

  • Coaching/behavior feedback can emerge from omnipresent context: e.g., “don’t hog the conversation,” waiting for children to finish, etc.

  • Interaction design must reflect how humans process information: Example critique: reading a menu item-by-item like a screen reader vs offering a more conversational flow (ask preferences, summarize categories first, then offer details).

6) AI design tools: helpful for productivity, not a substitute for taste

Recommendations / cautions:

  • Many designers still prefer Figma and use AI tools at the edges.
  • Suggested practical uses:
    • Figma Copilot for first-pass layout/ideas,
    • ChatGPT-like tools for product specs, and
    • AI-assisted prototyping/demos.
  • Expectation management:
    • current AI design tools won’t “solve your design” from scratch.
    • designers must still provide taste, review, and quality judgment.
  • Analogy: AI tools may move outcomes toward “average,” but craftsmanship still matters.

7) “LinkedIn for AI” as an example of solving a hazy AI design problem

The episode outlines how to start rather than jumping to pixels:

Stepwise alignment process:

  1. Define business objective
  2. Identify the technical innovation
  3. Choose user groups / interfaces needed

Concept directions discussed:

  • matchmaking (job matching/talent fit),
  • certification/training, and
  • content/distribution/social feed.

Example chosen for deeper design: “LinkedIn for AI” as matchmaking.

  • Match quality concept

    • Define what makes a “good match” between job seekers and employers using attributes beyond basic resumes.
    • AI could incorporate richer behavioral/personality/fit signals (example: structured personality-testing administration adapted for broader use).

  • UI concept

    • Separate UIs for job seekers and employers, with AI “magic” happening between them.

  • Possible UX metaphor ideas

    • Tinder-like “fit/no fit” interactions
    • comparisons to other matching domains (dating, college admissions) where “fit” is central

8) Historical product design lesson applied to AI: don’t redesign the whole thing—fix the details and architecture

Google Search and Maps examples:

  • Search
    • Evolved by adding formats (images, video, map results) while keeping a consistent structure.
    • Key claim: design excellence is often in nuances and ongoing detail work.
  • Maps redesign into clarity
    • Google Maps had too many tabs/search inputs at the top.
    • They reduced complexity via design architecture:
      • combined multiple search boxes into one single search box (controversial at the time).
    • Core principle: periodic “feature purging” to avoid clutter and re-center on core user tasks.

Methodologies / instruction-like frameworks (detailed bullets)

A) High-level AI feature design methodology (3 steps)

Defining

  • Choose the product goal (what should the AI enable?).
  • Determine the primary user job(s) and user groups.
  • Establish the key success criteria conceptually (what “good” means).

Designing

  • Plan UX for AI non-determinism:
    • decide when to show answers,
    • how to communicate uncertainty, and
    • how users correct/verify output.
  • Coordinate with research/eval teams:
    • align on evaluation metrics and failure modes,
    • ensure safeguards are designed into the workflow.
  • Decide on interface patterns beyond chat:
    • image/video centered experiences,
    • canvas/document co-creation,
    • voice-first interaction patterns.

Building

  • Implement the system with evaluation and guardrails:
    • AI evals,
    • confidence gating, and
    • human-in-the-loop review when needed.
  • Validate through field testing in real contexts.

B) Safeguards checklist for AI features (especially risky hybrid outputs)

  • AI research / model safeguards

    • Review training data sources and potential harmful/pornographic content exposure.
    • Run evaluation suites for:
      • hallucinations,
      • sensitive attribute generation, and
      • bias/diversity issues.

  • UI safeguards

    • Differentiate clearly what is:
      • original input vs AI-filled content.
    • Use UI mechanisms that support human review:
      • visible overlays/controls that help reviewers inspect changes (without hiding them).
    • For sensitive or low-confidence scenarios:
      • avoid auto-rendering unsafe expansions, and
      • consider presenting alternative options rather than one definitive output.

  • Human-in-the-loop

    • Provide easy-to-check UI states so humans can approve/deny changes quickly.

C) Product design process for “hairy/vague” AI problems (as exemplified by LinkedIn for AI)

  • Start with alignment (before Figma/pixels)

    • Define the objective (what business outcome are you pursuing?).
    • Clarify the innovation and how it changes capabilities.
    • Identify the user groups and their tasks.

  • Then design the interaction architecture

    • Decide where AI lives in the workflow (middle “magic” vs either-end assistance).
    • Define onboarding/input flows for each user group.
    • Draft candidate UX patterns (e.g., matchmaking feeds, swipe fit/no fit, etc.).

  • Aim to “emerge from ambiguity”

    • Convert hazy goals into a clear “what we’re building and for whom.”

Speakers / sources featured (identified in subtitles)

People / hosts

  • Elizabeth Lari/Laraki (also referred to as Eliz Lorrai / “Eliz LARAKI”)
  • Akash (podcast host; repeatedly speaking to Elizabeth)

Other mentioned people (as references)

  • Sam Altman
  • Fiji
  • Andy and Steven (associated with Cove; also linked to Street View and Uber Eats)
  • Olga (researcher who studied landmark-based directions in India)
  • Janet (designer working on directions who traveled to India)

Brands / products / organizations referenced

  • Google Maps, Google Search
  • ChatGPT, Claude, Gemini
  • Midjourney
  • Descript, Riverside
  • Figma, Figma Copilot
  • Discord, Cove
  • Vanta, Chameleon, Maven (sponsors)
  • Electric Capital (Elizabeth’s current affiliation mentioned)
  • Substack, Twitter, LinkedIn (distribution/social references)

Original video