McDonald’s is objectively delicious. Kids don’t clamor for quarter pounders, fries, and shakes because they’re cheap or convenient. They demand it because it’s the end result of decades of A/B testing to create the perfect combination of fat, salt, carbs, and animal in order to drive the greatest possible sales over the widest audience for the lowest possible price. If you are a human on this planet (and certainly if you’re reading this blog), you have eaten McDonald’s. You can probably identify the smell of McDonald’s fries with eyes closed. It’s ubiquitous.

Tens of millions of people eat McDonald’s every day. It’s cheap, convenient, and sometimes there isn’t much of a choice. In the US alone, 19 million people are estimated to live in food deserts – usually impoverished neighborhoods where there are convenience stores and fast food restaurants, but no grocery stores. The cost in time, effort, and money to go across town to a grocery store, buy fresh produce, and cook is prohibitive, so eating fast food daily can be a rational choice. Many people live this way, but you probably don’t. Why not?

It isn’t such a mystery. McDonald’s is unhealthy. It’s fattening. It clogs your arteries. They use the cheapest, lowest quality ingredients. It’s bad for the environment. And on and on. You don’t eat McDonald’s constantly because you don’t have to, it’s almost always a bad choice, and – though it tastes good – you’re an adult, and able to make adult decisions about what you eat. If and when you do, it’s because there was a specific situation in which it made sense. That one time at a highway rest stop when you just needed something fast and easy. That time when the kids were yelling and you were out of spoons and you just needed something fast and easy. That other time when you only had 10 minutes between appointments and you just needed something fast and easy. We’ve all been there.

You kiss your mom with that mouth?

If you’re in tech and you’ve been awake at any time over the last week, you’ll know that the Claude codebase was accidentally leaked. Whether this was due to engineer error (as Anthropic has claimed) or AI security failure (as some have suggested) is something we’ll never know, but now that we can see what the code looks like, we can see what we’re being sold.

According to Anthropic, approximately 90% of Claude Code is being written by Claude Code. These are the most experienced, most knowledgeable, most expert users of Claude Code. This is the pinnacle of usage. This is what we should be aspiring to. And when you look at the codebase, you can see what that means. Go ahead. Take a look. Read an analysis (this one’s funny and opinionated, but I’m sure you can find a Very Serious Analysis if you look).

[This analysis] answered some of my questions about what people think the future will be if everyone codes like this. It seems to be: instead of thinking about constraints of any kind or “what is the most efficient way to do Y or the most readable way to do Z?” answer the question, “what is the most brute force way to perform X if I pretend that there are no resource constraints and nothing needs to make sense as long as I see some sort of test passing? Just ship it with spaghetti code. – Timnit Gebru

It’s hard to even know where to start. Similar functionality included a dozen times. Variable names that are themselves prompts. Security theater married to appeals to the LLM to please please don’t do this thing, unless the user pinky promises that they have a Very Good Reason. Unbelievably poor performance due to ridiculous implementation “choices”. Let’s just accept that it’s bad. Very bad. Hilariously, nightmarishly, terrifyingly bad. And that this is what the industry wants you to believe is the future of coding.

So what?

Of course, you already knew that. You knew that the code being generated was poor quality. You didn’t care because you were focused on the outputs, and as long as your tests passed you didn’t care what the code looked like. Does the CEO know how the code works? Does the VPE? The manager? The PM? As long as you can create a test harness and use cases and guardrails that validate that the outputs are correct, why should you care what the code looks like?

Put another way, what’s the point of software engineering fundamentals? Why should we care about big-O time, modularization, code re-use, idempotence, re-entrance, race conditions, performance, byzantine fault tolerance, thread safety, artifact size, well-defined APIs, and security? Was it all a big con? A joke Donald Knuth told that got out of hand? Was big-O just a hazing ritual that ultimately didn’t matter?¹

These concepts aren’t just for making it easier for humans to build and maintain code. They aren’t just for enforcing certain contracts of behavior. They’re for reducing the surface area of the infinity of possible latent bugs and future problems that the code might contain. Of course humans write bugs too, and best practices and software fundamentals are an important way in which we protect ourselves. If you take your hand off the wheel, you need to accept that you’re creating an agglomeration of impenetrable code that passes the tests you thought to create, and has no guarantee of doing anything else.

