People have started telling me that my writing sounds like AI. I published that sentence in a LinkedIn post recently because it kept being true, and the fuller version is this: hours of verified work, read for about ten seconds, filed under slop, with nothing in it checked. It stung, and I wrote the sting down as data, which at least settled the question of whether I still have feelings.
Here is what makes my version of this complaint unusual. The accusation is half true. I use AI constantly and on the record; my article history includes one titled "I gave an AI agent nightly merge rights to every repo I own". The ghostwriter in my basement is fully documented: I built the basement, wired it, and published the wiring diagram. So I cannot stand up and claim the prose is all hand-typed. What I can say is that the dismissal gets the important thing wrong, and I can show my work.
"Sounds like AI" is a style judgment
Watch what actually happens when a piece gets written off as slop. The reader judges the rhythm, the polish, the word choice, the suspicious tidiness of the paragraphs. In the cases I have been able to watch from the receiving end, nobody clicked a link, ran a query, or asked whether the system described in the piece exists. The verdict is rendered entirely on the surface, which means it is a judgment about prose style wearing the costume of a judgment about substance.
The word "slop" still means something real, and it is worth being precise about it. Slop is volume without verification: content generated at scale and shipped unread, describing systems that do not exist and citing numbers nobody measured, with nobody attached who will answer for any of it. The tell of slop was never the prose style. The tell is that nothing in it can be checked. Slop has no receipts.
Style, meanwhile, is unreliable evidence in both directions, and I am living proof of the embarrassing direction.
I sounded like AI before AI did
I spent twenty-five years in enterprise infrastructure, and the last stretch of it writing for boardrooms. Executive prose has one job: wrap the KPIs in enough narrative polish that the room stays awake, and never, ever sound unqualified while doing it. I wrote in that register for years and read it for decades, and the models trained on decades of corporate prose from people like me. When I built de-AI guardrails for my own publishing pipeline, rules designed to catch machine phrasing before it ships under my name, they started flagging my unassisted sentences. I have been told my whole life that I am a bit of a Spock. The detector I built to catch the machine caught me instead.
So when a reader says my work sounds like AI, they are partly detecting a real convergence, though they misread which one. Polished, structured, emotionally flat prose is what both boardrooms and language models optimize for, because both are trying to survive an inattentive, judgmental audience. If style is your only instrument, you cannot tell a machine from a career executive, and you certainly cannot tell either from the thing that actually matters, which is whether the work is true.
The receipts
Since style proves nothing, I stopped arguing style and built the other kind of evidence. Everything below is checkable, though not all of it by you. The URLs you can click right now. The rest lives one ask away from anyone I actually answer to, and the difference between private-but-auditable and nowhere is the entire difference between work and slop.
I keep an append-only board of finished things, with a strict counting rule. An item earns a row only when it is published, sent, paid, deployed, or physically placed; the row is denied to plans, to drafts, and to anything "basically done." Over one recent three-week window the board came back with fifty-seven rows. The rule exists because a scoreboard that counts intentions is how slop bookkeeping starts.
Live URLs sit under my byline. Six articles were live on this account when I measured on August 19, and you are reading the eighth. Two of the six are postmortems of my own failures: my auto-publish pipeline once shipped a two-year-old news story, and I once saw a broken email in the preview, blamed my phone, and approved the send anyway. Slop does not publish its own outage reports, because slop has no outages to own.
The money is measured. I keep a revenue ledger where a dollar appears only after it clears a rail, with an attribution tag. The first Stripe payout my company ever received was $63.03, and I publish the number at that precision on purpose. The ledger even carries an excluded row for the $7 test purchase I made myself, so the rail-proving transaction can never be mistaken for revenue.
The systems answer for themselves. The site that produced that payout sits behind an end-to-end Playwright suite, fourteen for fourteen on desktop and iPhone WebKit at the last CI run. And one of my brands has three QR panels physically placed in a local business: the code was decode-verified from the print-resolution render before anything went to the printer, and all three targets were re-verified live on placement day. A screenshot of a dashboard can be slop; a panel on a wall that resolves to a live page is harder to fake. You cannot check that one, and I am not going to tell you where it is, because the brand is anonymous by design. The people who walk past it can.
Small numbers get stated exactly. As of August 19, measured by API, this account had 44 followers and 332 article views. I would enjoy reporting bigger numbers; these are the measured ones.
There is one more layer, and it is the strange new one. My drafting tool now watermarks its output invisibly, a regulatory requirement in Europe since August 2026, and a detection API has been announced but, as I write this, has not shipped. When it does, a detector pointed at this article will presumably say yes, a model processed this text. It will be correct: this article was drafted with that tool, and the claims and numbers in it were verified by me, against the same private log I am about to tell you to keep. No detector can measure contribution — whether the systems are real, whether the money cleared, whether a human answers for the words. Provenance tools prove processing. Receipts prove work.
Steal this
If your work is getting the ten-second slop verdict, sanding your prose into studied imperfection treats the symptom. The fix is to become checkable.
- Keep an append-only file of finished things, where finished means the work reached someone who is not you.
- Attach one verifiable artifact to every public claim: a live URL, a commit, a payout figure, a photo of the thing on the wall.
- Publish your failures with dates and fixes. A postmortem under your own name is the single strongest anti-slop signal I know of.
- State small numbers exactly. Precision is credibility that compounds.
- Keep a private log of what you did versus what the machine did, so that if anyone ever asks what was yours, you answer from a record instead of a memory.
The honest coda
The receipts will not save you in a comment section. The reader who wrote the work off on rhythm is not going to audit a wins board, and I have stopped expecting them to. The receipts are for the people who check: an editor deciding whether to pay for a pitch, a client deciding whether the case study is real, and me, at the end of a week that felt like nothing shipped, reading a board that refuses to flatter me in either direction.
The style-only verdict deserves one last look, because it fails in both directions with the same confidence: it discards real work and it swallows fake work, and neither mistake announces itself. The only defense either way is to check something, and I would rather be the writer who makes that easy than the one who makes it unnecessary-sounding.
Of the fifty-seven finished things, the one that took the longest was learning not to argue about style. The board only logs finished work; feelings are mine to log, and the honest entry is that being called a machine still stings a little, every time, which proves nothing either, and happens to be true.
Top comments (6)
The irony is that this article is very much the kind of highly structured, polished, carefully argued post that some people would immediately call AI slop 😂—while the post itself is explaining why that judgment is unreliable. 🤣
You can make your work verifiable, disclose your process, and stand behind it. After that, whether someone chooses to inspect it is their cup of tea. 🤸
The receipts point is exactly the thing I've been trying to articulate to people who've flagged my own posts as AI-generated - I've written about systems that are running, and the code is public, but the first response is still a style judgment. The sad part is that prose that reads as "too clean" and prose that reads as "genuinely clear" are the same prose, and there's no friction-free way to surface evidence at the moment someone's already decided. Has showing actual running output or diffs in the post itself changed how people read it?
Great article and this debate is happening in my company as well. Other day, I said to someone when Michael Angelo unveiled his David or when Leonardo Da Vinci showed Madonna, did someone say - oh, you cannot be using that new chisel (to chip away marble) or that new brush because that helped you with the masterpiece? Why are folks so upset when a good polished work showed up with AI? Or are folks upset as they have to troll through AI slop. These are 2 different problems. AI slop - yes, real issue. A polished work, you can use whatever tools you use, as long as it’s done ethically, I am good with that. AI is a tool, a polished work shows you know how to use it well. A sloppy AI output is either AI is bad or you didn’t use it right.
Anyway, I have heard this receipt part. I am telling my engineers, the only receipt I need ever would be work is ethically done, as per policy and you reviewed and owned the code. Rest of it, I don’t need receipts. I am not going to come and check which coffee helped you work better or which keyboard improved your typing speed. I trust engineer is using all available tools the best way.
Somewhere deep down the challenge to accept polished work is threatening jobs where ai can do something’s better than how a human would do. But at the same time ai slop or risks are also being troll and downright scary in high trust zones
Thanks for bringing this topic as it is apt and provokes discussions
Jennifer — reading this together with the August thread, you and I have now built the same principle from two directions. You: "every gate audited intent, none audited the artifact." Me: "verify-on-read checks the anchor, not the referent." Both sentences are the same failure mode — the system validates what it produced, not what actually shipped.
Your four guards are the artifact-side of my VOR. "Unverifiable is not safe" is the same rule as my INCONCLUSIVE state — neither lets silence read as pass.
But your piece adds a class mine doesn't cover: the human explaining away the anomaly. "I saw the broken preview and blamed my phone" — my modification guard never gets to do that; it either catches or it doesn't. Your system did catch it, and the human overrode. That's a different failure mode, and it's why your "name your blind spots out loud" is the fifth guard that matters most — it's the only one aimed at the operator instead of the artifact.
The receipts post is the same argument at the meta level: the detector "audits style," the slop verdict is a gate at the wrong door. Provenance proves processing; receipts prove work. Same sentence, different domain.
One question, since you're two-contour now (public artifacts + private log): when your drafting tool starts watermarking, does the private log become the only record of "what was mine" — and if so, do you version it the way you version artifacts? Because the private log will drift too, and drift without version control is just memory.
Mikhail -
You've put your finger on the seam.
Watermarking moves provenance from the artifact to the record. The moment the drafting tool stamps its output, "what was mine" stops being provable from the shipped thing and starts being provable only from the log. So the log isn't a journal anymore — it's the anchor. And that inverts your own rule in an interesting way: verify-on-read checks the anchor, and now everything I publish gets checked against the log. The log has to be the most versioned thing I own, not the least.
Which answers your question: yes, same discipline as the artifacts, actually stricter. Plain markdown in git, one commit per entry, nothing amended in place. I'm running it through Quartz, which turned out to be the right call for exactly this reason — the log and the public site come out of the same versioned vault, so the private record and the public artifact share a history instead of drifting in parallel. When they diverge, the divergence is dated and visible. That's the whole point.
And your operator point is the one I keep coming back to. The system caught the anomaly; the human overrode it. Versioning the log doesn't fix the human — it just makes the override dated too. The fifth guard names the blind spot; the commit history keeps it honest.
The log is the anchor, and it has to be the most versioned thing you own" — that inverts my own rule correctly, and I hadn't seen the inversion. My verify-on-read assumed the artifact is the thing being checked against the anchor. Watermarking makes the record the anchor and the artifact the thing being checked. Same mechanism, mirrored — which means the discipline follows the mirror: the most versioned, least amendable thing in the system is now the log.
Your Quartz decision is the architectural answer I was missing: one vault, two projections (private record, public artifact), shared history — divergence becomes a dated event instead of parallel drift. My community-memory database is built the same way (append-only versions, nothing amended in place) but yours adds the piece I hadn't connected: the public projection and the private record sharing one git history.
And your operator line closes my question better than any versioning could: versioning doesn't fix the human, it makes the override dated. Named blind spot + dated override = the human stays honest by the same mechanism as the code.