How to Learn from Bad UX Writing Examples.

by

The digital world. It’s this huge, sometimes confusing place. For us, navigating and figuring things out depends so much on the words we see, even more than just the design. Really good UX writing just kind of melts into the background, guiding you smoothly. But really bad UX writing? That stuff screams for your attention, not because it’s brilliant, but because it’s just broken. And honestly, it’s in those cracks and breaks where the most valuable lessons are hiding for those of us who want to master this craft.

Instead of just turning away from crummy copy, we need to take it apart, understand why it failed, and then reverse-engineer the solutions that would make it amazing. This isn’t about being mean or gloating; it’s about growing strategically. This is my guide to helping you pull mastery out of mediocrity.

The Power of the Empty Space: Why Bad Examples are Gold Mines

Imagine an artist. They don’t just study masterpieces, right? They also look at awkward sketches and messed-up photos. They learn what not to do. They start seeing common mistakes and understanding how even tiny changes can screw up or totally save a piece. UX writing is exactly like that. Good examples show you success, they give you a blueprint. But bad examples? They shine a light on the traps, on what frustrates users, and on how fragile communication can be. Ultimately, they help you make your own writing bulletproof against these common problems. They teach you empathy by showing user frustration, clarity by highlighting confusion, and conciseness by exposing just how wordy things can get.

Taking Apart the Disaster: My Framework for Analysis

Learning from bad UX writing isn’t just watching passively; it’s an active, multi-layered deep dive. Each bad example is like a unique problem that needs a systematic diagnosis.

1. Spot the Immediate Problem: “What’s Wrong Here, Right Away?”

Before you get into the weeds, pay attention to your gut reaction. That first moment of friction is what the user feels.

  • For example: You see a login screen and the button says “Proceed to Secure Area (SSL Encrypted).”
  • My immediate problem with it: It’s redundant, clunky, and uses technical jargon. The “SSL Encrypted” part is already implied by “Secure Area” and we, as users, shouldn’t have to see that.

2. Isolate the Core Mistake: Pinpointing What Principle Got Ignored

Bad UX writing always breaks one or more fundamental UX writing principles. Your job is to match the pain point you saw to the underlying principle that was violated.

  • Clarity: Is the message vague, unclear, or could it be misunderstood?
    • Bad Example: “Your request could not be fulfilled at this time. Please try again later.”
    • Core Violation: It’s not clear why the request failed or what “later” means. It doesn’t explain the error or tell you what to do next.
  • Conciseness: Is there too much text, jargon, or repeated information?
    • Bad Example: “Click on the designated button labeled ‘Submit Your Application for Review’ to finalize the process of submitting your officially prepared document.”
    • Core Violation: Overly long language, repetitive phrases, way too formal.
  • Consistency: Does the language, tone, or specific words change unexpectedly across the product or when you’re using it?
    • Bad Example: One screen uses “Save,” another uses “Store,” and a third uses “Commit Changes” for the very same action.
    • Core Violation: Inconsistent names make us think harder and get confused.
  • User-Centricity/Empathy: Does the language blame the user, use too much technical jargon, or just ignore our needs/feelings?
    • Bad Example: “ERROR 404: Page Not Found. The resource you sought is unavailable.”
    • Core Violation: It’s impersonal, technical (404), not helpful, sounds like a developer talking to a computer, not to me.
  • Actionable/Helpful: Does the text guide you well, give clear next steps, or offer solutions?
    • Bad Example: “Something went wrong.” (Error message)
    • Core Violation: No useful info, no help, leaves you stuck.
  • Tone & Voice: Is the tone wrong (too formal, too casual, condescending, robotic)? Does it fit the brand?
    • Bad Example: A financial app saying “Hey there, moneybags! Ready to stash some cash?”
    • Core Violation: Inappropriate, way too casual for something serious.
  • Accessibility: Is the text hard to read, too much to look at visually, or unclear for people with different abilities? (like tiny font, bad contrast, complicated sentences)
    • Bad Example: Long, dense paragraphs of legal fine print on a phone screen.
    • Core Violation: Visually overwhelming, hard to scan, not made for mobile.
  • Credibility/Trust: Does the language sound fake, untrustworthy, or like a dark pattern (a trick to make you do something)?
    • Bad Example: A pop-up saying “No thanks, I don’t want to save money” as the “no” option for a discount.
    • Core Violation: Guilt-tripping, manipulative language that destroys trust.