There are times when a Big Mac can make sense. When you’re building a throwaway prototype, demo, or proof of concept, creating intermediate non-shipping artifacts, internal tools, or CSS (well, you do care about the CSS deliverable size). Cory Doctorow once pointed out that ML is great for applications in which an accurate result has high value, and an inaccurate result isn’t that big a deal (advertising being a great example). But what about when you need accurate, consistent, secure, fault-tolerant results?

Compilers need to be fast, deterministic, and absolutely accurate – something YACC has been able to do since the 80s. A compiler that fails to generate accurate, optimized machine code 100% of the time is a curiosity, a demo, not a usable product.

3D games need a highly performant, accurate 3D rasterizer. Many need realistic physics engines. These need to run at 30-60Hz in order to provide smooth visuals. Video game developers typically spend a lot of time optimizing their code to improve performance, and game designers spend a lot of time playing with and tweaking their games to make them feel more natural. You can’t get to either of these through probabilistic code generation and test coverage.

E-commerce code needs to be idempotent and re-entrant. You have to charge a credit card and ship an order exactly one time – not zero times, not twice – and you need to think very carefully about how to guarantee that that happens.

You don’t have to be paranoid about OpenClaw deleting your root directory, or accessing your email and taking over your bank account, to be concerned about AI security (I mean, yes, you should be worried about those things if you’re using OpenClaw, but they aren’t the only things). Security is an insanely difficult topic, and you only have to read a couple of CVEs to understand how easy it is for small mistakes to compound and result in privilege escalation, confused deputies, or code injection. Would you trust an app like Signal if the code were an impenetrable morass of code that only black hats took the time to understand? Would you entrust your company’s SSO – privileged access to all of your accounts – to a product that was 100% AI generated?²

sqlite has an extraordinarily complex set of automated tests – a perfect test case for AI-generated code. It should be possible to have AI generate code against these tests, and in fact, someone did exactly that. The result was code that worked, but was about 20,000 times slower. Because there was a working version built by humans, it was possible to understand what went wrong. But in the Big Mac coding era, you don’t get to inspect the code. You can only tell the agent to try harder.

I expect that LLMs will continue to improve, and that the ridiculously well-funded companies pushing them, the tech press, and AI influencers will continue to breathlessly announce all the ways you can create self-organizing fleets of agents to AI harder than you could have ever imagined AIing. The problem is that this approach is fundamentally incompatible with building performant, secure, accurate code. You can’t Gas Town your way to software engineering fundamentals. You can’t get there from here. Using GenAI solves exactly one problem – speed – at the expense of all other considerations. Climbing a tree won’t get you closer to walking on the moon, and living exclusively on a diet of Big Macs won’t help you improve your health – no matter how convenient, cost-effective, or fast it is.

If your product doesn’t require deterministic accuracy; if performance isn’t a priority; if security isn’t a concern; if you don’t need idempotence or thread safety, if you don’t care about cloud resource cost, and you don’t care about the size of your deliverables, then GenAI can probably get you what you need. I tend to believe that most projects aren’t like that, but if yours is, congratulations, you can build it faster. If not, then you’re going to McDonald’s and expecting fine French dining.

---

1. I know that there are a lot of people – mostly people who don’t understand it – who think that big-O is in fact a meaningless hazing ritual used as a gatekeeping question at companies that have unfair interview practices. But I have personally seen a O(n) comparator instantly take down a top-100 website (estimated cost for the half hour of lost revenue before we could do an emergency failover: $50k). I’ve also seen O(n²) React code slow page load to a crawl. If you don’t understand why big-O matters, you’re like a carpenter who thinks hammers are just a fad and that using your screwdriver to hammer nails should be good enough for anyone. ↩︎
2. There’s a scene in the movie Erin Brockovich in which she’s at a conference room table with the defending executives, and she reveals that the water in their glasses is from the land they’ve denied polluting. There’s a palpable pause in which everyone recoils, while trying hard to pretend that they aren’t. Are you willing to drink the water to prove the point? Take existential risks to own the AI haters? ↩︎