A quick primer on designing with AI  ## Metadata - Author: [[Intense Minimalism]] - Full Title: A quick primer on designing with AI - Category: #articles - Document Note: --- tags: - #ai-design - #llm - #product-design - #ux - #trust-safety - #hallucinations - #wordPress - #open-source Author: Intense Minimalism Source: Article Reference: https://intenseminimalism.com/2024/a-quick-primer-on-designing-with-ai/ date created: 2025-08-21 00:00 --- # Title: A quick primer on designing with AI ## Table of Contents: - [🧭 Overview](#-overview) - [🧠 What LLMs Are](#-what-llms-are) - [🦜 Stochastic Parrots](#-stochastic-parrots) - [🧪 Before You Start](#-before-you-start) - [⚠️ Core Principle: LLMs Hallucinate](#️-core-principle-llms-hallucinate) - [🧰 Additional Design Principles](#-additional-design-principles) - [🎯 Why Add AI?](#-why-add-ai) - [📚 Further Reading](#-further-reading) - [📝 Summary](#-summary) - [📖 Main Content](#-main-content) - [🗒️ Notes](#-notes) - [📖 References](#-references) - [🗣️ Paraphrase](#-paraphrase) - [📰 Newsletter](#-newsletter) - [✅ Action Items](#-action-items) - [🧪 Hypotheses](#-hypotheses) - [📊 Methodology](#-methodology) - [❓ Questions](#-questions) - [🔮 Future Research](#-future-research) - [💡 Implications](#-implications) - [🧠 Learning Styles Assessment](#-learning-styles-assessment) - [📊 Accessibility Assessment](#-accessibility-assessment) - [🌍 DEIB Assessment](#-deib-assessment) - [✅ Logical validity](#-logical-validity) - [🔍 DARVO Analysis](#-darvo-analysis) - [🔍 SEO Evaluation](#-seo-evaluation) - [🎯 Conclusion](#-conclusion) ### References: - Google (2024) “People + AI Guidebook” - C. Fraser (2023) “Who are we talking to when we talk to these bots?” - T. B. Lee, S. Trott (2023) “A jargon-free explanation of how AI large language models work” ## 🧭 Overview The article offers a pragmatic, design-first primer for working with AI—more precisely with LLMs as a design material—centered on user value, risk management, and trustworthy UX patterns. ## 🧠 What LLMs Are - “LLMs are language black boxes that output a prediction to everything that was written before.” - Language: trained on large-scale text (web, chats) - Black box: we know how they’re built, less so why they’re so effective (explainability is ongoing research) - Prediction: next-token prediction guided by training distribution - Written before: chat UX is incidental—really a continuous text stream with pauses for user input ## 🦜 Stochastic Parrots - LLMs emulate answers; they don’t “reason” in the human sense. - Think of outputs as realistic props—often convincing, sometimes revealing their artificiality. ## 🧪 Before You Start - Primary question: Does this add real customer value? - Beware hype- or market-driven pressure; keep focus on concrete user outcomes. ## ⚠️ Core Principle: LLMs Hallucinate - Product implications: - Return outputs to users for review before action - Make errors low-impact, easily reversible, non-distressing - Set expectations; take accountability for errors - Guardrail patterns: - Retrieval/verification to show sources - Constrain outputs via product frameworks (dashboards, theming, design systems) - “Draft first” automation with review gates ## 🧰 Additional Design Principles - Quick Undo - Enhance Features (augment existing capabilities, don’t replace UX with chat by default) - Show Workings (sources, intermediate steps) - Quick Feedback (easy flags, internal review pipelines) - Output/Refine Loop (iterative generation and refinement) ## 🎯 Why Add AI? - Users want solutions, saved time, results—AI is a means, not an end. - Collaborate with strong engineers; prototype in short loops. ## 📚 Further Reading - Google’s People + AI Guidebook - “Who are we talking to when we talk to these bots?” - “A jargon-free explanation of how AI large language models work” ## 📝 Summary: The piece reframes LLMs as a design material characterized by prediction, opacity, and non-reasoning behavior. It argues designers must assume hallucinations and build UX patterns that surface drafts, enable quick undo, verify claims, invite feedback, and support iterative refinement. The goal is user value over hype, with careful guardrails and tight design–engineering collaboration. ## 📖 Main Content: The author advocates a material-informed design approach: understand LLMs, their limits, and their strengths. By recognizing LLMs as predictive black boxes—and embracing the “stochastic parrot” metaphor—designers can set appropriate expectations and create reliable experiences. The core stance is that hallucinations are inevitable; therefore, interfaces must reduce harm via reversible actions, constrained domains, verifiable answers, and visible reasoning paths. Rather than bolt on chat, teams should integrate LLMs to enhance existing features, keep users in control, and enable iterative improvement loops. Ultimately, AI should serve real user problems, with validation through continuous prototyping and feedback. ### 🗒️ Notes - Definition of LLMs - Predictive next-token models trained on text - Chat UX is incidental, not essential - Black-box effectiveness; explainability in progress - Stochastic parrot framing - Outputs are examples, not grounded reasoning - Treat as convincing props that sometimes fail - Value-first decision - Ask: “Does this deliver real customer value?” - Resist hype; prioritize outcomes over features - Core principle: hallucinations - Always show results for user review pre-action - Design for safe failure: undo, low-stakes errors, emotional safety - Responsibility: set expectations, own mistakes - Guardrails - Retrieval + source links - Constrain outputs via product frameworks/design systems - Draft-and-review gates for automation - Principles - Quick Undo - Enhance Features (augment vs. replace) - Show Workings (sources/steps) - Quick Feedback (flag, triage, improve) - Output/Refine Loop (iterative) - Why add AI - Solve problems, save time, get results; marketing can label it - Tight engineer collaboration; short prototyping loops ## 📖 References: - Google. People + AI Guidebook (2024) - Fraser, C. Who are we talking to when we talk to these bots? (2023) - Lee, T. B., Trott, S. A jargon-free explanation of how AI large language models work (2023) ## 🗣️ Paraphrase: - Original idea: “LLMs are language black boxes that output a prediction to everything that was written before.” - Paraphrase: Think of LLMs as opaque text machines that continue a given sequence by guessing the most likely next words based on prior text. - Original idea: “LLMs don’t give answers (they can’t reason), but they give examples of how an answer to that question would look like.” - Paraphrase: Rather than deriving answers through reasoning, LLMs produce a plausible-looking version of an answer—an imitation shaped by patterns in their training data. ## 📰 Newsletter: This week in WordPress and open source: Learning to build smarter without the hype. We’re diving into practical AI design—treating LLMs as a material, not magic. Key takeaways: assume hallucinations, keep humans in the loop, and favor augmentation over all-in chatbots. If you’re leveling up your web dev, we’ve got fresh tutorials on modern PHP patterns, script loading strategies in WordPress, and a hands-on Git workshop. Community highlights: new contributor office hours are back; if you’ve wanted to make your first Core or Docs contribution, join us on Friday! Plugin corner: don’t miss experimental “Explain This Error” in your logs—LLM-assisted, but review-first with one-click undo. We’re also piloting a Code Snippet Refiner inside the Site Editor for safer, iterative tweaks. For product folks, bookmark Google’s People + AI Guidebook for responsible patterns and guardrails. Want more? Reply with your biggest AI-in-WordPress challenge, and we’ll feature solutions next issue. Links: - People + AI Guidebook: https://pair.withgoogle.com/guidebook/ - Contributor onboarding: https://make.wordpress.org/ - Git workshop repo: https://github.com/ ## ✅ Action Items: Prompt for aligning articles with your Developer Advocate/OSPO trajectory: “Analyze how this article advances open-source advocacy, contributor engagement, and education within the WordPress ecosystem. Map each design principle to: - Open-source - Summary: Where I need to say “AI” because it seems that almost the entire world has forgotten that AI is the field, while LLM is the technology, but really: this article is about LLMs. A short background I’… - URL: https://intenseminimalism.com/2024/a-quick-primer-on-designing-with-ai/ Where I need to say “AI” because it seems that almost the entire world has forgotten that AI is the field, while LLM is the technology, but really: **this article is about LLMs**. #### A short background I’ve been working with chatbots for a long time: my MSc was a framework for emotional virtual assistant, it got converted into a [patent](https://patents.google.com/patent/US20080096533) (let’s ignore for a second that it was stolen and published not under my name) that got cited over 200 times by the likes of Apple, Google, Microsoft, Samsung, Intel, etc. Also, I’ve an interest in psychology and intelligence, and my current working theory is aligned with [embodied cognition](https://en.wikipedia.org/wiki/Embodied_cognition). While I haven’t done ‘building’ work in the current wave of LLMs, I still try to be as up-to-date as I can on the field, reading sometimes complex papers or their explanation written by many good people, with a product and design angle. This is because I believe that to design it’s important to **know the material** we work with. And LLMs are a new material. #### So what are LLMs? This question can have many many answers, but for the goal of using it as a material I think one good definition is: **LLMs are language black boxes that output a prediction to everything that was written before**. This is why I prefer this phrasing: * **Language** — they work because they were trained on a lot of text data of people talking with each other (i.e. web and chats) * **Black Box** — we know how LLMs work, but we don’t really know why LLMs work. In the sense that we know how they are built and trained, but we still don’t know why they are so effective. [Explainability](https://arxiv.org/abs/2309.01029) is still a field of research. * **Prediction** — at its core LLMs are predictive: the next statement is a best guess on what it’s expected to come (expected by the training data) after what has been written. * **Written Before** — the reason why LLMs took the shape of chatbots is almost incidental, due to the training data being a lot of people talking with each other. But it’s in many ways a “trick”: in a single conversation you can imagine it’s a *single flow of text that occasionally stops predicting and allows you to add another piece of text before continuing the prediction*. A term that I find very effective is also **stochastic parrot**. This is because LLMs don’t really know what they are doing. They are just predicting, *repeating a blurb of words from the training data*. There’s no intelligence or reasoning in it (at least, in the 2024 generation of LLMs, maybe in the future they will find a way as it’s the current next problem they are trying to solve). Another way to think about it is to realize that LLMs don’t give answers (they can’t reason), but they give *examples of how an answer to that question would look like*. It’s like someone creating an impressive prop for a theatre play. It might be so close to the real thing to be used in place of the real thing, but occasionally it becomes obvious it’s just a prop. #### Designing with LLMs ##### Before starting The question any designer or product person should ask before adding LLMs into a product is: **does it add real value to our customers?** This might be challenging as in some cases this feature has been pushed to the forefront by market forces, expectations, and marketing, but in general we should always try to connect to the real value they can add. ##### The core LLM design principle The first and core principles to design with this technology is: **LLMs hallucinate**. This means that any solution that leverages this tool needs to account that the output might not be accurate, which usually means two possible things: * Make sure to hand the output back to the user to **review** before doin any action. * Make sure that errors in the outcomes are as **inconsequential** as possible, can be undo’ed cleanly and easily, and won’t cause distress to the user. If we understand this, we realize that we need to set the right expectations with our users, as well as be accountable for any error that might be done. When we say that they hallucinate we mean that the core technology (LLMs) hallucinates. Then there are of course approaches that different products do trying to create guardrails. For example search engines verify the output statements with their own search engine queries to show sources, generative outputs use the framework of the software itself to limit its range (i.e. dashboard outputs, or design systems, or theming modules, etc), automation integration show draft to review before activating, etc. ##### The other LLM design principles * **Quick Undo** — make it safe to try things and roll back (i.e. a clear undo action, or a drafting space, or an unpublished item). * **Enhance Features** — instead of thinking as LLM as the product on its own, think how it could be instead augmenting existing features (i.e. have LLMs write a filter for you in the filter feature, not LLM as a chat interface for your existing product). * **Show Workings** — sure LLMs are almost like “magic” when they work, but the trust is low, so it can be useful to show how it reached that decision if possible (i.e. show source links for an answer) * **Quick Feedback** — have an effective feedback loop where people can quickly mark outputs that aren’t effective and *have a pipeline to review them internally* (i.e. dislike button on an answer, then review monthly to improve the answers). * **Output/Refine Loop** — for more complex problems, don’t provide one-and-done actions but create iterative loops where the output can be refined with multiple back and forth (i.e. generate an item, then ask to change and tweak that item until it’s good enough). #### Why we add AI? In general, try to remember that apart from the hype, people want solutions to their problems, save time, and get results. LLMs and anything else that will come out of the AI field in the future is a tool to get there, not the end story. Yes in the short term it might be valuable to highlight “AI features”, leave that to marketing. And as always, work closely with good engineers that have a grasp of this material and prototype in short loops. #### Further readings * Google (2024) [“People + AI Guidebook”](https://pair.withgoogle.com/guidebook/) * C. Fraser (2023) [“Who are we talking to when we talk to these bots?”](https://medium.com/@colin.fraser/who-are-we-talking-to-when-we-talk-to-these-bots-9a7e673f8525) * T. B. Lee, S. Trott (2023) [“A jargon-free explanation of how AI large language models work”](https://arstechnica.com/science/2023/07/a-jargon-free-explanation-of-how-ai-large-language-models-work/), A quick primer on designing with AI, Intense Minimalism, 01ja5sw6eps7nrzva6ersvbs3n.