3. The “Why”: Digging into the Root Cause

Once you’ve found the violation, dig deeper into why it probably happened. This goes beyond just criticizing the surface to understanding what went wrong in the design and writing process.

  • Developer-Speak: The writer didn’t translate technical terms for the user. (e.g., “Authentication failed,” “Invalid payload.”)
  • Lack of User Research/Testing: The writer didn’t understand how users think, what words they use, or their typical journey. (e.g., assuming users know what “cache” means.)
  • Design Constraints (or Not Pushing Back Enough): The writer was given too little space, or couldn’t convince others to allow for more clarity. (e.g., a tiny error box forcing just “Error!”)
  • Rushed Process/No Dedicated UX Writer: Anyone just wrote it, without specific UX writing expertise. (e.g., marketing copy dumped into a crucial part of the app.)
  • Company Jargon/Internal Language Leaked: Internal terms showed up outside the company. (e.g., mentioning “Q3 roadmap feature” in a message to a user.)
  • Overly Formal/Legalistic Tone: Fear of legal issues or wanting to seem professional led to really clunky language. (e.g., super long disclaimers for simple actions.)
  • Poor Information Hierarchy: Important info is buried, or irrelevant info is front and center. (e.g., an error message that puts a generic code before the actual problem.)
  • Ignoring User Context: The message doesn’t consider when or where the user sees it. (e.g., a generic “Error!” when the user is trying to make a time-sensitive payment.)

A Concrete Example of Taking it Apart:

  • Bad Example: You click “Delete Account” and a pop-up says: “Are you absolutely positive you wish to permanently terminate your membership with us? This action cannot be undone.” (Buttons: “Yes, terminate” / “No, cancel”)

  • 1. Immediate Pain Point: It’s way too formal, sounds aggressive, alarming, fear-inducing, and the phrasing is too long for a simple confirmation. “Terminate membership” feels like a funeral!

  • 2. Core Violations:

    • Clarity: “Absolutely positive” is verbose. “Terminate membership” isn’t how we, as users, think of our accounts.
    • Conciseness: Too many words (“absolutely positive,” “permanently,” “with us.” “This action cannot be undone” is already implied by “permanently”).
    • User-Centricity/Empathy: The tone is accusatory and cold. It focuses on what the system is doing (“terminate”) rather than what I want to do (“delete”). It’s high-stakes language for a standard (though serious) action.
    • Tone & Voice: Doesn’t fit with what’s likely a friendly or neutral brand voice. Sounds like legal talk.
  • 3. Root Cause:
    • Fear of legal liability or customer complaints (“This action cannot be undone” is probably a legal requirement, but it’s phrased badly).
    • Lack of empathy for the user/understanding of common user language.
    • Possibly internal jargon (“terminate membership”) that leaked out.
    • Probably no dedicated UX writer, or the writer was overruled by legal or other stakeholders.

The Makeover: From Flawed to Flawless

The real learning happens when you actually change things. How would you fix it? This step is super important for truly understanding the principles.

1. Brainstorm Solutions: Many Ways to Improve

Don’t just go with the first fix you think of. Explore several ways to rephrase something, focusing on different areas of improvement.

  • My Example (from “Terminate Membership”):
    • Option A (Focus on Conciseness): “Delete your account? This can’t be undone.” (Buttons: “Delete” / “Cancel”)
    • Option B (Focus on User-Centricity/Clarity): “Confirm account deletion. This action is permanent.” (Buttons: “Delete Account” / “Keep Account”)
    • Option C (Adding Context/Helpfulness): “Are you sure you want to delete your account? This can’t be undone. Your data will be removed.” (Buttons: “Delete My Account” / “Go Back”)

2. Pick the Best Solution & Explain Why:

