AI prototyping
The video argues that AI prototypes end up feeling like "AI slop" when builders supply only a thin prompt and expect legacy-level fidelity, and that the fix is "context engineering": deliberately assembling functional, visual, and data context — eventually combined into one full-stack prompt with a separate, swappable data file — so an AI prototyping tool can produce customer-realistic, easily iterable prototypes.
The source diagnoses a common prototyping failure — output that "feels like AI slop" — as arising because builders supply only a thin prompt or mini-spec and then expect the same fidelity they used to get from a full legacy process.
It reframes the fix as a shift from "prompt engineering" to "context engineering": treating prototyping as assembling all the information and tools a model needs, rather than having a conversation with it.
It argues a prototype's required fidelity should be set by the decision it needs to support — if meant to drive customer research, it must be realistic enough to create "suspension of disbelief," otherwise customers switch from describing real behavior to speculating about it.
Through a live demo it builds the case incrementally: a text-only prompt gets surprisingly close but breaks on responsiveness and missing album art; adding a wireframe fixes layout but leaves dummy content; adding real structured data finally produces a prototype judged ready for user testing — each added context type fixes a specific gap the previous one left.
It claims that giving a model real underlying data, rather than a spec, lets the model correctly infer UX decisions (features, layout) on its own, treated as evidence that data is a more powerful lever than manually specifying interface details.
It argues that assembling all context types up front, with data kept in a separate swappable file, produces a prototype whose underlying structure is coherent enough to survive iteration and content swaps — versus letting the AI "figure out the details" itself, which risks incoherent structure.
It reframes the classic linear product process (spec → wireframe → data model → build) not as dead but as radically compressed — the same decisions still happen, just in minutes instead of weeks — and recasts team collaboration as moving from a linear "assembly line" to a fluid, leaderless "jazz band."
It rejects the idea that dedicated visual design tools are becoming obsolete, arguing text-based and visual thinking are distinct cognitive modes that both still need dedicated ways to reach the model, with tool "round-tripping" between code and design expected to keep improving.
It reorders rather than removes the PRD: process order is now organic — teams often prototype and get customer reaction first, then write a leaner PRD supplying what the prototype alone cannot (problem statement, success metrics, strategic fit) — with all artifacts together, not any one alone, giving a complete picture.
It concludes that AI has democratized a capability once reserved for the richest, most product-centric companies — comfortably producing large amounts of work that will never ship — and frames doing so as a hallmark of working in a genuinely "AI-native" way.
Context engineering — The source's reframing of AI-assisted building as designing and building systems that give a model the right information and tools to accomplish a task, replacing the older "prompt engineering" idea of just conversing with a model. Apply: Instead of writing one conversational prompt, deliberately assemble all the information (specs, visuals, data, tools) a model needs before asking it to build.
Functional context — The plain-text mini-spec or prompt describing what a feature or product should do. Apply: Write a short functional prompt describing the feature (e.g. a genre page) and let the prototyping tool expand it into a multi-step build.
Visual context (wireframes) — Supplying an image such as a wireframe, sketch, or mockup so the model can see the intended layout instead of inferring it from text alone. Apply: Sketch a quick wireframe in Figma, Balsamiq, or on paper/photo and attach it to the prompt so the model matches the intended visual structure.
Data context (structured data/JSON) — Providing the model with the actual structured dataset that will populate the product instead of letting it invent placeholder content. Apply: Generate a JSON file with real content (e.g. via Claude) and paste or attach it so the prototyping tool builds the UI and features around real data.
Full-stack prompt — Combining functional, visual, and data context together into one markdown-structured prompt. Apply: Write a markdown prompt with functional requirements, reference an attached wireframe image, and instruct the tool to populate content from an attached or pasted data file.
MCP (Model Context Protocol) servers — A mechanism for connecting an AI model like Claude to external tools or data sources. Apply: Add an existing MCP server (e.g. for album art or images) to Claude so it can fetch real data such as cover art or photos during generation.
Custom MCP server building — Building a bespoke MCP server via Claude Code when no existing server meets a specific data need. Apply: When no free, keyless MCP server exists for a need (e.g. album covers), build a small custom one in Claude Code in about an hour hitting a free source like Deezer, run it locally, and reuse it across future prototypes.
Reforge Build — An AI prototyping tool aimed at teams building on top of an existing product who already have a design system and context to integrate. Apply: Use it as the prototyping tool for demos on an existing product, feeding it the assembled functional, visual, and data context.
Multi-tool "hack your own multi-agent system" — Deliberately using several separate AI tools for different sub-tasks instead of doing everything in one tool. Apply: Prep and refine context in one tool (e.g. Claude for data), then hand only the finished, clean context to the prototyping tool so it isn't polluted with intermediate reasoning steps.
data.json modularity pattern — Saving generated content as a separate data file instead of inlining it in the prompt or chat. Apply: Ask the tool to save data to its own file (e.g. data.json) so the entire content set can be swapped later without touching the prototype's code.
Markdown-structured prompting — Formatting a prompt with markdown so its sections (requirements, visuals, data) are clearly structured for the model. Apply: Write prompts with markdown headers or lists separating functional requirements, visual references, and data instructions.
Suspension of disbelief — A UX-research concept the source uses to argue a prototype must be realistic enough that customers describe what they're doing rather than theorize about what they'd do. Apply: Check whether a prototype is visually and functionally realistic enough that a customer testing it forgets it's a mockup, and add missing context types until it is.
Data-driven UX inference — Feeding a model only structured data with minimal instructions and letting it infer likely UI elements and features from the shape of the data. Apply: Paste a real dataset with minimal instructions and review what UI elements (filters, sort, grids) the tool infers as a brainstorming step.
Jazz band collaboration model — A framing for how product, design, and engineering roles now collaborate: cross-functional specialists riffing off each other with no fixed leader, replacing the old linear "assembly line" handoff. Apply: Treat the AI-prototyping process as fluid, cross-functional co-creation rather than each role waiting for the previous one's handoff.
Prototype-then-PRD workflow — A reordering of classic product process where a prototype is built and tested with customers first, then a leaner PRD is written afterward to capture the problem, goals, and strategy that the prototype alone can't convey. Apply: Build and test a prototype to validate direction before writing a full PRD, then write a lean PRD linking to the prototype and covering only the problem, success metrics, and strategic fit.
Feeding the model raw structured data with almost no spec caused it to invent UX features never requested (follow-a-genre, an essential-albums grid, tag filters) — used here as a brainstorming technique rather than just a shortcut.
Keeping generated content in a separate data file rather than inline in a prompt let a full genre swap (downtempo → psychedelic rock) happen by replacing one file, with zero changes to the prototype's code.
When no ready-made MCP server fit the need for real album art, the source built a small custom one in Claude Code in about an hour hitting a free, keyless source (Deezer), then reused that same server across demos for months and rebuilt the same pattern for travel/location data.
Deliberately splitting work across separate AI tools (one to prep data, another only for final assembly) is framed as a way to keep the prototyping tool's context unpolluted by intermediate reasoning steps, not just a convenience.
The classic waterfall sequence (spec → wireframe → data model → build) is presented as still fully intact, just compressed from roughly two weeks to about ten minutes — the same decisions, not a different process.
Comfortably producing prototypes that are never meant to ship is reframed as a formerly expensive privilege of the largest, most successful companies that AI now makes affordable to any company.
«It kind of feels like AI slop.»
— 00:00
«We've moved from a really fast assembly line approach to much more of a jazz band.»
— 00:34
«context engineering is designing and building systems that provide an AI model with the right information and tools to accomplish the task.»
— 02:00
«a really good prototype is a good decision-making tool.»
— 03:25
«you can use not just the tool itself, but you can use multiple tools in concert to sort of almost hack your own multi-agent system.»
— 04:41
«you're only giving the prototyping tool the context that it absolutely needs rather than polluting the tool with a lot of context that are intermediary steps.»
— 04:58
«if you're building a house, you would never work with an architect that doesn't know how to draw blueprints.»
— 10:06
«JSON is similarly ubiquitous as a format and a really good way to define structured data.»
— 14:24
«I think it's like the difference between sketching and painting an oil painting.»
— 29:23
«I think that there are two different ways to think. There's like a text-based way to think and there's a visual way to think.»
— 31:03
«all of that stuff that's really taste-based is it going to become more important, and that's going to set apart a product that feels like really dialed in versus a product that feels like AI slop.»
— 33:49
«you and I grew up in PM where like, you know, everyone like I remember at Microsoft and people were writing like 17-page PRDs.»
— 34:04
«each individual artifact alone is not enough to explain itself, but collectively you have a very clear um path forward.»
— 35:29
«a prototype is like I I I can tell you like I actually want this or I don't want this, right? It's the way faster to get to your answer, I I think.»
— 37:01
«I think a lot of times the best companies that were really good at being product-centric were the ones that were comfortable doing a lot of wasted work.»
— 37:18
«Yeah, as long as the stuff you're creating is not a 17-page doc, you know.»
— 37:51
«This is such an important skill. We want to make sure as many people as possible have access to it.»
— 38:41
Reception
Comments are largely positive and appreciative, praising the content and taste while requesting follow-up videos on production and advanced topics.
A demo-driven practitioner tutorial rather than an abstract framework: its value is in the concrete Reforge/Claude/MCP walkthrough, and its claims about faster iteration and better fidelity rest on one guest's live demo and interview commentary rather than independent evidence.

38:49