The digital world we live in is this huge, complicated place, and right at its core is the user experience. You know, UX writing? It’s kind of the unsung hero, the invisible architect that gently guides, informs, and reassures people. It takes really complex stuff and turns it into something intuitive and easy to use. But a lot of digital products stumble exactly where they shouldn’t, because their writing just confuses, alienates, or totally misses the mark. So, I want to dive into some of the most common mistakes I see in UX writing, and I’ll give you some practical steps and real-world examples to help you create truly compelling, human-centered copy. My aim is to help you take that user experience from just “functional” to genuinely delightful.
Forget the Inside Baseball: Speak the User’s Language
One of the biggest traps we fall into with UX writing is using our own internal jargon, technical terms, or just being way too formal. We’ve got to remember, our users aren’t immersed in our product’s lingo. They come with their own ideas and expectations.
Mistake 1: Jargon Over Clarity
The Problem: We use terms specific to our company, technical vocabulary, or industry slang that users just don’t get. This forces them to guess or, even worse, give up. It really creates a barrier and chips away at their trust.
Why it Happens: We get so used to how we talk internally that we forget it’s not universal. And sometimes, developers and product managers – with the best intentions – nudge the copy to be technically accurate, even if it sacrifices user understanding.
The Fix: You need to translate technical stuff into simple language. Always assume your user has a basic understanding, but no specialized knowledge. If you absolutely have to use a technical term, explain it immediately in plain language or give them an easy-to-understand tooltip.
Example (Bad): “Initiate transmogrification sequence to reify data packets.” (Seriously, who talks like this outside of a sci-fi movie?)
Example (Good): “Start the data transfer process.” or “Transfer your files.” (Clear, direct, gets the job done.)
Example (Bad): “Your API call to the endpoint returned a 404 Not Found error.” (Unless I’m a developer, this means nothing to me.)
Example (Good): “We couldn’t connect to that page. Please check the address and try again.” (Tells me what happened and what to do next.)
My Advice to You: Do a “jargon audit.” Go through your product’s interface and highlight every single term that isn’t universally understood. Then, brainstorm simpler ways to say those things. And here’s the kicker: test those simpler alternatives with actual users who aren’t familiar with your product. Their confusion will reveal where you need to simplify.
Mistake 2: Formalism Over Friendliness
The Problem: Adopting a tone that’s too formal, institutional, or even robotic. It just lacks warmth and approachability. This can make users feel like they’re talking to a machine, not a helpful guide.
Why it Happens: Sometimes, we mistakenly think professionalism means being stiff. Or maybe we’re afraid of seeming “unserious.” Or, often, there aren’t clear brand voice guidelines, so the copy ends up feeling impersonal.
The Fix: You can inject personality without sacrificing clarity. Aim for a conversational, empathetic tone. Imagine you’re explaining something helpful to a friend. Use contractions when they feel natural and avoid those really ornate, long sentence structures.
Example (Bad): “Your request has been processed successfully. You may now proceed.” (Too stiff, sounds like a very polite robot.)
Example (Good): “Success! You’re all set.” or “Done! You can now continue.” (Warm and inviting.)
Example (Bad): “It is incumbent upon you to ascertain the veracity of the provided credentials.” (My eyes just glazed over.)
Example (Good): “Please confirm your details are correct.” (Much clearer and more human.)
My Advice to You: Define your brand’s voice and tone. Is it playful, serious, empathetic, direct? Document it so everyone’s on the same page. Then, role-play! Read your copy aloud as if you’re speaking to a user. Does it sound natural? Would you actually say it that way in real life?
Being Precise and Purposeful: Crafting Actionable Copy
Every word in a user interface has to serve a specific purpose: to guide, inform, or motivate. If your writing is vague, ambiguous, or just uses too many words, it gets in the way of those goals, leading to frustration and users just leaving.
Mistake 3: Vague Call-to-Actions (CTAs)
The Problem: CTAs that don’t clearly say what’s going to happen when you click them. Users are left feeling uncertain and hesitant. Generic terms like “Click Here” or “Submit” are particularly bad offenders.
Why it Happens: Sometimes it’s a rush to finish a feature, or a lack of real thought put into the writing process. Or, we just default to common patterns that aren’t actually helpful.
The Fix: CTAs must be direct, action-oriented, and set clear expectations. They should answer that unspoken question in the user’s head: “What will happen if I click this?”
Example (Bad): “Submit” (on a form where you’re sending a message, it’s just too generic)
Example (Good): “Send Message” or “Submit Your Application” (Tells me exactly what I’m submitting.)
Example (Bad): “Learn More” (When I’m reading an article about a specific product feature, what does “more” even mean?)
Example (Good): “Discover [Feature Name]” or “See How [Feature Name] Works” (Specific and enticing.)
My Advice to You: Every CTA should have a strong verb that directly relates to the action, and a noun that specifies what that action is affecting. If you’re short on space, prioritize the verb. And don’t be afraid to test different CTA variations to see which one works best!
Mistake 4: Ambiguous Error Messages
The Problem: Error messages that are unhelpful, accusatory, or don’t give you a clear way to fix the problem. They force users to guess or just give up.
Why it Happens: Error messages are often written from the system’s perspective (“something went wrong”) instead of the user’s (“how can I fix this?”). Developers often write the initial error messages because they’re focused on the technical problem.
The Fix: Error messages should always be:
1. Clear: Say what went wrong in plain language.
2. Specific: Pinpoint the exact issue if you can.
3. Humble: Don’t blame the user.
4. Helpful: Offer a solution or a clear next step.
Example (Bad): “Error: Unable to process request.” (This gives me literally no information.)
Example (Good): “Sorry, we couldn’t save your changes. Please check your internet connection and try again.” (It’s apologetic, specific, and tells me what to do.)
Example (Bad): “Invalid input.” (On a password field, this is so frustrating.)
Example (Good): “Your password must be at least 8 characters long and include a number.” (Tells me exactly what’s wrong and how to fix it.)
My Advice to You: For every possible error state, ask yourself: “What does the user need to know right now to fix this?” Provide links to help articles or customer support if the solution is complicated. Make those error states feel more human by showing empathy.
Mistake 5: Over-Explaining and Redundancy
The Problem: Giving too much information, repeating instructions, or using unnecessary words. This just leads to cognitive overload and a cluttered interface.
Why it Happens: Sometimes it’s fear that users might miss something, or a lack of confidence in the design’s clarity. Or simply, we’re not editing with a critical eye.
The Fix: Be concise. Every single word needs to earn its spot. Edit ruthlessly for brevity without losing clarity. If the user interface makes an action obvious, don’t explain it.
Example (Bad): “Please click on the ‘Save’ button located at the bottom right corner of the screen to save your progress and ensure that your changes are permanent.” (Wow, way too many words for something so simple.)
Example (Good): “Save your changes.” or simply “Save.” (If the context is clear, “Save” is often enough.)
Example (Bad): “You have successfully logged in. Your login was successful, and you are now able to access your account.” (Repetitive and clunky.)
Example (Good): “You’re logged in!” or “Welcome back.” (Friendly and to the point.)
My Advice to You: Adopt a “less is more” mindset. Read your copy aloud. Does it drag? Are there any words you can remove without losing the meaning? Pay special attention to introductory text, tooltips, and confirmation messages – these are often culprits of over-explanation.
Empathy and Context: Understanding the User Journey
Good UX writing isn’t just about words; it’s about truly understanding the user’s emotional state, their goals, and where they are right now in the product.
Mistake 6: Ignoring User Context and Emotional State
The Problem: Delivering generic messages that don’t acknowledge where the user is in their journey, what they’ve just done, or how they’re probably feeling (e.g., frustrated, eager, confused).
Why it Happens: We end up writing in a bubble, without a deep grasp of user flows, or we forget to consider edge cases and moments where users might struggle.
The Fix: Anticipate what users need and how they feel. Tailor your messages to that specific moment. Is the user facing an error? Reassure them. Are they doing a complicated task? Encourage them. Are they waiting for something? Explain the delay.
Example (Bad): “Task Complete.” (After a user just submitted sensitive financial information? Not enough reassurance.)
Example (Good): “Success! Your payment has been processed securely.” or “Great! Your application is now submitted.” (This provides reassurance and a clear outcome.)
Example (Bad): “Loading…” (For a long process, this just leaves me hanging.)
Example (Good): “Almost there! We’re preparing your report, this may take a moment.” or “Just a sec, generating your results…” (This sets expectations and gives a friendly update.)
My Advice to You: Map out your user flows and pinpoint those “moments of truth” – the points where users might feel confused, anxious, or even delighted. Craft specific microcopy for these moments. Think about the tone you want to convey at each stage.
Mistake 7: Inconsistent Terminology and Phrasing
The Problem: Using different words or phrases to describe the same concept or action throughout your product. This just leads to confusion and erodes trust.
Why it Happens: Sometimes, you have multiple writers working on different parts of the product, or there’s no central style guide, or the review processes aren’t thorough enough.
The Fix: Establish a strict vocabulary for your product. Once you’ve chosen a term for a specific action or feature, stick to it religiously. This makes your product predictable and easier to navigate.
Example (Bad): “Add to Cart,” then “Purchase Now,” then “Checkout” (for the same flow, perhaps across different pages. It’s jarring.)
Example (Good): Stick to one consistent term, like “Add to Cart,” “View Cart,” “Proceed to Checkout.”
Example (Bad): “Profile Settings,” then “Account Preferences,” then “User Options” (Again, confusing.)
Example (Good): Consistently use “Account Settings.”
My Advice to You: Create a UX writing style guide and a dedicated glossary of terms. This should include your preferred terms, terms to avoid, capitalization rules, and tone guidelines. Make it super easy for everyone involved in content creation to access it.
The Power of Practicality: Actionable Steps for Improvement
Avoiding these mistakes isn’t just about knowing what’s wrong; it’s about building processes and adopting mindsets that truly foster excellent UX writing.
Mistake 8: Neglecting Microcopy Opportunities
The Problem: Overlooking the power of small pieces of text – things like button labels, tooltips, empty states, form field labels, placeholder text. These tiny bits can really enhance usability and even delight.
Why it Happens: We often focus on the major features and treat microcopy as an afterthought, or we just underestimate its cumulative impact.
The Fix: Embrace microcopy as a critical element of the user experience. Every tiny text snippet is a chance to guide, reassure, or even entertain.
Example (Bad): (Empty inbox) “No messages.” (A bit bleak, right?)
Example (Good): “Your inbox is sparkling clean! Send your first message to get started.” or “Inbox empty? Now’s a great time to send an email or catch up on other tasks.” (This provides encouragement or clear next steps.)
Example (Bad): (Placeholder text in a search bar) “Search” (Could be more helpful.)
Example (Good): “Search for products or categories…” or “Find articles, topics, and more…” (This gives helpful examples of what you can search for.)
My Advice to You: Do a “microcopy audit.” Systematically review every small piece of text in your product. Does it add value? Is it clear? Is it consistent? Brainstorm ways to make it more helpful, human, or guiding.
Mistake 9: Failing to Test and Iterate
The Problem: Writing copy in isolation and just pushing it live without checking if it’s clear, effective, or has the right emotional impact with real users.
Why it Happens: Time constraints, budget limitations, or just believing that writing is subjective and doesn’t need testing.
The Fix: Treat UX writing like any other design element: it needs to be tested and refined based on user feedback.
Example (Bad): Launching a new onboarding flow with really complex instructions, just assuming users will understand.
Example (Good): Conducting usability tests with the new onboarding copy, watching where users get stuck or seem confused, and then refining the language based on those insights.
Example (Bad): Sticking with a button label that’s not performing well just because it “sounds good” to you.
Example (Good): Running A/B tests with different button labels to see which one gets more clicks or user engagement.
My Advice to You: Integrate UX writing into your regular design and testing cycles. Do informal hallway usability tests, guerrilla testing, or A/B test critical pieces of copy. Pay attention to user comments, even just anecdotal ones, about the clarity of your text.
Mistake 10: Writing for Artificial Intelligence, Not Human Intelligence
The Problem: Crafting copy primarily for search engine optimization (SEO) or internal system logic, which leads to keyword stuffing, unnatural phrasing, or system-centric language that isn’t user-friendly.
Why it Happens: Over-relying on SEO tools without a human editing layer, or a misguided belief that systems are your main audience.
The Fix: Always prioritize the human user. Write naturally, clearly, and concisely. While SEO is important, it should enhance the user experience, not make it worse. A human-first approach often leads to better SEO anyway.
Example (Bad): “Buy widgets online. Affordable widgets. Best widgets for sale. Purchase widgets here.” (This is just blatant keyword stuffing.)
Example (Good): “Find the perfect widget for your project.” or “Shop our collection of high-quality widgets.” (Natural and helpful.)
Example (Bad): “Please select from the dropdown to access your user ID portal.” (Trying to match internal system terms.)
Example (Good): “Choose your user ID.” (Focuses on the user’s action, not the system’s.)
My Advice to You: Read your copy aloud. Does it sound like something a human would actually say? Does it flow naturally? If you’re optimizing for keywords, integrate them smoothly and naturally. Remember, search engines are getting smarter and smarter at understanding natural language.
The Path Forward: Mastering the Art of User-Centered Language
UX writing isn’t just an afterthought; it’s a truly invaluable part of product design. It’s the voice of your brand, the guide for your users, and often, the deciding factor between a frustrating experience and a delightful one. By systematically avoiding these common pitfalls – by embracing clarity, consistency, empathy, and constant iteration – you really elevate your ability to craft user-centered copy that doesn’t just inform, but truly connects and empowers. The goal isn’t just to make users understand, but to make them feel understood, supported, and confident on their digital journey.