Choose the best option and explain why it’s better. Refer back to the violated principles.

  • Optimal Solution (from “Terminate Membership”):
    Headline: “Are you sure you want to delete your account?”
    Body: “All your data will be permanently removed. This action cannot be undone.”
    Buttons: “Delete Account” (primary, red) / “Keep Account” (secondary, neutral)

  • My Justification:

    • Clarity & Conciseness: Uses “delete account,” which is user-friendly and to the point. Removes “absolutely positive” and “with us.”
    • User-Centricity/Empathy: Focuses on my action as a user and the consequences (“your data will be removed”).
    • Actionable/Helpful: Clearly states that it’s irreversible and the consequence (data removal).
    • Tone & Voice: Neutral, clear, and takes the seriousness of the action into account without being alarming.
    • Accessibility: Clear contrast between “Delete” and “Keep” (which implicitly means “Cancel”). Making “Delete Account” red gives a visual cue for how serious it is. Allows us to quickly understand the choice.

3. Articulate the General Lesson:

What overall principle or best practice does this specific fix show? This is the core takeaway you’ll carry into your own work.

  • My Example (from “Terminate Membership”):
    • Generalized Lesson: When dealing with high-stakes actions, use clear, direct, and concise language that focuses on what the user intends and the consequences, avoiding jargon, overly formal terms, and alarming phrases. Always confirm irreversible actions using precise language that manages expectations without causing panic. Make sure button labels are explicit and mirror the headline’s intent, giving clear positive and negative choices.

Categories of Bad UX Writing: Common Culprits

While every bad example is unique, they often fall into pretty clear categories, making it easier for me to spot patterns and internalize solutions.

A. The Jargon Jungle: Technical Terms & Internal Speak

  • Problem: Using words only developers or internal teams would understand.
  • Examples: “Authentication failed,” “Cache cleared,” “Invalid payload,” “Error 0x80070005.”
  • My Fix: Translate, simplify, explain, or just leave out technical details. Focus on what happened to the user and what they can do.
    • Instead of: “Authentication failed.”
    • Try: “Incorrect password. Please try again.” / “Login failed. Check your username and password.”
    • Instead of: “Clear cache.”
    • Try: “Clear browsing data.” / “Delete temporary files.”

B. The Verbose Vortex: Wordiness & Redundancy

  • Problem: Using far too many words to say something simple, repeating information.
  • Examples: “Please be advised that your submission has been successfully processed and is currently awaiting review by our dedicated team of professionals.”
  • My Fix: Edit ruthlessly. Every single word needs to earn its spot. Combine sentences, get rid of adverbs, and banish passive voice.
    • Instead of: “Please be advised that your submission has been successfully processed and is currently awaiting review by our dedicated team of professionals.”
    • Try: “Submission received. We’ll review it soon.” / “Your submission is under review.”

C. The Ambiguity Abyss: Vagueness & Unclear Meaning

  • Problem: You don’t know what to do next or what something even means.
  • Examples: “Something went wrong,” “Action failed,” “Your request could not be fulfilled.”
  • My Fix: Be specific. Explain what went wrong, why, and what you should do. Give clear next steps.
    • Instead of: “Something went wrong.”
    • Try: “Payment failed. Please check your card details or try another payment method.” / “Upload failed. Your file type is not supported.”

D. The Robotic Relic: Impersonal & Dehumanizing Language

  • Problem: Writing that sounds like it came from a machine, lacks empathy or connection.
  • Examples: “User error detected,” “Do not close this window,” “Interaction required.”
  • My Fix: Use natural language, talk directly to the user (me!), and show empathy.
    • Instead of: “User error detected.”
    • Try: “Oops! Something went wrong on our end.” / “That didn’t work. Let’s try again.”
    • Instead of: “Interaction required.”
    • Try: “Please select an option.” / “What would you like to do?”

E. The Blame Game: Accusatory & Unhelpful Error Messages

  • Problem: Messages that blame us, make us feel dumb, or offer no solution.
  • Examples: “You entered an invalid format,” “Your query returned no results,” “You must complete all fields.”
  • My Fix: Frame errors constructively. Focus on the solution, not on my perceived mistake. Use system-first language for problems, not user-first. Highlight what can be done.
    • Instead of: “You entered an invalid format.”
    • Try: “Incorrect format. Please enter as MM/DD/YYYY.”
    • Instead of: “Your query returned no results.”
    • Try: “No results found for ‘X.’ Try a different search term or check for typos.”

