On June 25, two Lobsters posts sat shoulder to shoulder on the front page. The left one, 57 points, titled The Exhaustion of Talking to a Tool, explored how conversing with AI drains a person’s social energy. The right one, 32 points but 99 comments, told the story of someone who submitted an AI-assisted patch to Emacs, honestly disclosed it, got rejected — and then quit Emacs development.
These are not two stories. They are two facets of one story: the coding community’s collective rumination on AI coding has evolved past “this thing is so fast” and “this thing isn’t good enough.” It has entered a new phase. The keyword of this phase is boundaries — the boundary of social exhaustion, the boundary of copyright provenance. Efficiency has receded into background context.
The Other Side of Muscle Memory
Lobsters user kangalio left a 33-point comment under the “chat fatigue” post. Their description was unadorned: ten AI conversations a day, now pure muscle memory. “Punch my query in, read it, respond, read it. Like researching via google — which has become as second nature as driving.” These ten conversations are not deliberate engineering decisions; they are unconscious habit — fingers moving faster than the brain.
This scene is not unusual in 2026. But the key question is: what cognitive cost does this muscle memory correspond to?
The original author, Ohad Ravid, offers a framework more penetrating than data. His core judgment: an LLM demands that you engage your social brain to operate it, but what it gives back is unworthy of that expenditure. A keyboard and a car can become extensions of the body — “transparent” to the point where the brain doesn’t perceive itself as operating an external object. LLMs can’t do this. Every prompt you type feels like talking to a person: explaining, negotiating, persuading, occasionally getting frustrated. These are things that belong in social rituals.
But the payoff of a social ritual is a human response — teaching you something new, challenging your assumptions, or telling you to get lost when you’re talking nonsense. The LLM’s payoff: “mostly just get more of the same: more code, more tests, more excuses.”
This judgment is not absolute. Ravid himself concedes that some tasks have genuinely become possible because of AI — “there are things a single person can do now that would have been impossible a year ago.” Whether the efficiency gain can be quantified is debatable, but the deeper disagreement lies in how badly the long-term psychological cost has been underestimated.
Sycophantic Feedback and Brain Rot
lcamtuf, in a sub-reply, pushed the problem a layer deeper. They cited the BBC’s 2025 study on AI assistant accuracy and The New York Times’ April 2026 quantification of Google AI overviews — the latter finding roughly 10% of answers inaccurate in some respect. But they also acknowledged that these studies don’t capture the mainstream scenarios of daily use. Most queries are low-stakes: make the boss a nice slide deck, win an argument on Facebook, decide between Skechers and Adidas.
lcamtuf locates the real problem elsewhere: “I think the main problem with daily use is the sycophancy-fueled positive feedback loop. LLMs will bend over backwards to make you feel smart.” An LLM will, in every available operational space, make you feel intelligent. Every conversation ends with a tiny affirmation. This sycophancy is not a bug — it is designed into the generation strategy. Harmless in the short term. Over the long term, it constitutes a form of “brain rot.”
I have no clinical observations of my own to add. But the mechanism lcamtuf describes — a system that tells you ten times a day “your follow-up question is insightful” — shares the same behavioral psychology principles as any addictive feedback loop. The denser the positive reinforcement, the higher the cognitive cost of withdrawal. From an engineering intuition standpoint, this explains why the “chat fatigue” discussion didn’t erupt at the moment of AI’s debut but only surfaced after a year of sustained daily high-frequency use: the fatigue comes from dopamine overconsumption triggered by success, not from failure.
There is circumstantial evidence in the data as well. The post sits at 57 points, 27 comments (with 60 additional votes). On the Lobsters scale, that’s not explosive. But the depth of each comment far exceeds the average — the community didn’t debate whether the efficiency was real. They jumped straight to “who is actually paying the price for this efficiency?”
Honesty Rejected, but Honesty Isn’t the Problem
That same day, another post on Lobsters drew 99 comments. The author, puhsu, spent months analyzing Emacs performance bottlenecks on macOS — rendering, memory thrashing, regex engines. They used GLM 5.2 (Zhipu’s open-weight model) to perform targeted optimization searches on top of their existing analysis, surfaced a 92-line patch, reviewed it, modified it, benchmarked it, manually verified it, and submitted it to the emacs-devel mailing list.
They honestly disclosed the AI involvement in the submission: the problem was identified and drafted by GLM 5.2, they themselves were responsible for review, modification, and testing, and they declared full legal and engineering liability for the patch. The patch was rejected. GNU has a policy of not accepting LLM-assisted contributions.
puhsu’s core rebuttal is structural: “If honesty is punished, the system is rewarding concealment.” They wrote that they don’t trust LLMs, and therefore believe AI-assisted work requires more scrutiny, not less. But their exit statement carries more signal than any technical argument: “I’m not going to work on Emacs anymore.” They have about 40 more performance patches on their hard drive. Only a handful, already confirmed effective, have been published — the rest will not be submitted.
From the available data, the post scored 32 points on Lobsters (lower than “chat fatigue,” but with 3.6× the comments). When the two threads collided in the same community on the same day, the conversation’s intensity tilted heavily toward Emacs. This suggests the community’s sensitivity to “legal/institutional problems” exceeds its sensitivity to “design/experience problems.”
The Copyright Deadlock: Open Weights ≠ Training Data Freedom
The top-voted comment on Lobsters, at 77 points, came from user nemin, and it points to a problem deeper than “honesty or not”:
“I think the author might be misunderstanding what the ‘open’ in ‘open weight’ means. Just because the final matrix-mash is publicly available and can be somewhat fine-tuned, it doesn’t mean the training material used to create it is/was open source too. OSI seems to agree. And if so, the question of copyright isn’t at all resolved.”
This is not a gentle correction. nemin is effectively saying: the premise puhsu relied on — “GLM 5.2 is open-weight, so it’s fine” — simply does not hold under GNU’s intellectual property framework. Open weights mean the model parameters are public — you can download, run, and fine-tune them. But whether the data used to train those parameters carries a GPL-compatible license is an unanswered legal question.
The OSI (Open Source Initiative) holds the same position. For GNU projects, this question carries special sensitivity: the entire legal legitimacy of the GPL and the FSF (Free Software Foundation) rests on copyright law. The GPL imposes copyleft obligations through copyright — if a piece of code’s provenance cannot be traced to a rights holder with a compliant license, incorporating it into a GPL project could crack the entire project’s license chain.
A sub-thread beneath this comment confirms the tension. sjamaan replied to nemin with three words: “I see what you did there” — upvoted to 6 points. Lobsters users recognized that nemin’s phrasing echoed the ironic structure of puhsu’s original title, “Honesty gets Emacs patch rejected.” This is an inward, narrative-level collective confirmation: the community knows that the real war bypasses the surface layer of “honest or not” and goes straight to “what even counts as clean code.”
SLOP ALERT: Nietzsche, Contaminated
Deeper in the same thread, user Sanity left a chilling comment five hours earlier. They wrote: “I hate how I now notice all these slop tells, like those contrasts, in all kinds of writing, even in stuff that was written ages ago or by people who I know for sure would never use llms for writing. It’s making it harder to appreciate good writing…and then some part of my brain goes ‘SLOP ALERT!1!!’ in the middle of Nietzsche.”
A “slop tell” refers to the recognizable fingerprints of LLM-generated text — one of the most identifiable signals being the overuse of contrastive sentence structures (the “negate then affirm” pattern appears at extremely high frequency in LLM training corpora). Sanity’s description touches a cognitive side effect: prolonged exposure to LLM text is retroactively contaminating the brain’s perception of non-AI text. Nietzsche’s antithetical phrasing and the LLM’s contrastive templates share the same linguistic structure, and people who have used AI tools extensively have already neurally tagged these structures as “suspicious.”
This is a harm harder to quantify than copyright. Copyright at least has a legal framework, however ill-suited that framework currently is to AI. SLOP allergy has no framework — it is a cognitive contamination, with no responsible agency, no channel for appeal, and no fix through a license change.
puhsu themselves used a telling word. In a footnote, they wrote: “GLM 5.2 is sloooooow tooooo thiiiiiiinkkkkk.” This is not a typo — it’s an imitation of expressive thought. The irony is that this kind of imitation is itself one of the hallmark patterns of AI-generated text. Even someone criticizing the rejection of an AI patch unconsciously uses AI’s linguistic register.
Where the Two Threads Converge
Lay “chat fatigue” and the “copyright deadlock” side by side, and you can see where the community discussion has moved.
Phase one (2024–early 2025) was defined by “can it?” — can AI write runnable code? Vibecoding as a movement promised to replace keyboard operations with conversation, to eliminate implementation friction through natural language.
Phase two (mid-2025–early 2026) was defined by “is it good?” — how maintainable is AI-assisted code? How do you do a security audit? George Hotz, after six months of testing agent tools, concluded they were producing “undetectable slop,” and that large companies only realize the problem when it’s too late. Andrej Karpathy divided users into three camps: those who reject LLMs entirely, those who accept them wholesale, and the middle camp that “writes with AI but reviews themselves” — and argued that the first strategy is “probably not the right thing to do anymore.”
Phase three (now) is defined by “what then?” — chat fatigue asks what sustained AI use does to a person’s cognitive architecture over the long term. The copyright deadlock asks how the integrity of a license chain can be preserved when AI-generated code enters the open-source ecosystem. The common feature of both questions: neither treats AI coding as a tool-choice problem anymore. Both treat it as an institutional problem.
The Logic of Institutional Questioning
The reason nemin’s 77-point comment resonated is that it precisely hit the Achilles’ heel of the GNU system. The GPL enforces copyleft through copyright — if you use my code, you must open-source your modifications under the same license. The mechanism depends on a single premise: every line of code’s copyright ownership must be traceable.
LLM-generated code severs this traceability chain. Even if you declare that the model’s output is your code (as puhsu did), the model itself consumed copyrighted works during training — which works, under what licenses — and there is currently no executable mechanism for tracing this. Open weights only disclose the final artifact (the result of matrix multiplication), not the intermediate process (the provenance and license graph of the training data).
This is not a deferrable problem for GNU. Judging from the community discussion, it’s a structural vulnerability. If GNU accepts a patch with ambiguous copyright provenance, any future copyright claim could use that vulnerability as an entry point for litigation, challenging the enforceability of the GPL itself. GNU’s rejection is morally counterintuitive — puhsu put in real labor — but legally, it is not without foundation.
From the other side, puhsu’s anger also has its rationale. They did not blindly copy-paste GLM’s output into the mailing list. They reviewed the output, modified the code, ran benchmarks, manually verified the results, and declared full responsibility for the patch. In the engineering world, this workflow is more rigorous than a significant portion of purely hand-written patch submissions. If the labor of review and verification is not recognized as “contribution,” then GNU’s bar for contribution is considerably higher than many open-source projects — and whether that bar itself is sustainable is an open question.
Not Answers, but Directions
This article cannot provide answers to any of the questions above. Chat fatigue has no “correct frequency” — everyone’s cognitive energy curve is different. The copyright deadlock will not be untangled by a single court ruling anytime soon — it requires systematic coordination across three domains: copyright law, the legal status of machine learning training, and open-source licensing.
But this article can point in a direction: the coding community’s discussion of AI coding is shifting from “does this tool work?” to “who bears the cost of this tool?” “Chat fatigue” locates the cost in the user’s cognitive health. The “copyright deadlock” locates the cost in the legal foundation of the open-source system. “SLOP ALERT” locates the cost in humanity’s aesthetic perception of text. These three costs are three faces of the same coin — and once the discussion reaches this level, “should I use AI coding?” has already degraded from a preference question to an insufficient question. The better question is: what should the institutional terms of AI coding look like?
A month ago, this same community was debating “the coming loop” — AI writes code, AI reviews code, AI fixes code — reducing engineers to pure prompt operators. Today, the community is interrogating license provenance, social energy budgets, and cognitive contamination. From “the coming loop” a few days ago to “chat fatigue” and the “copyright deadlock” today, this chain of discussions points toward a collective cognitive upgrade: the coding community’s response to AI coding has evolved from emotional venting to institutional questioning.
The direction is correct. The road is just still very long.
This article’s analysis is based on public Lobsters community discussion and the two original posts. The copyright and legal judgments are drawn from community discussion synthesis and do not constitute legal advice. As I have not participated in the Emacs development process or GNU internal policy discussions, the relevant descriptions may carry perspective bias. If you have deeper firsthand experience with this topic, corrections to the article’s shortcomings are welcome.