Everyone Is an Expert Somewhere: What Your Friends Know About LLMs That You Don't

There's a conversation I keep having. A developer friend shows me a Claude output. "Look at this," he says, pointing at a function that compiles but does something subtly wrong. A race condition the model didn't consider. A data structure that will buckle at scale. "It sounds so confident, but this would break in production." A psychologist friend tells me about a ChatGPT therapy session someone shared with her. The language was warm. The phrasing was textbook. "It reads like a therapy session," she said, "but it can't actually model the person's internal state. It's pattern-matching on therapeutic language without doing therapy." And me. I'm a writer. I'm also INTP, which means I've spent most of my life dissecting how people communicate: what lands, what doesn't, and why. When I read LLM-generated prose, I can feel exactly where the punch should land and doesn't. The sentences are grammatical. The structure is reasonable. But there's a flatness to it. A tendency to reach for the safe generalization instead of the one specific detail that would make you stop reading and start thinking. Three people. Three domains. Three different sets of cracks in the same technology.

The Eloquence Trap

Here's the problem: LLMs are extraordinarily good at sounding right. They produce fluent, well-structured, grammatically correct output. The surface quality is so high that it creates a kind of trust transfer. Because the language sounds authoritative, we assume the content is authoritative too. This is the eloquence trap. It works precisely because most of us are not experts in most things. A developer asks ChatGPT for therapy advice. They get something that sounds like therapy. They don't have the clinical training to notice that the model is reflecting their language back at them rather than probing beneath it. The "validation" they're receiving is a linguistic pattern, not a therapeutic judgment. A psychologist asks Claude for code. They get something that compiles and runs. They don't have the engineering context to notice the missing edge case, the unhandled null, or the O(n²) hiding inside a loop that looks clean. Either of them asks an LLM to write a blog post. They get paragraphs that flow and transitions that connect. They can't feel the moment where a human writer would have cut the abstraction and dropped in the one concrete detail that makes an argument land.

Everyone can see the failures in their own domain. Nobody can see them in someone else's.

The Dunning-Kruger of AI Trust

There's a psychological frame for this. In the classic Dunning-Kruger formulation, people with low competence in a domain overestimate their ability. With LLMs, the dynamic rotates: people with low competence in a domain overestimate the model's ability in that domain. They can't see the mistakes because they don't have the expertise to recognize them. I notice this in myself. I used vibe coding to build a habit tracker and a singing app. The code runs. The apps work. But I know, with the quiet certainty of someone who's read enough about software architecture to recognize what he doesn't know, that there are structural choices in that code I can't evaluate. The gap exists. I just can't see all of it. The model never flags its own uncertainty in a way that's calibrated to the actual risk. It doesn't say "I'm less confident about this clinical recommendation than I am about this Python function." It presents everything with the same polished surface.

What This Means in Practice

This isn't abstract. Self-diagnosing with LLMs. People are using ChatGPT as a therapist, a medical advisor, a legal counsel. The warm, empathetic tone of a therapy response feels genuinely helpful. Until a trained clinician sees advice that's superficially correct but misses the actual therapeutic intervention. The model validates a coping mechanism that a therapist would gently challenge. It reflects anxiety back as understanding when what the person needs is reframing. (I know this pattern from the inside. As someone who's spent years studying enneagram and personality frameworks, I can tell you: the model gives you a Type 2's response every time. Warm, affirming, conflict-averse. Sometimes what you need is a Type 8's response: "You're wrong, and here's why that matters.") Content that passes the "looks right" test. Businesses use LLM-generated content for marketing, documentation, and thought leadership. To someone who doesn't write professionally, the output looks polished. To a writer, it reads like something assembled rather than written. Technically correct, structurally sound, but missing the willingness to commit to a specific point of view. The thing that distinguishes writing from text generation is conviction. LLMs have none.

The Compound Problem

Each individual domain gap is manageable. The compound problem is that we operate across many domains every day, and LLMs now assist us in all of them. In a single afternoon, you might ask an LLM to debug your code, draft an email to a difficult colleague, explain a medical test result, and help you write a cover letter. In each case, you're operating with a different level of expertise. In one of those domains, you'd catch the model's mistakes immediately. In the others, you're flying blind.

The failure mode isn't that LLMs are useless. It's that their failures are invisible to the person most likely to be affected by them: the non-expert who turned to the model precisely because they lacked the expertise to do the task themselves.

What Each Domain Expert Sees

Developers complain about the same three things. The model picks the obvious solution, not the right one. It doesn't understand system context; it optimizes locally and ignores global constraints. And it's confidently wrong about concurrency. Anything involving shared state tends to get a superficially correct answer that would fail under load. Clinicians notice something subtler. The model mirrors instead of probes. Good therapy involves reflecting and challenging; the model only does the former. It applies CBT principles the way a textbook describes them, not the way a clinician adapts them. And it can't sit with discomfort. A skilled therapist knows when to let silence do the work. The model always fills the space. Writers (this is my territory) see three tells:

It reaches for the abstraction too early. Good writing earns its generalizations through specific detail. LLM prose jumps to the takeaway without building the foundation.
It hedges where it should commit. "It's worth noting that" and "this raises interesting questions about" are language that gestures at ideas without arguing them.
It doesn't know when to stop. Every point gets a paragraph. Every paragraph gets a transition. The relentless completeness is itself the tell.

I placed second in the International Speech Contest at Toastmasters. What I learned there wasn't how to write sentences. It was how to cut them. The best speeches are the ones where you can feel the absence of everything the speaker chose not to say. LLMs have no sense of absence. They fill every gap because they can't distinguish between "this space is empty" and "this space is doing work."

What To Do With This

Not panic. Not abandon the tools. I use Claude daily; it makes me measurably more productive. The point isn't that these tools are dangerous. The point is that they require epistemic humility that the tools themselves don't encourage. When you use an LLM in a domain where you're an expert, you have a built-in error-correction mechanism: your own judgment. When you use it in a domain where you're not, that mechanism is gone. You're trusting the surface. And the surface is very, very good. The minimum responsible practice:

Know where your expertise ends. If you can't evaluate the output, you can't trust it.
Treat unfamiliar-domain output as a draft, not an answer. Verify with someone who knows.
Be cautious with high-stakes domains. Health, law, therapy, finance. The eloquence trap is most dangerous where being wrong carries real consequences.
Talk to people in other fields. Every conversation I've had with a developer, a psychologist, or a domain expert about LLM output has recalibrated my sense of where these models actually are.

The Pattern

My developer friends can see code mistakes I can't. My psychologist friends can see clinical mistakes I can't. I can see writing mistakes they can't. None of us can see all the mistakes. But all of us, talking to each other, can see the pattern:

LLMs fail everywhere, with equal confidence, and each of us can only see the failures in our own domain.

That's not an argument against using them. It's an argument against trusting them in the dark. The eloquence is real. The understanding isn't always. The distance between those two things is where the actual risk lives.