If you keep up with AI news, you may have seen that the source code for Claude Code leaked. I think this is interesting news, but some of the technical stuff involved might be a little opaque. So if you're curious, here's my best attempt at a (provisional, partial) explanation, piece by piece:
What is source code?
Whenever you write a computer program, you write it in a programming language (C++, JavaScript, Python, etc.). Most modern programming languages are relatively “high-level” – which is to say that they’re shorthand systems designed to make it possible to write complicated programs. But when the computer itself runs code, it runs “machine code” – the really basic instructions that tell the hardware when to turn the switches on and off.
Before releasing a given program as an executable file (the kind you double-click on your desktop), software engineers have to “compile” it, or translate it from the programming language – the “source code” – into usable machine code.
This translation is one-directional: we can’t easily translate machine code back into a higher-order language. Machine code is extremely difficult for humans to read, and the instructions it conveys don’t correspond one-to-one with the code as it was written. There are a few reasons for this; the most basic is that the source code often contains a lot of text that doesn’t actually do anything in the final project, used by programmers to explain what they’re doing with a given section of the code, mark things that need revision, etc. There are various techniques for “reverse engineering” a given program, but they’re difficult, complicated, and imperfect. It’s one (very difficult) thing to figure out how to make a program that pretty much does all the same stuff that the original program does, but you won’t ever get to the original code as it was originally written.
Some software is “open-source,” meaning that the source code is publically available for everyone to see and work on. Most commercial software is proprietary, or “closed-source.” This makes the software easier to sell and harder to imitate, but it also gives companies a lot of power and makes public oversight difficult.
What is Claude Code?
If you’re not a programmer and you’ve heard of Anthropic, it might have been from the “showdown” their CEO, Dario Amodei, had recently with the Trump administration. Anthropic is generally portrayed as the “good AI company,” especially compared to the blatantly nefarious OpenAI. Amodei actually split with OpenAI over “ethical concerns” – though as Karen Hao argues in her book about the rise of OpenAI, Empire of AI, Amodei’s, and by extension Anthropic’s, specific concerns essentially disregard the real problems caused by LLMs in favor of a lofty, patronizing, uselessly abstract, and fundamentally noxious set of ideological fixations, often associated with the “TESCREAL” and “effective altruism” movements. They’re incredibly aggressive in promoting unrealistic claims about what AI can (or will be able to) do, fueling speculation and scaring everyone.
It’s mildly interesting, if not quite commendable, that anyone in tech would stand up in any way to Trump’s administration, especially in light of long-standing labor disputes between liberal-leaning tech workers and their reactionary bosses. But while I don’t have time to get into it here, suffice it to say I don’t think we really “have to hand it to” Amodei here or ever. (As I’ll explain in a second, Anthropic’s reaction to the Claude Code leak is a good reminder of why this is.)
If you are a programmer, you’ve already heard of Anthropic. Claude Opus 4.5, the model they released in November of last year, was widely heralded as a massive leap forward for LLM-assisted coding, though many software engineers dispute this claim.
Ok, that’s Claude “Opus.” Is that different from Claude “Code”?
In brief: Claude Opus is a “model”; Claude Code is, essentially, an interface for interacting with that model. To understand this, it’s worth taking a moment to break down what exactly happens when you ask one of the big commercial chatbots something.
Let’s take ChatGPT as an example. Say I’m using the web interface – the thing that comes up when you go to the ChatGPT website:
(1) I type a question into the box. (2) The question is sent over the internet to a data center. (3) The question is broken down and run through the model – a massive, intricate algorithm – in order to synthesize a textual response. (This process is sometimes called “inference.”) (4) The response is sent from the data center to your web browser. (5) The response is displayed in the box.
The really complicated and expensive stuff is all happening in a data center, far from your laptop. This is a problem borne of technical necessity: even the fanciest consumer-grade computers aren’t powerful enough to run cutting-edge “frontier” models like GPT-5 and Claude Opus. (There do exist open-source models that can run on home computers, but they’re much, much slower and clunkier.)
“Claude Code” is a software application designed specifically for programmers. It runs on your computer (in the command-line) and is designed to make it easier and more efficient to interface with the model. It’s also, as it turns out, a total mess.
So what just happened, then?
Claude Code’s source code wound up on the public internet, probably because Claude itself disregarded instructions and put it there, though Anthropic is, of course, blaming human engineers for the problem.
This doesn’t solve the largest transparency problem with corporations like Anthropic and OpenAI – namely, that we don’t have access to the models themselves. But there’s still a ton we can learn from this leak.
Like what?
I’m on rockier ground here, as I can’t myself read the code. But I’ll link to a few different interpretations I’m seeing. The main thing people are saying is that the code – which engineers at Anthropic have said is entirely written by the application itself – totally sucks.
How does it suck? How does code suck, in general?
Again, totally not an expert here. But I’ll lay out some of what I’m seeing.
One problem is that it’s a massive, sprawling mess. Some argue this doesn’t really matter, and it’s true that the elegance or beauty of code doesn’t necessarily translate into good software, nor does functioning software require good code. If it does what you need it to, it works.
But there are reasons beyond the aesthetic to prefer well-written code. A clear foundation is easier to build on and expand, for one. More than that, though, the key shortcoming in LLM-assisted coding, as best as I can tell, is that it makes it really easy to ship (publish) code that the engineers don’t themselves understand.
The concept of “technical debt” has long been important to software engineering, especially in terms of the relationship between software engineers and managers. Technical debt is, in short, the cost incurred by writing and shipping code too fast. While a patched-together solution might be easier in the short-term, the shortcomings of quick fixes add up over time. Sloppy code is harder to maintain and build on than well-written code.
With the advent of LLM-assisted coding, a new variation has emerged: “cognitive debt.” Cognitive debt is the debt incurred by shipping code the engineers don’t themselves understand.
https://margaretstorey.com/blog/2026/02/09/cognitive-debt/
How does Claude Code suck?
It seems that Claude Code sucks in a lot of the classic ways code can suck: it’s a big sprawling mess, etc. But there are a couple of specific ways it’s bad.
For one, it frequently uses prompts where code should go. Instead of solid, deterministic code, written in accordance with long-standing best principles, it just asks Claude to do stuff in natural language, like an ordinary user would. This makes the overall process both less reliable and more expensive.
The fundamental problem with LLMs – the reason they will never, ever do what their biggest boosters say they will do – is that they are probabilistic. You simply cannot guarantee that an LLM will produce the correct outcome. Regular code, on the other hand, is deterministic. The same outcomes result every single time. Obviously, regular code can have bugs, but the reason you can fix them is because you can figure out what is triggering the unwanted outcome and rewrite it. You cannot fix bugs in LLMs the same way. The problem of “hallucinations,” as they are anthropomorphically called, is ineradicable.
What this means is that every time Claude Code does something with an LLM prompt that it could do with good old code, it is opening up room for failure. The other thing it means is that Claude Code is probably just wildly expensive.
I’ll summarize this problem in another blog post at some point, but there’s a reason all of the major AI companies are so cagey about releasing financials. All of the available evidence leads us to believe that “inference” – the act of running a prompt through a model and generating a response – is far more expensive than OpenAI or Anthropic wants us to believe. These companies are almost certainly losing money on even the most expensive subscription plans.
This is why Dario Amodei, CEO of Anthropic, recently attempted to redefine the basic concept of profitability on a podcast recently:
AMODEI: Profitability is this kind of weird thing in this field. I don’t think in this field profitability is actually a measure of spending down versus investing in the business…I actually think profitability happens when you underestimated the amount of demand you were going to get, because you’re buying the data centers ahead of time.
This claim is difficult to make literal sense of, so I can’t say this is a definitive rebuttal, but what this claim (as well as the “toy model” he builds from “stylized facts” to illustrate his point) fails to address is the fact that it is impossible for a service-based company to make money when the service it offers loses them money every time it is used. For a company like this, high demand just makes the financials even worse than they otherwise would be. So when Claude Code substitutes efficient, solid code for prompts, the software doesn’t just become less reliable – it loses them even more money.
All of which is to say that the Claude Code leak has confirmed what many believed: the premier AI-assisted coding application, created by a company widely regarded as revolutionary, is a big pile of needlessly expensive, architecturally sloppy “spaghetti code,” one which only serves to deepen the hole Anthropic is in. What this means for the future of LLM-assisted coding isn’t clear yet, but this leak makes it harder to believe, at least in the medium-term, that it’s anything good.
[Note: there are a few links I'd like to add but haven't yet. Will do soon!]
- Theodora