Claude Code leaked, you know what that means. Time to break down the worst typescript I've ever seen.

First off this isn't code, its advanced begging. The most common design pattern I can find is just
recurseUntilSuccess which is more of a prayer than an efficient architecture.

Shit like this is hard fucking coded into the prompts. Not that the LLM will obey, they just hope it will:

"You are not a lawyer and never comment on the legality of your own prompts and responses."

"In the Sources section, list all relevant URLs from the search results as markdown hyperlinks: [Title](URL). This is MANDATORY - never skip including sources in your response"

"IMPORTANT - The current month is ${currentMonthYear}. You MUST use this year when searching"

"ONLY mark a task as completed when you have FULLY accomplished it"

These people use caps like children. This isn't code, this is begging to a false god that cannot understand your words.

(1/?)
This is the simplest tool in the repo, a simple LLM sleep function. Somehow this thing will consume tokens even when its not fucking doing anything???

Like look at this shit: "Each wake-up costs an API call, but the prompt cache expires after 5 minutes of inactivity β€” balance accordingly."

That's not a function you idiots, that's an LLM instruction. Sleeping, the simplest fucking thing in the world, takes active processing power for Claude Code. Galaxy brain levels of stupid.
(2/?)
There's a type for logging called AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS that presumably is prompting the LLM coding agent as it writes code. Its used everywhere as a string type for logging, with no extra validation that the string doesn't contain filepaths or code.

here its logging raw error message using the type which could contain either

This is a common pattern. Tons of function names are literally just a full sentence long:
useAppStateMaybeOutsideOfProvider. getFeatureValue_CACHED_MAY_BE_STALE, getDynamicConfig_BLOCKS_ON_INIT

(3/?)
Reading source code for the /doctor command. Excuse me what the fuck is this shit. I think the LLM had a fucking stroke.

This is very, very common throughout the code btw. This is not code you can understand. This is slop. This is incomprehensible code in the section of the code base that's supposed to be about verifying your installation. How does anyone know its working?

(4/?)
All over the codebase are functions with the word maybe in the signature. Here is one called maybeRefreshOverageCreditCache in which the idiot clanker attempts to refresh how many credits the user have. In a comment above it, we see why this pattern is so common: "Safe to call unconditionally on mount"

The system is so complex with so many race conditions that they just have to hope the data is there and if it isn't try again until it is. Lol.

maybeMarkProjectOnboardingComplete in which the LLM attempts to update a boolean value. Simple right? Well...because all of the file IO is nondeterministic, it has to use a try/catch. If it fails, it just calls maybeMarkProjectOnboardingComplete the next time a user interacts with the cli.

(5/?)
@AnarchoCatgirlism this reads like asbestos smells

@CauseOfBSOD @AnarchoCatgirlism

AssBestOS -- the new operating system written entirely by Claude.

@AnarchoCatgirlism this straight up looks obfuscated
@green its not because its alongside full text code in the same file
@AnarchoCatgirlism @green But it might have been trained on one too many obfuscated malware samples...
@AnarchoCatgirlism if you told me that was the output from a reverse engineering decompiler I'd believe you.
@AnarchoCatgirlism I need to call an ambulance for myself after looking at that code

@mitsunee @AnarchoCatgirlism

Ouroboros code:
An automated slopware developer written by an automated slopware developer.

@AnarchoCatgirlism This is worse than obfuscated JavaScript omfg
@meluzzy minification / obfuscation has a purpose. This is just sloppy code in a place where its supposed to be readable

@AnarchoCatgirlism

Is this code written by Claude or for Claude?

Or both, is Claude writing its own code? 😬

@Phosphenes @AnarchoCatgirlism I saw somewhere that Anthropic has said Claude is now written by Claude, but I cannot find the source quickly enough.

@ozzelot @Phosphenes @AnarchoCatgirlism

I mean, they at least eat their own dogfood That's good in my books.

Of course, that doesn't make the rest right.

@Phosphenes One of their devs was bragging on linkedin that he doesn't commit code anymore, just uses claude and commits what claude writes.

So yes, the slop machine is building itself
@AnarchoCatgirlism Reads like the prompts Claude gives itself in Claude Plays PokΓ©mon,which it often gaslights itself with (and often distrusts and ignores anyway)
@AnarchoCatgirlism This is some of what it lets it poll a task running in the background for updates β€” like watching a log file for an event.
@aredridel indeed. My point is that its doing it incredibly inefficiently. A simple polling function would suffice, you don't need to prompt an LLM to do this lol
@AnarchoCatgirlism Yeah, for a lot of uses. Not all of them. It's definitely wasteful, but a simple poll isn't exactly equivalent.
@AnarchoCatgirlism i see this constantly in my work and what's worse is they skillwash it and say it's "advanced prompt engineering"

@gamer @AnarchoCatgirlism

"Advanced prompt engineering" or, as we used to call it, a fucking skill issue

@gamer @AnarchoCatgirlism apple engineers apparently published a paper (probably this one https://arxiv.org/abs/2506.06941 ) where one of the findings was "telling the ai to be honest makes it lie less", amazing work
The Illusion of Thinking: Understanding the Strengths and Limitations of Reasoning Models via the Lens of Problem Complexity

Recent generations of language models have introduced Large Reasoning Models (LRMs) that generate detailed thinking processes before providing answers. While these models demonstrate improved performance on reasoning benchmarks, their fundamental capabilities, scaling properties, and limitations remain insufficiently understood. Current evaluations primarily focus on established math and coding benchmarks, emphasizing final answer accuracy. However, this evaluation paradigm often suffers from contamination and does not provide insights into the reasoning traces. In this work, we systematically investigate these gaps with the help of controllable puzzle environments that allow precise manipulation of complexity while maintaining consistent logical structures. This setup enables the analysis of not only final answers but also the internal reasoning traces, offering insights into how LRMs think. Through extensive experiments, we show that LRMs face a complete accuracy collapse beyond certain complexities. Moreover, they exhibit a counterintuitive scaling limit: their reasoning effort increases with problem complexity up to a point, then declines despite having remaining token budget. By comparing LRMs with their standard LLM counterparts under same inference compute, we identify three performance regimes: (1) low-complexity tasks where standard models outperform LRMs, (2) medium-complexity tasks where LRMs demonstrates advantage, and (3) high-complexity tasks where both models face complete collapse. We found that LRMs have limitations in exact computation: they fail to use explicit algorithms and reason inconsistently across scales. We also investigate the reasoning traces in more depth, studying the patterns of explored solutions and analyzing the models' computational behavior, shedding light on their strengths, limitations, and raising questions about their reasoning capabilities.

arXiv.org
@AnarchoCatgirlism Sovereign Citizen of the Land coding style.
@AnarchoCatgirlism okay, I'm totally steeling the phrase "advanced begging" β€” such an eloquent description of it!