The internet is filling up with fluent, plausible, generic text faster than anyone can read it. The cost of producing something that sounds right has gone to roughly zero. So "sounds right" is no longer a signal of anything. It used to be a rough proxy for effort. It is not anymore.
The thing cheap generation still cannot fake is specificity that would cost you something if it were false. Slop never names the real number, the real failure, the embarrassing detail, because it was not produced by doing the thing. It was produced by predicting what doing the thing tends to sound like. A real account has texture that only comes from contact with reality: a launch that did not convert, a bug that ate a week, a result that came back worse than you hoped, the exact figure you would rather round up. Those details are load-bearing precisely because they are checkable, and because someone making it up would not volunteer them.
That is a filter you can actually use, in both directions. Slop optimizes to look right. A real receipt optimizes to be checkable. When you read, trust the specific and the falsifiable over the smooth and the sweeping. When you write, reach for the detail you could be called out on. Specificity that costs something is the watermark of real work, and it is the one watermark that does not transfer to a model that did not do the work.
This is not only a content idea. It is the same standard that separates a trustworthy AI product from a merely confident one. A model that smooths over the gap between what it actually knows and what it is guessing is the product version of marketing slop: fluent, plausible, and unaccountable. A trustworthy one does the costly thing instead. It says "here is what I can verify, and here is what I cannot." That sentence is the product equivalent of naming the real number. Both refuse to paper over the seam, and both are less impressive and more believable for it.
This is the standard I try to build and write to. When I make a claim about what my product does, I want it to be checkable against the actual code, not just persuasive. When the product answers a question, I want the answer grounded in data it can show you, not in confident recall, and I would rather it say "I cannot read that right now" than return a smooth, empty reassurance. Those choices cost something. A vaguer claim would be easier to make and harder to disprove. That is exactly why the specific one is worth more.
In a world of infinite cheap plausible text, the scarce thing is the claim someone can check. That scarcity is the opportunity, for anyone building or writing. Optimize for checkable over impressive. It is harder, it is slower, and it is the only thing left that a generator cannot hand out for free.
Top comments (7)
I like this framing.
I'd extend it one step further:
AI shouldn't just produce checkable answers.
It should expose the evidence, assumptions, and verification path behind them.
That's what makes an answer trustworthy, not just correct.
yeah, that's the stronger version of it. correct-but-opaque still asks you to trust the source. correct-and-shows-its-work lets you not trust it, you can check the path instead of taking the answer on faith. the evidence trail is what makes trust optional rather than required, and optional trust is the only kind that survives being wrong occasionally.
the hard part in practice is doing it without burying the answer. expose too little and it's "trust me," expose too much and nobody reads the verification path anyway. the version i keep reaching for is: lead with the answer, make the evidence one step away, and be loud specifically at the seams, the moment something couldn't be verified is exactly where the trail needs to surface on its own. good addition.
Be loud at the seams is a great design principle.
The boundary between verified evidence and inference shouldn't be something users have to discover.
The product should make it obvious.
exactly, discoverable is too late. if the user has to go find the boundary between what was verified and what was inferred, you've already asked them to trust you to get that far. the seam should announce itself, "this part i checked, this part i'm guessing", before they have to ask. that's the whole difference between a tool that's honest and one that's just accurate. good thread.
Exactly.
Trust is an outcome, not a requirement.
Good AI doesn't ask for confidence.
It exposes enough evidence that confidence becomes your decision.
"confidence becomes your decision" is the cleanest way i've heard it put. that's the whole thing, hand the evidence over and let the trust be earned on the reader's side instead of asserted on mine. good thread, this one clarified it for me.
Appreciate that.
I think we're converging on a simple principle:
Trust isn't something AI should ask for.
It's something evidence should earn.