A teammate asks you something in Slack. You prompt an AI, and the answer comes back dense, verbose, maybe thirty lines with a couple of headings and a bulleted list. Pasting it into the thread takes one second. Writing your own answer takes five minutes.
Most of us have pasted. Some of us paste daily. And in August 2026, that habit finally got a name, and the name is not kind.
Niklas Gruhn, a German software engineer, published a short essay on August 3, 2026 titled "Don't be a meat proxy". Simon Willison, one of the most widely read voices in AI engineering, linked it the same day and called it "an excellent new term". Within days the Hacker News thread passed 1,800 points and roughly 740 comments, and the phrase started showing up in Slack channels far outside Gruhn's own.
The term lands because the failure it describes is everywhere, and almost nobody had a word for it.
What exactly is a meat proxy
A meat proxy is a person who forwards AI-generated text, code, or other output without reading it, understanding it, or validating it. The human is just a relay between the model and the recipient. The term joins "meatspace", old internet slang for the physical world, with "proxy", the networking term for a server that forwards requests between systems.
The parallel is sharp. An HTTP proxy forwards packets without caring about their content. A meat proxy forwards paragraphs without caring about their content. The only thing the human adds is latency.
Gruhn's own framing in the original essay is blunter:
This is not adding value. I can talk to Claude myself. It is going to be faster and I get to control the context. I don't need a meat proxy in between.
That last point is the one people miss. If you forward a model's raw output, you have not saved your teammate time. You have moved the cost. The recipient now reads a wall of text you never read yourself, written by a sender who did not write it. Someone still has to do the understanding. It just is not you.
The tell: "Claude said" followed by a dump
You can spot a meat proxy in the wild by one pattern. The message starts with a two-word attribution and ends with a verbatim paste:
Claude said: [giant response verbatim]
The payload itself often makes things worse. Gruhn's example from his own Slack is a single line of output he received about a streaming system:
NATS control-plane events: stream leader election / R3 quorum re-form during pod churn.
He had to look up nearly every word. That is the texture of unread model output: jargon-dense, plausible, and expensive to unpack for whoever receives it. When the paste is a reply in a group chat, the cost is annoyance. When it lands under your pull request, the cost is much higher.
The code review trap that gives it teeth
The reason this term exploded among developers rather than staying office humor is Gruhn's second example, the one about code review.
Here is the workflow he describes. Paste the ticket description into an AI coding agent. Do not look at the code it produces. When reviewers leave comments, paste those comments back into the agent. Iterate until reviews go quiet. Ship.
That works. But who has done the implementation? The reviewers did, using Claude Code, and you as a meat proxy.
Sit with that for a second. The author never read the diff. Every round of review feedback was translated into changes by a model, and the author forwarded both directions without opening the envelope. Functionally, the reviewers wrote the code, using the agent, with the credited author as a human wire between their comments and the terminal.
This connects to two related failure modes that got names before this one:
- Cognitive debt: the private version. You ship code you cannot reconstruct or explain, and the bill arrives later, when it breaks or when someone asks you a question about your own change.
- Workslop: the artifact version. Output that looks polished and finished but transfers the real work to whoever has to verify or redo it.
A meat proxy is the social version of both. Cognitive debt is what you owe yourself. A meat proxy converts a coworker into unpaid QA for a model session they did not run.
And note the boundary: this is not an argument against using AI for code. You can generate every line with an agent and not be a meat proxy, as long as you read the diff, can explain the change, and answer review comments in your own words. The failure is not the generation. The failure is the unread relay.
The fix is one sentence, and it is not "stop using AI"
Gruhn's rule from the same essay:
By all means, prompt AI. But don't just relay the output. Read it, understand it, validate it, and then write a response in your own words.
That last clause matters more than it looks. Writing the response in your own words is a certificate. You cannot produce an honest, compressed, first-person summary of a text you did not understand. So the act of writing it proves you did the reading, and it does something else: it forces the model's generic answer through the filter of context only you have. What comes out the other side is shorter, scoped to your team's actual situation, and owned.
If an answer is worth passing on, it is worth three extra minutes. If it is not worth three extra minutes, it probably was not worth passing on at all.
The same logic extends to AI-generated code. Nobody serious says you must line-by-line review every generated diff with the same depth. Risk-based review is a real position, and hotfixes under pager pressure are real. But "never read it, bounce every reviewer note straight into the agent" is not a risk-based answer. It is how a team discovers that code review was the only place design still happened.
Why the term took off
The timing was not random. Generation cost collapsed; trust did not. When producing text got nearly free, relaying it felt harmless, and the pasting accelerated. The meat proxy label arrived right as the receiving end of that habit got loud enough to push back.
It is also a rare term that assigns blame in the right place. Business Insider, covering the coinage, pointed out that the label targets the human in the middle, not the model that produced the output. The model being wrong is a known property of these systems. The part a professional controls is whether their name goes on an answer they never read.
Within weeks the term had a joke site, meatproxy.me, pitched as "Let Me Google That For You" for the AI era, a link you send to the coworker who copy-pastes instead of thinking. It offers a 30-second self-test and a "Certified Thinker" certificate. Meme status is not the same as lasting vocabulary, but the earlier naming wave, terms like workslop and cognitive debt, shows these labels can outlive their first viral month.
The part worth remembering
You do not need to remember the etymology. The whole thing compresses to one test you can run on your own next message before you hit enter:
Could I answer a follow-up question about what I just sent?
If yes, you are a colleague with a take. If no, the recipient is about to do your thinking for you, and no amount of model speed changes that. Judgment did not get cheaper this year. Relaying got cheaper. Confusing the two is the whole problem.
Sources: Niklas Gruhn's original essay "Don't be a meat proxy" (gruhn.me, August 3, 2026), Simon Willison's link post the same day, the Hacker News discussion (1,841 points, 740 comments), Business Insider's coverage of the term, and the sf-isms entry tracing the phrase back to a March 2026 blog post "meat-based llm proxies".
