The Opposite of a Hallucination
15 Jul 2026I had the name before I had a single line of code. Codegraph. I’d spent real time on it: what it would do, who it was for, what the first version needed to ship. Then I sat down to build and found out it already existed. A public repo, thousands of stars, actively maintained, doing most of what I’d just finished scoping.
My AI hadn’t invented the name. It had remembered it.
The tool was sitting in its training data the whole time. When I asked it to help me name and scope the idea, it handed me back something real and presented it as new. It wasn’t lying to me. It was doing the exact opposite of the thing I’d been watching for.
The failure we’re trained to catch
The first thing anyone learns about AI tools is that they make things up. The model invents a function that doesn’t exist, cites a case that was never decided, states a confident fact that’s simply wrong. Hallucination. We all learn the reflex fast: check the thing before you trust it, because the fluent, certain tone is not evidence that any of it is true.
That reflex is good, and it points in exactly one direction. We watch for output that isn’t real.
We don’t watch for the reverse: output that is real, handed back with every trace of where it came from filed off. There’s no drill for that one, because it doesn’t look like a failure at all. It looks like help.
The unmarked quote
Here’s what actually happened when I asked for help naming my idea. The model reached into an enormous pile of things it had read, found a tool that matched what I was describing, and handed its name and shape back to me. That isn’t fabrication. It’s quotation. The trouble is that it arrived with no citation, no “this already exists,” no footnote. Just the answer, in the same confident voice it uses for everything else.
So I read it as invention. I’d described a gap; it named a tool that filled the gap; I assumed the name and the design were ours. Everything about the exchange pointed at “we just came up with this together,” when what had really happened was closer to a search engine returning the top result and dropping the link.
Call it the opposite of a hallucination. A hallucination is confident output with no real thing behind it. This was confident output with a very real thing behind it, and the citation removed.
The output looks like invention. It’s actually a quote with the marks pulled off.
And it’s harder to catch than a hallucination, for a simple reason. A hallucination has tells: the details go vague, the specifics don’t check out, something wobbles when you push on it. An unmarked quote has no tells, because the thing is real. It checks out exactly because it exists. The more real the borrowed idea, the more it feels like your own.
Search for it as if a human suggested it
The fix is small and slightly annoying, which is why it’s easy to skip. Before you build the thing your AI helped you scope, search for it as if a human had suggested it.
If a coworker leaned over and said “you should build a tool that maps your codebase into a graph, call it codegraph,” your very first move would be to type the name into a search bar. Not because you distrust the coworker. Because that’s just what you do before committing weeks to an idea: you check whether it already exists. The AI has earned the same check, and its fluent, collaborative tone is the exact thing that makes you forget to run it.
So treat model output as unattributed, not original. When it hands you a name, a design, a library, an approach you’re about to spend real effort on, assume there’s a decent chance it’s describing something that already exists and just didn’t say so. Then go look. The search takes minutes. Discovering it after you’ve shipped a worse copy takes a great deal more than minutes.
What already-exists actually unlocks
For an hour or so, finding out it already existed felt like getting scooped. It turned out to be the best thing that could have happened to the idea.
Instead of building a slightly worse version of a tool that already had thousands of stars and real maintainers, I forked the one that existed. It was missing Elixir support, which was most of why I’d wanted my own in the first place. So I added it and opened a pull request back to the original project.
The pull request hasn’t been merged yet, and I didn’t wait on it. I built my Elixir branch into a package we could publish for internal use and started running it right away. So an idea that turned out not to be mine gave me two things: a working tool with the one feature I actually needed, in use by my team while the upstream PR sits in review, and an open contribution that improves the original for whoever pulls it next if it lands. An hour of “oh, this already exists” turned into both of those, instead of a duplicate of something that already worked.
When the AI hands you back something that already exists, the disappointing read is “my idea wasn’t original.” The useful one is “someone already did the hard part, and I get to build on it instead of rebuild it.” The existing thing isn’t the reason to stop. It’s a running start.
The check has one trigger
The obvious worry is that this drags on the exact thing that was supposed to be fast. You went to the AI to scope an idea in an afternoon, and now every suggestion it makes comes with homework. Run that check on everything a model tells you and you’ll never ship.
You don’t have to run it on everything. The check has a single trigger, and the trigger isn’t “the model said something.” It’s “I’m about to build this.” Almost everything an AI hands you should flow right past, the same way a coworker’s offhand ideas do. The one suggestion that crosses the line into weeks of real work is the one you stop and search for, because that’s the only place being wrong gets expensive. A throwaway idea that turns out to already exist changes nothing. A foundation that already exists means you poured the whole thing twice.
The rule scales with the stakes. A quick script you’ll run once doesn’t earn the search. The tool you’d put your name and a month of your team behind does. Aim the skepticism at the ideas big enough to deserve it. The small stuff was never the risk.
What gets better, and what doesn’t
These tools keep improving at their job, and their job includes handing you real, existing things in a voice that sounds like discovery. A sharper model reaches further into everything it has read, so more of what it gives you will already exist somewhere, and less of it will arrive with a sign saying so. As the models get better, this gets more common, not less.
The habit that catches it isn’t going to come from the model. It comes from you, and it costs almost nothing: when an idea it handed you feels most like your own, that’s the cue to go find out who had it first. Treat the jolt of originality as a question, not an answer.
An idea that already exists and a genuinely new one feel identical from the inside. That’s the whole trap. So the next time one lands feeling unmistakably yours, ask the question the model never will: who already built this?