A meat proxy is a person who forwards AI-generated text, code, or other output without reading, understanding, or validating it. They are not a colleague with a take. They are a relay: the model on one side, the recipient on the other, and a human in the middle who never opened the envelope.
Developer Niklas Gruhn named the pattern on August 3, 2026. Three weeks later it showed up as a dictionary card in the San Francisco Field Guide at sfisms.org, then as a screenshot making the rounds on X. The joke landed because everyone already had the Slack message: Claude said: followed by a wall of prose nobody in the thread had time to audit.
The term is not "people who use AI." It is people who outsource the reading to whoever they just pinged.
TL;DR
| Question | Direct answer |
|---|---|
| What is it? | A human who forwards unread model output to another human |
| Who named it? | Niklas Gruhn, August 3, 2026; Simon Willison linked it the same night |
| Where did the card come from? | sfisms.org, "The San Francisco Field Guide" |
| The Slack tell | Claude said: plus a verbatim dump |
| The PR tell | Ticket into the agent, reviewer comments back into the agent, author never reads the diff |
| What is the job instead? | Read, understand, validate, then answer in your own words |
| Is this LMGTFY? | Only if they asked for a search result. If they asked you, they asked for judgment |
| Related failure modes | Cognitive debt (unread code you ship) and workslop (polished junk) |
What Gruhn actually wrote
The original post is short. That is part of why it stuck. Gruhn's complaint is not that models are in the loop. It is that a person showed up in the loop and added nothing:
Too often I ask a question in Slack or leave feedback under a merge/pull request or argue with friends in a WhatsApp group and get back: Claude said: [giant response verbatim]
His follow-up is the whole ethic: I can talk to Claude myself. It's going to be faster and I get to control the context. A paste that the sender did not read is not help. It is a context-free document with your name on the notification.
Simon Willison called it an excellent new term the same day and quoted the rule that matters:
Read it, understand it, validate it, and then write a response in your own words (a decent certificate that you've done the prior steps). Making that effort is value you can add.
That last clause is the product claim. Generation got cheap. Trust did not. The meat proxy is what happens when a team pretends the cheap part was the whole job.
Gruhn's running example of why unread dumps hurt is jargon density, not malice. He cites a single Claude sentence — NATS control-plane events: stream leader election / R3 quorum re-form during pod churn — and notes he had to look up almost every word. Verbose model prose is already expensive to read. Forwarding it unread makes the recipient pay that tax twice: once to parse the model, and again to guess what you think.
The code-review version is the load-bearing case
The Slack dump is rude. The pull-request version quietly reassigns the implementation.
Gruhn's sequence is now a standard coding-agent workflow, minus the human:
- Paste the ticket into Claude Code (or any agent).
- Do not read the code or the model's writeup.
- When reviewers comment, paste the comments back into the agent.
- Iterate until CI is green.
That works, in the narrow sense that a diff appears. The punchline is authorship: the reviewers did the implementation, using the agent, with you as the meat proxy between their comments and the model. Should you review every line of AI-generated code? is a real production question with risk-based answers. "Never read it, bounce every note into the agent" is not one of those answers. It is how a team discovers that review was the only place design still happened.
This is adjacent to, and not the same as, cognitive debt. Cognitive debt is what you owe yourself when you ship code you cannot reconstruct. A meat proxy is what you owe other people when you make them reconstruct it for you. One is a private understanding gap. The other is a social one: you converted a coworker into unpaid QA for a model session they did not run.
The same gap shows up as de-skilling when juniors never have to own a diff, and as the 2x-not-10x ceiling: model speed does not multiply the judgment tasks ("is this maintainable?") that still sit with humans. Loop engineering is the craft of staying in that loop on purpose. Meat-proxying is leaving the loop while keeping your name on the thread.
LMGTFY, HAPI, and the takes that miss the definition
Once the sf-isms card circulated, the replies split into a few recurring arguments. They are useful because they name the adjacent behaviors the definition does not cover.
"If you complain about a forwarded LLM answer, you are the problem — they are hinting you should have asked the AI. We used to call this Let Me Google That For You."
LMGTFY was a snub for a question that was a search box with extra steps. It only maps if the recipient asked for information the model can retrieve, and the sender is clearly handing them a search result. It does not map if they asked for a decision, a review, a status, or your reading of a messy thread. In those cases they already knew Claude existed. They pinged a person. An unread dump is not a hint. It is a bait-and-switch: the notification says a colleague replied; the body says a model did, and nobody checked it.
"We wrote a policy after learning this term."
That is the workplace version of the same instinct. You do not need a five-page AI policy. You need a norm: model output that leaves your hands has been read, and anything you could not validate is labeled as such. Teams that skip the norm eventually pay for it in review latency, because the next human in the chain becomes the verifier of record.
"We prefer HAPI — Human Application Programming Interface. I am proud to be HAPI."
This is a different contract. A HAPI is openly the interface: "I ran this prompt, here is the raw output, I have not verified section three." That can be useful, the way pasting a compiler error is useful. A meat proxy hides the contract. The paste arrives as if it were a human answer. Pride in being a HAPI is compatible with Gruhn's rule; pride in never reading the paste is not.
"Aren't we all meat proxies sometimes?"
Yes, in the same way everyone has forwarded an email they skimmed. The term is still doing work. It names the moment you stopped being a colleague and started being a socket. Occasional skimming is fatigue. A workflow of unread relay is how AI slop enters a team channel with a human signature attached.
"My AI had this to say: your absolutely right."
That joke is the tell in miniature: even the model's own writing tells and typos survive when nobody reads the output. Forwarding a sycophantic "you're absolutely right" is not collaboration. It is a screenshot of the model agreeing with itself, routed through a person.
Meat proxy vs vibe coding vs workslop
These get collapsed in threads. They are three different failure modes.
| Term | What failed | Who pays |
|---|---|---|
| Vibe coding | You generated without a spec tight enough to own the result | You, later, when it breaks |
| Workslop | The artifact looks done and is not useful | Whoever has to redo it |
| Meat proxy | You relayed unread output and called it a reply | The recipient, immediately |
You can vibe-code and still not be a meat proxy: you read the diff, you can explain the change, you answer review in your own words. You can avoid vibe coding and still be a meat proxy: you wrote none of it, you understood none of it, and you forwarded the model's essay into Slack because typing "looks good" felt like work.
The sf-isms definition is the one to keep: the person acts only as a relay between the AI system and the intended recipient. If you added judgment, you were not only a relay. If you did not, your name on the message is the bug.
How not to be one
Gruhn's four-step rule is enough. The rewrite is the test.
- Read it. If you would not want to receive a dump that long, do not send one.
- Understand it. Can you explain the claim without looking back at the model?
- Validate it. Check the part that would hurt if it were wrong — the API, the number, the "this is already in main."
- Write it in your own words. A short answer plus one cited excerpt beats a thousand-word paste. The rewrite is the certificate.
If the recipient actually wanted the raw transcript, say so: prompt, model, what you verified, what you did not. That is HAPI. It is also how you keep provenance honest instead of laundering slop through a human.
For code, the same rule is "own the diff." You do not have to retype every line. You do have to be able to answer why this approach, what happens if this constant changes, and which tests would fail if the model invented a helper that already exists. If the only person who can answer those questions is the reviewer, you were the meat proxy.
Related on explainx.ai
- When answers get cheap, trust is the job
- Should you retype LLM code? The cognitive debt debate
- What is AI slop?
- What is vibe coding?
- Should developers review every line of AI-generated code?
- 2x, not 10x: realistic coding gains with LLMs
- OCR It — don't paste unread OCR into an LLM either
- Lars Faye — AI coding will prevent expertise
- Humanising LLM outputs is lossy — render at the boundary
- Loop engineering for coding agents
- "Load-bearing": Claude writing tells
- AI-driven de-skilling
Sources
- Niklas Gruhn, "Don't be a meat proxy" — August 3, 2026
- Simon Willison, link post — August 3, 2026
- sfisms.org — San Francisco Field Guide entry for meat proxy
Definition and sources as of August 24, 2026. The sf-isms card is third-party artwork; this post quotes the public definition rather than reproducing the graphic. Follow @explainx_ai for updates.