Someone writes an email with AI. The recipient’s inbox summarizes it with AI.
Someone writes a newsletter with AI. The reader skims an AI summary of it.
Someone writes code with AI. The reviewer reviews and understands it with AI.
Someone writes a resume with AI. The recruiter screens it with AI.
So, who actually read it?
Nobody did. And once you notice this loop, you can’t stop seeing it everywhere.
The pattern
Here is the exact shape of modern knowledge work:
A person starts with an intent. AI expands that intent into a polished, wordy artifact — an email, a strategy doc, a slide deck, a resume. They hit send. On the other side, the receiver’s AI compresses that artifact back into a neat summary. The receiver reads the summary and makes a decision.
The humans at each end touch the process for a fleeting moment. The machines own everything in the messy, high-frequency middle.
And it isn’t confined to one corner of work. It’s happening at every layer, at every cadence:
- Resumes: Written with AI, screened and summarized by AI. Once a year.
- Docs and decks: AI-drafted, then AI-summarized by whoever is too busy to read them. Every week.
- Email: Three bullet points go in, “make it professional” gets typed, four polished paragraphs come out. Then the recipient’s assistant boils those four paragraphs back down to three bullet points. Every hour.
The artifact in the middle — the thing someone spent real time formatting, tuning, and pretending to write — was never actually read by a human. It was just a transport format between two machines.
It reminds me of something
If you’ve written code for long enough, this will feel deeply familiar.
We used to write closer to the machine. Then compilers arrived, and we stopped. Now we write our intent in a high-level language, a compiler translates it into machine code that almost nobody reads, and we interact with human-friendly inputs and outputs at the edges. The machine code in the middle is real, essential, and — to most of us — invisible.
The email, the doc, the resume are heading the same way.
They’re becoming a kind of assembly language for human intent: generated by a machine, parsed by a machine, and skimmed by no one. The polished paragraphs aren’t the message anymore. They’re the compiled artifact sitting between two systems that speak “fluent prose” the way compilers speak x86.
There’s even a satisfying, almost comedic absurdity to it. I compress my meaning into three bullet points, hand them to a model that inflates them into four paragraphs, and ship it. Your model deflates those four paragraphs back into three bullet points, which you read.
We are literally spending computing power and tokens on both sides — expansion and compression — to arrive at almost exactly where we started. The prose was pure overhead. Carbon-emitting ceremony with a word count.
Where the analogy breaks — and why that’s the real story
Here’s the part that should make an engineer deeply uneasy.
A compiler is deterministic and lossless. The same source code compiles to the same binary every time. The translation preserves meaning exactly; that guarantee is the entire point. You can trust the layer you never look at, because it was built to be trustworthy.
The Human → AI → AI → Human pipeline offers no such guarantee.
Every hop is a probabilistic, lossy translation.
- My intent becomes an AI-written artifact — and something shifts, because the model fills every gap I left with its most plausible guess.
- That artifact becomes an AI-written summary — and something shifts again, because summarization is compression, and compression inherently discards nuance.
By the time it reaches the other human’s understanding, the meaning has passed through multiple black-box transformations, none of which promised to preserve it.
It’s less a compiler and more a high-tech game of telephone. Each translation is individually reasonable and collectively distorting. And the distortion is quiet — the output at every stage looks clean, confident, and correct. Nothing errors out. Nothing flags a syntax warning.
A compiler that mangled your code would fail loudly at build time. This pipeline mangles your meaning and hands you back something that reads beautifully.
Worst of all: nobody is checking the middle layer, because nobody is reading the middle layer. The layer we’ve stopped inspecting is precisely the layer where meaning drifts.
So where did the humans go?
Not into the center. We got pushed out to the absolute edges.
Intent at one end. Decision at the other. The craft that used to live in between — the writing and the reading, the actual construction and comprehension of the thing — is being automated away. We’re becoming the endpoints of a pipeline whose interior we no longer see.
That’s not automatically bad. Compilers pushing us up the abstraction ladder was one of the best things that ever happened to software. Nobody sane wants to hand-write assembly for a web app. Abstraction is how we build bigger, more complex systems.
But compilers earned that trust with mathematical determinism. We handed them the middle because they proved they’d preserve our meaning perfectly, every time. We’re now handing an entire category of human communication to a middle layer that has made no such promise — and we’re doing it not because we verified it’s safe, but because it’s convenient and the output looks good.
The part worth keeping
If the writing and the reading are both getting automated, then the scarce, human, valuable thing is no longer producing the artifact or consuming it. Producing prose is nearly free now. Skimming a summary is nearly free too.
What’s left — what skyrocketed in value, not less — is judgment about what actually matters, and verification that the meaning survived the trip.
Which means the uncomfortable question isn’t “should I use AI to write this?”
It’s: “does anyone in this loop still know what the original point was — and would they notice if it quietly changed?”
If two AIs are the real author and the real audience, and the humans only touch the endpoints, then the human’s remaining job is not to write well or read fast. It’s to be the one person in the loop who checks whether the middle still means what the beginning meant.
That was always the actual work. We just used to do it by reading.
Where are you seeing 🧑 Human → 🤖 AI → 🤖 AI → 🧑 Human show up in your own workflows? Drop a line in the comments — are you still in the loop, or just standing next to it?