The Better Error: How Small Words Can Make Frustrating Experiences Feel Better
Errors are inevitable.
A button gets clicked too soon. A server goes down. A payment fails. A password doesn’t match. A file is too large.
We can’t always prevent users from encountering errors, but we can control what happens next.
That’s where microcopy comes in.
A few carefully chosen words can turn an error from a dead end into a helpful next step. And with AI, rewriting those few words has become faster, easier, and surprisingly insightful.
Welcome to The Better Error: a simple exercise in taking a real error state, rewriting its microcopy with AI, and discovering how small changes can make a frustrating experience clearer, kinder, and more on-brand.
The error message nobody wants to read
Let’s start with a familiar one.
Imagine you’re uploading an important document and suddenly see:
Error. Upload failed. Please try again.
Technically, this message communicates something.
The upload failed.
But as a user, you’re left with questions:
Why did it fail?
Is my internet connection the problem?
Is the file too large?
Did I upload the wrong format?
Should I try again immediately?
Will I lose the file if I leave this page?
The message tells us what happened, but not what to do about it.
And that distinction matters.
A good error message shouldn't simply announce failure. It should help the user recover from it.
Step one: Give the error a little more empathy
Let’s ask AI to rewrite the message.
Instead of simply saying:
Error. Upload failed. Please try again.
We could get:
We couldn’t upload your file. Please check your connection and try again.
Already, it feels different.
“We couldn’t” sounds less accusatory than “Upload failed.”
More importantly, the message starts behaving like an assistant rather than a warning sign.
But we can go further.
Step two: Make the problem specific
Vague errors create more work for users.
Consider:
Something went wrong.
It’s short. It’s common. And it’s almost completely useless.
Now imagine the same situation with a little context:
This file is too large to upload. Please choose a file under 25 MB.
Suddenly, the user knows:
What happened: The file is too large.Why: There is a 25 MB limit.What to do: Choose a smaller file.
That’s the basic formula behind useful error microcopy:
What happened + Why it happened + What to do next
You don't always need all three, but whenever possible, give users a path forward.
Step three: Let your brand personality show up
Error messages don't exist outside your brand.
If your product is playful, the error can have a little personality.
For example:
Oops. That file is having a big day. It’s over our 25 MB limit. Try a smaller one.
If the product is professional:
Upload unsuccessful. Your file exceeds the 25 MB limit. Please select a smaller file.
If the product is warm and conversational:
Looks like this file is a little too large. Choose one under 25 MB and you’ll be good to go.
All three communicate essentially the same information.
But they don't feel the same.
That's the power of microcopy.
The words surrounding a problem can reinforce how users perceive the entire product.
Step four: Use AI as a writing partner, not a replacement for judgment
This is where the experiment gets interesting.
AI can generate dozens of alternatives in seconds. But the best result usually isn't the first one it gives you.
Instead, give it constraints.
Try a prompt like:
Rewrite this error message for a mobile app. Keep it under 12 words. Make it clear, empathetic, actionable, and conversational. Avoid technical jargon and blame. Give me five variations.
Suddenly, you're not just asking AI to “make this better.”
You're defining what better means.
You can then experiment with different directions:
Clear
We couldn’t upload your file. Try again.
Helpful
Upload failed. Check your connection and try again.
Friendly
Oops! Your upload didn’t go through. Give it another try.
On-brand
Almost there. We couldn’t upload your file—try again in a moment.
Action-focused
Upload failed. Check your connection, then try again.
AI gives you the range.
You provide the judgment.
The smallest words can change the experience
There’s an interesting lesson hiding inside these rewrites.
Sometimes the improvement isn't dramatic.
It's a single word.
Compare:
You entered an invalid password.
with:
That password doesn’t match.
Or:
Invalid email address.
with:
Check your email address and try again.
Or:
Payment declined.
with:
Your payment didn’t go through. Try another payment method.
The second versions don't necessarily contain much more information.
They simply sound less like a system talking at you and more like a product helping you.
That distinction can make a surprisingly large difference.
Don't blame the user
One of the easiest ways to make an error message worse is to make the user feel responsible for the problem.
Compare:
You entered the wrong information.
with:
We couldn't verify those details. Please check them and try again.
The first places the focus on the user's mistake.
The second focuses on the system's inability to complete the task.
This doesn't mean every error needs to apologize.
In fact, excessive apologies can become irritating:
We're so sorry! Unfortunately, we're terribly sorry, but something went wrong.
What users usually need isn't an apology.
They need clarity.
Tell them what happened. Tell them what they can do next. Then get out of their way.
A useful error is a tiny piece of UX
Error messages are easy to treat as an afterthought.
The happy path gets the polished interface. The error state gets:
Something went wrong.
But users often remember frustrating moments more than successful ones.
An error is a moment when the product has broken the user's expected flow.
That means the words surrounding that moment matter even more.
Good error microcopy can:
Reduce confusion
Prevent repeated mistakes
Build trust
Reduce support requests
Keep users moving
Reinforce brand personality
In other words, an error message isn't just text.
It's part of the product experience.
The Better Error challenge
Want to try the exercise yourself?
Find one real error message in a product you use.
Don't choose an obviously terrible one. Choose an ordinary one.
Then ask:
1. What does it currently say?
Write down the exact message.
2. What does the user actually need to know?
Is the problem clear?
3. Can the user recover?
Does the message explain what to do next?
4. Does it sound like your brand?
Would the message feel natural anywhere else in your product?
5. Ask AI for alternatives
Give AI the original message and define your constraints:
Tone
Word count
Audience
Platform
Brand personality
Required action
Words to avoid
Then compare the results.
Don't automatically choose the cleverest version.
Choose the one that helps the user most.
Before and after
Here's our original error one last time:
Before:
Error. Upload failed. Please try again.
After:
We couldn’t upload your file. Check your connection and try again.
It's not revolutionary.
And that's exactly the point.
Good UX writing doesn't always require big changes.
Sometimes better experiences are built from tiny decisions:
“We couldn't” instead of “Error.”
“Try again” instead of “Please retry.”
“Check your connection” instead of “Something went wrong.”
A few words can reduce friction, remove blame, and give someone a clear next step.
The better error is the one that helps
Errors are going to happen.
The question isn't whether users will encounter them.
The question is what your product says when they do.
AI can help us generate better options faster. But the real skill is knowing what makes an error message useful: clarity over cleverness, guidance over blame, and personality without getting in the way.
So the next time you see an error message that feels cold, confusing, or unnecessarily technical, stop and rewrite it.
Change a few words.
Make the problem clearer.
Give the user a way forward.
Because sometimes, the difference between a frustrating error and a helpful one is only a sentence.
Comments