The Designer’s Guide to Large Language Models
First things first, this article isn’t exclusively for designers but it was written for them. If you aren’t a designer but interested in LLMs, you are free to stick around and learn something about how to shape the behind the scenes of the technology that you are very likely to interact with later today. Your call, no pressure.
The next thing, why do designers need to know about LLMs? Speaking for myself, my design “game” really amped up when I understood the relationship/conversations my design was asking of the back end, especially APIs.
Consider designing a user profile page. A naive design might show all user data at once-personal info, purchase history, preferences, and activity logs. But understanding APIs reveals the cost: each data type requires separate database queries. A knowledgeable designer can create progressive disclosure patterns that load core information first, then fetch additional data only when users request it. This reduces server load, improves performance, and creates better user experiences through faster initial page loads.
It is not just about the relationship between the design and the LLMs but it also about understanding LLMs place in the marketplace, the growing expectations and not getting crushed under the the terminology tsunami.
Why Focus on LLMs?
The Market Reality
LLMs represent only 2-3% of the total AI market at $6.4 billion in 2024. Yet they’ve captured something far more valuable: mind share. LLMs dominate 69% of AI tool usage in the US. ChatGPT alone has more than three times the user base of its closest competitors combined. More importantly for designers, LLMs are projected to power 750 million apps by 2025.
This isn’t just about market size. According to Nielsen Norman Group, AI and conversational interfaces represent the first new UI paradigm in 60 years. And I tend to agree. We’ve fundamentally flipped the script. Instead of humans learning to talk to computers through clicks and drags, we’ve taught computers to talk with the average user in their language. Whether the LLMs listen all the time… that’s a different story.
Unlike computer vision systems that work behind the scenes, LLMs sit at the intersection of human communication and machine capability. Every design choice you make directly affects how users interact with these systems. These interactions determine adoption or abandonment: they shape user trust, task completion rates, and ultimately whether users continue engaging (or tolerating) your product. Misaligned conversation design leads to user frustration, abandoned tasks, and negative brand perception. GOOD conversation design speaks to the user and guides them to outcomes that gets them closer towards their goals and balances the needs of the LLM limitations and potential.
Understanding LLMs Through a Design Lens
Understanding the available models isn’t just about technical specifications; It’s about constraint-driven design decisions that directly impact user experience and product viability. But first, it’s crucial to address a fundamental misunderstanding about what designing for conversational AI actually entails.
The Great Misconception
There’s a widespread belief that conversation designers just write prompts. As Rômulo Luzia puts it:
“Diminishing our craft to just prompt design is not only a disservice to our class but also shows a lack of understanding of the value that conversation designers bring to the table.”
The reality is stark. Prompt writing is just a fraction of what conversation designers do. The real work involves user research, testing, prototyping, understanding human communication patterns, and bridging the gap between human and artificial intelligence systems.
The Three Model Tiers
The current model offers three distinct tiers:
Local Models (Privacy-First)
- Models: Mistral Small 3, Llama 3.3 70B
- Design implications: Enable privacy-first design patterns and offline functionality
- Interface considerations: Graceful handling of device limitations, battery drain indicators, offline mode transitions
Cost-Conscious Models (Scale-Friendly)
- Models: AWS Nova Micro, GPT-4.1 Mini
- Design implications: Enable AI features at scale without prohibitive costs
- Interface considerations: Generous AI assistance, real-time features, reduced friction around AI interactions
Premium Models (High-Reasoning)
- Models: Claude 4, O1 Pro
- Design implications: Require careful UX consideration around when expensive reasoning is necessary
- Interface considerations: Transparent cost communication, selective activation, clear value proposition for premium features
Practical Design Guidelines for 2025: The Core Fundamentals
Despite rapid evolution in LLM capabilities, certain fundamental constraints remain unchanged and must inform your design decisions.
The UX Crisis in AI
AI is suffering from a massive UX problem. As Jurgen Gravestein observes: “Similar to the early days of the web, it is predominantly technical people that drive the development of these new products and services. They think technology-first, not user-first.”
The bottom line is stark: “AI is nothing without good UX and the UX of AI is conversation design.” Without proper conversation design, we end up with lack-luster bots that underperform and leave users with bad experiences. Ironically, LLMs were expected to solve the “bad bot” problem. Instead, they’ve highlighted how essential good conversation design really is. I write critically to hammer the point but not to wantonly bash LLMs being the “bane” of UX. Grammarly is a good demonstration of LLMs and users needs. The tool offers writing assistance that feels like a knowledgeable editor looking over your shoulder. The interface provides explanations for suggestions and maintains user agency throughout the editing process.
Understanding the Cost-Usability Relationship
Every design decision in LLM interfaces has a direct economic impact. Consider these two approaches to building a customer support interface:
Approach A: The Context-Rich Design You create a beautiful timeline showing purchase history, support tickets, billing changes, and account modifications. Each time users ask a question, your interface sends this complete context to provide personalised answers.
For the sake of this example, this has the beginnings of solid UX, serves the users needs and doesn’t have too much friction. But you’ve just created a system where asking “What’s my account balance?” costs the same as asking “Please analyse my entire relationship history with your company.” Every simple query now carries 3,000+ tokens of context, transforming a fraction-of-a-penny operation into a potentially expensive interaction at scale.
Approach B: The Progressive Context Design Design the interface to start lean. Show basic account status prominently, but keep additional context collapsed. When the AI determines it needs more information, it can request specific details: “To answer that question about your billing, I’ll need to review your recent payment history. Should I include that context?”
This approach respects both the user’s attention and the computational economics. Simple questions get simple, fast, cheap answers. Complex questions naturally expand to include necessary context, with user awareness and consent.
Note: It’s not your job to know all the economic details, but it is empowering to be aware of this information. The goal of this article is to give designers an awareness of what their designs for LLMs may imply.
Designing for Probabilistic Outcomes
Traditional software is deterministic-meaning the same input always produces the same output. LLMs are fundamentally different in that they are probabilistic. This requires new interface patterns that many designers haven’t internalised yet.
A traditional approach might present this like a word processor. You input requirements, the AI generates a draft, and you edit it. But this ignores the probabilistic nature of LLMs.
A better approach acknowledges that the AI might produce three dramatically different emails from the same prompt. Design the interface to generate multiple options by default, each with different tones or approaches. Show these as tabs or cards, allowing users to quickly compare approaches or blend elements from different versions.
Design for iterative refinement. Instead of a binary “regenerate” button, provide granular controls: “Make this more formal,” “Add more detail about the budget,” “Shorten the conclusion.” Each refinement should build on the current version rather than starting over.
What’s Happening Behind the Scenes: When users make these granular refinements, the LLM receives the original content plus specific modification instructions. This is more efficient than regenerating from scratch because it leverages the existing context and builds incrementally. The model uses attention mechanisms to focus on the specific aspects needing change while preserving the rest of the content.
The Context Window as Design Constraint
A context window refers to the amount of text (measured in tokens) that an LLM can “remember” and work with at any given time. The terminology comes from the transformer architecture’s attention mechanism, which processes information within a fixed “window” of tokens. Think of it like short-term memory everything within the window is immediately accessible, but information outside the window is effectively forgotten.
Context windows function like screen size constraints in responsive design. They’re invisible to users but fundamentally shape what’s possible in your interface.
The Long Conversation Problem Traditional messaging app patterns seem natural, but they create a hidden problem: after enough conversation, the most important context starts falling out of the LLM’s “memory.”
The user might reference something crucial they mentioned three weeks ago, but the AI has no memory of it because it’s beyond the context window. From the user’s perspective, the AI suddenly seems to have forgotten important personal details, reducing trust and increasing frustration. This problem is compounded by automatic memory features like ChatGPT’s context persistence, which can backfire when the AI draws from previous conversations without explicit user consent.
Better interface design acknowledges this constraint explicitly. Create summary panels that highlight key insights or decisions from previous conversations. Design “pinning” functionality that lets users mark important context to remain accessible. Most importantly, set user expectations appropriately.
Structured Input Design for Complex Tasks
Natural language interfaces which include but aren’t limited to chat interfaces seem intuitive, but they often work against LLM capabilities. This is where understanding the psychology of human-computer interaction becomes crucial. Research in neurolinguistics shows that humans are psychologically wired for speech patterns and respond positively to computers that mimic human conversation because it activates the same neural pathways we use for social interaction, particularly in areas like Broca’s and Wernicke’s areas responsible for language processing and comprehension.
Scenario: Designing a Content Strategy Assistant The natural approach would be a chat interface: “Help me create a content strategy for Q2.” But this forces the AI to guess at crucial details about your industry, audience, goals, and constraints.
A better approach uses progressive disclosure with structured inputs. Start with natural language to capture the core request, then expand into structured fields that gather essential context: industry dropdown, target audience checkboxes, primary goals selector, budget range slider, timeline picker, and competitor analysis toggle.
This isn’t about replacing conversation with forms. Recognising when structure helps both the user with their task AND simultaneously helps with the LLM’s performance is the goal. Conversation designers serve as essential translators here: computers need structured data while humans understand language intuitively. Studies show that users complete tasks 40% faster when complex requests are broken into structured components while maintaining conversational flow.
Trust Calibration Through Interface Design
Users tend to either over-trust or under-trust AI systems. Both extremes are problematic according to research from MIT and Stanford on human-AI interaction. Interface design plays a crucial role in helping users develop appropriate trust calibration.
Designing for Appropriate Trust Levels:
Confidence Indicators: Use visual design language to communicate uncertainty. For high-confidence responses, use solid colours and definitive language. For uncertain responses, use softer colours, dotted lines, or “suggestion” styling.
Source Transparency: Make it easy to verify AI claims through expandable source sections, automatic footnotes, or sidebar panels showing reasoning chains.
Graceful Failure: Design clear error states that explain when the AI cannot help and provide alternative paths forward.
Progressive Disclosure of AI Involvement: Start with the value, then reveal the AI assistance. For example, show the helpful answer first, then include a small “AI-assisted” label.
Calibrated Language: Train your AI to use appropriately uncertain language. “Based on the information provided, it appears…” rather than definitive statements when uncertainty exists.
Security and Safety Considerations
System prompts are actually design decisions that directly affect user experience. OpenAI learned this dramatically when a system prompt instructing ChatGPT to “match the user’s vibe” led to sycophantic responses that told users their “lollipop on a stick business idea is genius” and even advised people to stop taking medication. The fix was simple prompt engineering: changing the instruction to “be direct. Avoid ungrounded or sycophantic flattery.” Not every product will have this concern but the morality is always a part of design.
Looking Forward: What Designers Should Watch
The trajectory toward autonomous AI agents represents perhaps the most significant design challenge on the horizon. Unlike current LLMs that respond to individual queries, these systems will plan multi-step workflows, make decisions autonomously, and take actions on behalf of users. This evolution demands entirely new design paradigms around delegation and oversight.
Multimodal integration is accelerating rapidly, with models like GPT-4o processing text, images, and voice simultaneously in real-time. This convergence creates both opportunities and complexity for designers who must now consider how users switch between input modalities, how context carries across different types of interaction, and how to create unified experiences that feel coherent rather than fragmented.
Real-time processing improvements are enabling streaming responses and interactive refinement that approaches the fluidity of human conversation. Studies from Anthropic show that users prefer AI responses that build incrementally rather than appearing all at once. This requires careful design consideration around interruption patterns, response pacing, and the visual treatment of evolving content.
Are We Heading Toward a Chat-Only Future?
While conversational interfaces are powerful, the future likely isn’t purely chat-based. Instead, we’re moving toward conversational augmentation of existing interfaces. AI will enhance familiar patterns forms, dashboards, editors with natural language capabilities rather than replacing them entirely. The most successful AI products blend conversation with traditional UI elements, using each approach where it’s strongest. Chat excels for exploratory tasks and complex requests, while traditional UI elements remain superior for quick actions, data entry, and visual tasks.
As we navigate this transformation, remember that the LLM landscape changes monthly. Models have dramatically different strengths, costs, and capabilities. Design interfaces that can gracefully accommodate this diversity rather than being tied to specific model characteristics.
Perhaps most importantly, we must recognise that “As long as there are bots out there talking to people, there will be someone who self-identifies as the conversation designer.” This suggests conversation design isn’t just surviving the AI revolution. It’s becoming more crucial than ever as our primary interface with artificial intelligence. We’re not just designing interfaces anymore. We’re designing the fundamental way humans and AI will communicate for generations to come.
A big thank you to Jakub Żerdzicki and Charles Asselin on Unsplash for their photos ❤️