I read the code.

The tweet

"I read the code." is a tweet posted by Mitchell Hashimoto, the creator of Ghostty and co-founder of HashiCorp. It started a debate over the internet about whether people should read the slop generated by AI coding agents or not.

First of all, I'm not going to address the dumb "AI as a compiler" take. The only thing you get out of this argument is knowing the person saying it doesn't know shit about compilers or LLMs. If you're willing to spread shitty arguments without understanding the technology, get the fuck out of tech and find something you're actually willing to learn.

When AI works without reading

You have a trivial app you use for yourself a couple times and you don't care how it works. You're not going to maintain or scale it. Here the AI is perfect. It just gives you what you want in very little time. Big win.

The zero-dependency trap

So I've been thinking a lot about the role of AI in programming, and there are a lot of ideas. But here's an interesting hypothesis. Say we use AI coding agents to make our code zero-dependency. Sounds nice, huh? The AI builds you the helpers or the low-level stuff you don't understand and exposes a simple API. It's like importing a third-party library without actually adding a dependency. And zero-dependency code is great, right? It lets you work on projects out of your league right now. But in fact it's very bad. Using a third-party library is actually better than going zero-dep. What? How? I'll tell you.

We don't really think about this when we use a third-party dependency, but when we do, we're implicitly trusting the maintainers to keep it working with good performance. You don't need to care about the library. It's all trust.

With AI-generated code, the code is sitting in your codebase, which makes it officially your problem — not someone else's. So now you're implicitly trusting the AI agent to maintain this code and meet your application's functional and non-functional requirements. That's a real problem if you actually understand how AI works under the hood. And by now, it seems like the big majority are just pretending to know.

The 500K lines scenario

Humans have been generating slop for decades. We write bad code with massive technical debt and abstractions that kill performance. So why is AI much different? Let me paint a scenario. You had AI author a non-trivial piece of software (I'm too lazy to think of a specific example). You don't review any of it. You let the AI do whatever it wants. Now it's generated a 500K+ line codebase. Congrats, your code has users. Bug reports start coming in. Feature requests pile up. Maybe it's a SaaS and you need to scale. In this scenario you're completely fucked. Here's why.

Let's start with what we can measure. Our biggest AI models have around 1M tokens of context window. Solid, right? But in our scenario you have 500K+ lines of code you know nothing about. You have a logical bug and you need to fix it. How? You go to an LLM, tell it "solve this bug plsss." It loads the whole codebase and burns through the entire context window looking for candidates in the over-engineered mess it created. It tries to debug. It fails — because it just exhausted most of its context tokens. 1M tokens is roughly 750K words depending on the tokenizer. It's trying to fit the codebase plus all its thinking into that. And yeah, I know you can use AGENT.md, CLAUDE.md, all those markdown files you read about on LinkedIn. The codebase is still too large.

You'll tell me: hahaha, you're dumb, "solve this bug plsss." is a stupid prompt, I can write a better one. And I'll tell you that as humans we also have context windows. AI mimics our intelligence. In this scenario you don't know shit about the codebase. You don't know how it's organized, where the code lives, how any of the logic works. You have zero context about the problem. And it's simple: if you don't understand the problem, you can't solve it. Just like that.

Now if you were actually reading the code the AI generates, you'd know where the bug likely is. You do some simple debugging, feed the LLM the relevant places, give it the debugging session results, and tell it the expected behaviour. It solves the problem with way fewer tokens. That means more money saved. If it solves your problem but costs way more than it should, that's not good after all.

So will AI get better?

Let's talk about if AI is actually going to get better — good enough that reading doesn't matter.

First, the cost. You'll say: it solves everything, it'll get cheaper like all technology, right? I don't think AI is getting cheaper. Not with the current market conditions. Anthropic and OpenAI are consistently losing money because they underprice their model serving. Which means it should actually get more expensive. You'll say: but China's models are great. And I agree — long live open-source. But that doesn't really solve the problem. It's cheap now, but it's not going to get cheaper. It will only get more expensive. With each new SOTA, the param count grows. Kimi k2 just dropped with 2.8 TRILLION params. Insane.

And these massive models don't just cost more in API tokens — they need more expensive hardware to run at all. More params means you need GPUs with way more VRAM, which cost a fortune and draw insane amounts of power. Running inference on a 2.8T param model is incredibly inefficient compared to a smaller, fine-tuned model that could do the same job. So even if the API is cheap today, the underlying economics make no sense at scale.

And here is the thing: the companies building these models don't really have an incentive to make the AI generate less code. Less code means less tokens, and less tokens means less money. They are not going to optimize for conciseness when their business model is selling you tokens. So you're stuck paying for bloated, over-engineered solutions.

Second, the quality problem. AI is still generating over-engineered code with bad abstractions and patterns. You will find yourself in a codebase that could have been much smaller, more elegant. And it's not the LLMs' fault. They're trained on human code, and we generate bad code by definition. Good design isn't objective — you can't enforce it with a deterministic feedback loop. There's no reward signal for clean architecture.

And the most active direction in AI research is architectural hacks to increase params and context window — not better foundational models that could actually change how language generation works. I'm a huge believer in the world model architecture Yann LeCun introduced. But we still don't have evidence it will deliver here.

This should make it obvious. AI will let you down at some point. And at that moment, you'll have to figure it out yourself.

Your own slop is better than AI slop

At this point you don't have a fucking clue how anything works. So the velocity you gained getting to market? It essentially backfires. The time you saved? You're paying it back to refactor and understand the project.

So if I'm a bad programmer who writes slop, at least it's my own slop. I understand it. I can operate within it. (If you're a web developer who uses TypeScript, you don't have the right to call anyone's code slop tbh.)