F. The Sales Pitch Sneak Attack: Marketing Copy in UI Elements

  • Problem: Putting promotional language into functional parts of the user interface, confusing me or making me distrust the app.
  • Examples: Button text “Unlock amazing savings!” when it should just be “Apply Discount.”
  • My Fix: Separate marketing from functional copy. UI elements should be clear and straightforward. Marketing has its place, but not in critical action prompts.
    • Instead of: “Unlock amazing savings!”
    • Try: “Apply Discount” / “Redeem Coupon”

G. The Dark Pattern Deception: Manipulative Language

  • Problem: Using language to trick or nudge you into doing things you didn’t intend (like signing up for newsletters, keeping subscriptions).
  • Examples: “No thanks, I don’t like saving money” (the “no” choice for a discount). Confusing “opt-in” and “opt-out” checkboxes.
  • My Fix: Always prioritize transparency and our ability to make our own choices. Honesty builds trust. Use neutral, unambiguous language for choices.
    • Instead of: “No thanks, I don’t like saving money.”
    • Try: “No, thank you.” / “Continue without discount.”

Beyond the Words: The UX Writing Ecosystem

Often, bad UX writing isn’t just about the words themselves, but about how they fit into the bigger user experience.

1. Lack of Visual Harmony:

  • Problem: Text isn’t supported by the visual design (e.g., long text in a tiny box, unclickable text that looks like a button, or vice-versa).
  • My Lesson: UX writing lives alongside UI design. Words should complement, not fight, what you see. A great headline with a terrible visual layout will still fail.
  • My Actionable Step: Always think about the visual space for your words. Is it scannable? Is there enough empty space? Do headings clearly separate sections?

2. Ignoring User Journey & Context:

  • Problem: A message appears at the wrong time or in the wrong place, even if the copy itself is “good.”
  • For Example: A “Welcome Aboard!” message pops up after you’ve been using the product for a month because of a bug.
  • My Lesson: UX writing has to be super aware of exactly where the user is in their journey. Context is everything.
  • My Actionable Step: Map out user flows. Understand what users just did and are about to do. Anticipate their state of mind (are they frustrated, curious, focused?).

3. Inconsistent Brand Voice:

  • Problem: The voice changes drastically from one part of the product to another, confusing what the brand is all about.
  • For Example: A quirky, fun onboarding process is followed by extremely formal, cold error messages.
  • My Lesson: A strong brand voice provides consistency and predictability, building trust. It’s a fundamental part of the entire user experience.
  • My Actionable Step: Develop a brand voice guide. Make sure all writers stick to it. When I analyze bad examples, I ask myself if the voice fits the product’s overall identity.

Developing Your “Good Eye” for Bad Writing

To consistently learn from negative examples, you need to cultivate a special mindset and approach.

  • Be a Digital Anthropologist: Watch how people react to flawed interfaces. See their frustration. Note common complaints.
  • Collect & Categorize: Create a personal “Swear Jar” or “Hall of Shame” for bad UX writing examples. Take screenshots. Categorize them by the principles they violate (Jargon, Verbose, Ambiguous, etc.).
  • Critique with Empathy: Approach critique not with ridicule, but with a genuine desire to understand why it failed and how it could be better for the user.
  • Reverse-Engineer Relentlessly: For every bad example, don’t just point out the problem; actively build the solution. This is how you develop the muscle memory for good UX writing.
  • Share and Discuss: Talk about bad examples with other UX writers. Hearing different perspectives on the same problem can open up new insights and strengthen your analytical skills.
  • Read Critically, Write Consciously: Apply the lessons you learn from bad examples to your own work. When you write, continuously ask yourself: “Is this clear? Is it concise? Is it empathetic? Does it guide the user?”

Conclusion

The path to amazing UX writing isn’t just paved with fantastic examples; it’s also deeply shaped by the lessons we learn from mistakes and failures. By systematically taking apart bad UX writing, identifying its core issues, understanding what caused them, and actively transforming it into optimal solutions, you don’t just avoid making mistakes – you build an unshakeable foundation of understanding, empathy, and strategic communication. Every annoying pop-up, every confusing error message, and every overly wordy button becomes a stepping stone towards mastery. This active engagement with imperfection is where true UX writing excellence is forged. The worst writing can often be your greatest teacher, as long as you approach it with curiosity, a critical eye, and a commitment to always getting better.