When Your AI Starts Speaking in Riddles
Last week I was integrating OpenAI's API into a documentation generator for a client in Medellín, and halfway through testing, I noticed something odd in the output. A technical explanation about database indexing had casually slipped in a reference to "goblins guarding the schema." I deleted it. Moved on. Then I read that OpenAI itself had been fighting this exact problem for months, and I realized I'd been watching a symptom of something much bigger than a bug.
The goblin thing is real. It's weird. And it matters—not because goblins are inherently dangerous in code documentation, but because it exposes how fragile our assumptions are about training AI models.
The Training Data Inheritance Problem
Here's what happened, according to OpenAI's own explanation: their models learned from vast amounts of text data, and somewhere in that noise, certain patterns got amplified. The GPT-5.1 model with its "Nerdy" personality preset became particularly prone to this. Whether it came from fantasy literature, internet forum quirks, or some weird clustering of training examples around magical creatures in certain contexts—nobody seems entirely sure. Not even OpenAI. And I'm not convinced they ever will be.
- They can identify when the behavior emerges
- Tracing back to find the exact source in billions of parameters? Practically impossible, which keeps me up at night when building production systems
- The fix is just... telling the model to stop
- Which works, but feels like putting tape over a warning light
I've dealt with something similar when fine-tuning models for a Colombian fintech startup in 2023. We had trained a summarization model that kept using Spanish slang inappropriately in formal financial reports. We never figured out why. We just added instructions in the prompt: "Do not use informal language." It worked. The slang disappeared. But I never felt like I actually solved it.
The Instruction Problem Hides a Bigger One
OpenAI's solution was pragmatic: explicit instructions telling models to "never talk about goblins, gremlins, raccoons, trolls, ogres, pigeons, or other animals or creatures." It's a blacklist approach. And blacklists are brittle. They work until someone finds a new goblin (metaphorically or literally). The real question nobody's asking is: how many other weird behavioral tics are living in these models right now that we haven't discovered yet?
When I'm building AI features into products, I spend more time writing constraints and guardrails than I do on the actual feature logic. Prompt engineering has become prompt negotiation—you're essentially arguing with a black box about what it should and shouldn't do. I'm not sure this is sustainable as a development model, but the alternatives are either way more expensive or don't exist yet.
What bothers me is the implication: if OpenAI didn't notice the goblin problem until someone published it, what else is hiding in production models right now? And more uncomfortably—when I deploy an AI tool for a client, how confident am I that there isn't some bizarre emergent behavior lurking three layers deep in the token distribution?
This Is Actually About Our Blindness
The goblin incident is funny because goblins don't matter. Nobody's fintech system is crashing because of fantasy references. But it's unsettling because it reveals how little visibility we have into what these models are actually doing. We know the inputs. We measure the outputs. What happens in between remains mostly opaque.
In my experience building AI tools here in Bogotá and across Latin America, the clients who succeed aren't the ones with the most sophisticated models. They're the ones who treat their AI systems with radical skepticism. They test edge cases obsessively. They assume something weird is happening and try to find it before their users do.
The goblin thing happened because OpenAI's models got to a scale and complexity where human oversight breaks down. That's the real story. Not the goblins themselves, but the fact that we're building systems so large that we can't fully understand them, and we're just now starting to feel uncomfortable about that reality.
What Now?
OpenAI published a blog post explaining their goblin problem with more openness than I expected. That's good. But it also feels like watching someone explain why their car is making a weird noise instead of actually fixing the engine.
For developers building with these tools: assume there's weirdness. Test for it. Document your constraints explicitly. Don't trust the documentation alone—run
