Why AI Loves Clichés (and How to Debug It)
On Monday we poked fun at the phrase “isn’t just ___, it’s ___” — today let’s get technical. Why do generative AI systems churn out the same tired patterns over and over? The short answer: math. AI models are probability machines. They predict the next word based on patterns in their training data. If a phrase shows up thousands of times in marketing, blogs, and leadership posts, the model learns that it’s a safe bet.
The Math Behind the Cliché
Think of language generation as a recipe where each ingredient is chosen by probability:
- Step 1: The model looks at your prompt (“write a professional blog post”).
- Step 2: It calculates likely next words based on training data.
- Step 3: High-frequency patterns (like “isn’t just ___, it’s ___”) rise to the top.
- Step 4: Without intervention, the model serves you the statistical equivalent of instant noodles: reliable, but bland.
A Cooking Analogy
Imagine a buffet line. Everyone before you chose mashed potatoes. By the time you get there, the serving spoon has a groove. Even if you wanted carrots, the spoon “knows” potatoes are the default. AI works the same way — the more often a phrase is chosen, the deeper the groove, and the more likely it gets served again.
How to Debug the Output
Fortunately, you can nudge AI away from clichés the same way you’d tweak a recipe:
- Adjust the temperature: In AI terms, this means increasing “temperature” or “top-p” sampling to encourage more adventurous word choices.
- Use constraints: Tell the model “avoid clichés” or “ban the phrase isn’t just ___, it’s ___.” Like leaving the salt shaker off the table, it prevents over-seasoning.
- Prompt creatively: Instead of “write a blog post,” try “write as if you’re explaining this to a chef who hates buzzwords.” That framing forces new patterns.
Code Meets Kitchen
Let’s zoom in on how the math drives clichés. AI models don’t “decide” like humans do — they assign probabilities to possible next words. Here’s a toy example in Python-like pseudocode:
# After generating the words: "This soup"
probabilities = {
"isn't": 0.42,
"is": 0.12,
"tastes": 0.08,
"smells": 0.07,
"looks": 0.05,
"feels": 0.03,
"comforting": 0.01
}
# The model picks the word with the highest probability (greedy choice)
next_word = max(probabilities, key=probabilities.get)
print(next_word) # "isn't"
The result? You’re halfway into the “isn’t just ___, it’s ___” pattern before you even notice. The algorithm didn’t try to be clever — it simply grabbed the statistically safest option.
A Real Example with Hugging Face
If you want to see this in action, the Hugging Face Transformers library makes it possible to experiment directly in Python. With just a few lines of code, you can test how different settings change the flavor of text:
from transformers import pipeline
# Load a text generation model
generator = pipeline("text-generation", model="gpt2")
# Prompt with a safe temperature (bland, cliché-prone)
safe_output = generator("This soup", max_length=15, temperature=0.7)
print("Safe:", safe_output[0]["generated_text"])
# Prompt with a higher temperature (more creative)
creative_output = generator("This soup", max_length=15, temperature=1.3)
print("Creative:", creative_output[0]["generated_text"])
At temperature=0.7, you might get something familiar like:
“This soup isn’t just hot, it’s comforting…”
At temperature=1.3, the output becomes more adventurous:
“This soup hums like jazz on a rainy night…”
That’s the difference between clichés and creativity — it’s just math, with a dash of seasoning.
Takeaway
AI falls into clichés because they’re safe, frequent, and statistically reinforced. But with careful prompting and parameter tuning, we can push past instant noodles and serve meals worth savoring. Tools like Hugging Face let you turn the knobs yourself, which means you don’t have to settle for bland potatoes at the buffet. Tuesday’s lesson: don’t just accept the line — grab the tongs and choose your own flavor.
Comments