LLM Architecture: Lessons from Karpathy

Stop thinking of LLMs as "thinking" machines and start seeing them as massive autocomplete engines. I finally got around to Karpathy's deep dive into how ChatGPT-style models actually work, and it clears up a lot of the mystery regarding why certain models fail at simple tasks while crushing complex coding benchmarks.

As someone who leans on Claude Code for the heavy lifting—Jira tickets, unit tests, and architecture—and uses ChatGPT for research, I wanted to know what actually changes when a "new version" drops.

Here is the technical breakdown of the core concepts:

Base Models vs. Instruct Models

The most important distinction is that a base model is just a stochastic text generator. It has no concept of being an "assistant." It's trained on the internet to predict the next token, period. To make it "chat-able," it goes through post-training (SFT/RLHF) where it's fed human conversation examples. This is why a base model might respond to a question with more questions (because it thinks it's completing a FAQ list) rather than actually answering you.

The Training Grind

The process is essentially a massive game of reducing "loss."

• The Goal: Lower the loss number.
• The Process: The network makes a prediction, calculates the error (loss), and recomputes parameters to be slightly more accurate next time.
• Hardware: This is why GPUs are non-negotiable. CPUs can't handle the massive parallel matrix multiplication required for these neural networks. While Karpathy focuses on GPUs, TPUs are obviously the other heavy hitter for tensor operations.

What "New Model" Actually Means

When OpenAI or DeepSeek announce a release, they are usually talking about two different things:

• Open Weights: You get the forward-pass code and the parameters (a file with billions of numbers).
• Closed Source: You get an API endpoint or a UI. You have zero visibility into the weights or the specific architecture.

One weird takeaway: LLMs are fundamentally bad at spelling or counting (like the "how many r's in strawberry" meme) because they process tokens, not individual characters. They aren't "looking" at the letters; they are predicting the next token based on probability.

If you're looking for a real-world AI workflow, understanding this helps you realize when to stop fighting a model's inherent architecture and start adjusting your prompt engineering.