Your AI Isn’t Thinking. It’s Dreaming. Here’s the Difference.
I have a rule. When Andrej Karpathy drops something, I clear my schedule.
Ex-OpenAI founding member. Ex-Tesla AI Director. Currently building Eureka Labs, an AI-native school. The man has forgotten more about neural networks than most people will ever learn, and he still takes the time to explain things like you’re a reasonably smart human who just wants to understand what’s actually happening under the hood.
His 3.5-hour “Deep Dive into LLMs” video is arguably the best public resource on how large language models actually work. Not how they’re marketed. Not what the benchmarks say. How they actually work.
I’ve been building AI systems for years. I still watched the whole thing. Twice, in parts. This video is making sense as the weeks have passed and so here I am, writing about it.
Here’s what I took away, filtered through the lens of someone who’s watched these systems behave unexpectedly in production more times than I’d like to admit.
First, The Mental Model Everyone Gets Wrong
Most people think of an LLM as a search engine with a personality. Or a very fast Google. Or a database that talks back.
All of those are wrong.
The more accurate mental model: an LLM is a distilled dream of the internet.
The pretraining process essentially downloads and compresses a significant fraction of human written knowledge. Trillions of tokens. Dozens of terabytes. FineWeb, the dataset Karpathy references, is 44TB of processed text. The model learns to predict what comes next in that ocean of text, over and over, billions of times, until it has internalized something like the statistical structure of how humans write, reason, and explain things.
It doesn’t store facts the way a database does. It stores patterns. The difference matters enormously when something goes wrong.
The base model, before any fine-tuning, is genuinely strange. Karpathy demos this in the video with Llama 3.1 raw. It doesn’t answer questions. It continues text. Ask it “what is the capital of France?” and it might respond with three more geography quiz questions. Because that’s what comes next, statistically, in a document that looks like a quiz.
This is the model’s natural state: completion machine. Everything after that is shaping it into something usable.
The “Tokens to Think” Idea Changed How I Prompt
This was the section that made me pause the video and sit with it for a minute.
Karpathy introduces the idea simply: models need tokens to think. The more reasoning steps you allow, the better the output. Not because the model is lazy. Because the computation literally happens in the token generation process. Each token produced is a step of reasoning.
This explains something I’d noticed empirically but couldn’t articulate cleanly: if you ask a model to answer immediately, you get a shallower answer. If you ask it to think step by step, or better yet, if you’re using a reasoning model that generates internal chain-of-thought, you get qualitatively different output.
It’s not a prompt trick. It’s a function of how the architecture works.
The analogy that landed for me: imagine you’re asked a hard math problem, and someone insists you answer out loud the instant you hear it, no pause, no scratch paper. You might get lucky. But you’ll get it right far more often if you’re allowed to talk through your reasoning first. The tokens are the scratch paper.
The practical implication for anyone building on top of LLMs: cheap inference is not always good inference. There’s a tradeoff between speed and depth that most production systems treat as a cost-optimization problem, when it’s actually a quality-of-reasoning problem.
Jagged Intelligence Is the Bug Report Nobody Filed
“Jagged intelligence” is Karpathy’s phrase for something every LLM practitioner has experienced but struggled to name cleanly.
The model writes a brilliant legal memo. Then fails to count the number of ‘r’s in the word “strawberry.”
The model explains quantum entanglement coherently. Then gets confused by a simple logic puzzle a ten-year-old would solve.
This isn’t inconsistency in the human sense, where you’re tired or distracted. It’s structural. The model is extraordinarily capable in regions of the training distribution that were well-represented, and surprisingly brittle in regions that weren’t.
The internet has a lot of legal writing. It doesn’t have a lot of character-counting exercises. The model learned what it saw.
My personal take on this: jagged intelligence is the biggest underappreciated risk in enterprise AI deployments. Teams see the model perform brilliantly on their demo tasks, deploy it, and then hit an edge case that seems trivially simple to a human but represents a gap in the model’s training distribution. The failure is jarring precisely because everything around it was working so well.
The mitigation isn’t to distrust the model universally. It’s to know where the edges of the cliff are, which requires actually testing at those edges rather than demoing on the smooth terrain.
Hallucinations: The Problem Is the Name
The word “hallucination” implies the model is having some kind of breakdown. A glitch. An anomaly.
It’s not. It’s the model doing exactly what it was trained to do: generating the most plausible continuation of the text, given everything it knows. When it doesn’t know, it doesn’t stop. It generates a confident, fluent, structurally correct continuation anyway, because that’s the task.
Karpathy puts this more precisely: the model was never trained on “I don’t know” as a response. It learned from the internet. The internet is not full of people confidently saying they don’t know things.
The mitigations are real and increasingly practical:
Retrieval-augmented generation: give the model the actual document before asking questions about it, so it’s completing text that contains the answer
Tool use: let the model invoke search, calculators, or code execution rather than generating facts from memory
Model self-interrogation: newer techniques train the model to recognize its own uncertainty and flag it
But the honest practitioner view is this: hallucination is a calibration problem, not a knowledge problem. The model knows a lot. The issue is that it doesn’t know what it doesn’t know, and it doesn’t slow down when it hits that boundary.
Which, now that I think about it, describes about 40% of the engineers I’ve worked with over the years. So maybe we shouldn’t be too hard on the models.
The RL Section Is Where Things Get Genuinely Strange
The video’s most fascinating section, for me, is the transition from supervised fine-tuning to reinforcement learning, and specifically the discussion of DeepSeek-R1.
Here’s the rough arc: early LLM assistants were trained by showing the model ideal human responses and getting it to imitate them. This works surprisingly well. RLHF then layers human preference signals on top. But reinforcement learning, particularly the version used in reasoning models, does something different and weirder.
It lets the model discover strategies through trial and error on verifiable problems. Math, code, logic, anything with a checkable answer. The model generates candidates, gets rewarded for correct ones, and over time develops internal reasoning strategies that nobody explicitly programmed.
DeepSeek-R1’s famous “aha moment” during training, where the model spontaneously started double-checking its own work mid-reasoning, was not designed in. It emerged from reward signals.
That’s the part I find both exciting and worth thinking carefully about. We’re increasingly building systems whose reasoning strategies are discovered, not designed. The outputs are increasingly capable. The interpretability of the process that produced them is... not keeping pace.
The AlphaGo comparison Karpathy draws is apt. Move 37 was not in any human game database. It was discovered through self-play. The model found it because the reward function gave it room to. LLM reasoning models are doing something analogous in language space.
My Honest Take: Watch the Video Anyway
I’ve tried to distill the ideas that shifted something for me, as a practitioner, not recite the syllabus.
But Karpathy’s teaching style has a quality that’s genuinely rare in this space: he explains complex things without making you feel like you need a PhD to follow along, and without dumbing it down so much that the insight gets lost. That balance is hard. He consistently gets it right.
The three things I’d tell anyone building with LLMs to internalize from this video:
Tokens are computation. Give the model room to reason, especially on hard problems. Don’t optimize for speed at the expense of depth unless you’ve actually measured the tradeoff.
Jagged intelligence is real and underweighted in deployment risk assessments. Brilliant at the demo, brittle at the edges. Test the edges. Deliberately.
The base model and the assistant model are different animals. One dreams. One assists. Knowing which mode you’re actually in, and why, changes how you design prompts, systems, and evaluations.
The video is 3.5 hours. Worth every minute. But also, now you have the cheat sheet.
-Hardik
The video: Andrej Karpathy, “Deep Dive into LLMs like ChatGPT” — freely available on YouTube. Link: youtube.com/watch?v=7xTGNNLPyMI. Educational use licensed freely by Karpathy.
buymeacoffee.com/HardikGoel