This past year I’ve read so much text and so few books

How I used to read

For most of my young life, I identified as someone who loved to learn. I was born in 2004 and grew up in the era of abundant and accessible information via the internet. The pursuit of knowledge was a part of my identity because I thought I enjoyed learning new things.

By 16, I’d never read a book cover to cover. I didn’t think much of it. Books seemed like an inefficient delivery mechanism for information I could get faster elsewhere. I had bad priors about the nature of learning and knowledge, but I didn’t know that yet.

Around the same time, I noticed something uncomfortable: I didn’t actually know anything deeply. I’d spent years consuming what felt like learning, articles, video essays, YouTube tutorials, commentary channels, podcasts, and had very little to show for it. All of that content was optimized for the same thing. Make the viewer feel like they learned something in a short amount of time. That’s a different thing from actually teaching them.

So I forced myself to start reading books. I wanted to stay consistent with the identity I’d built around learning, and it was getting harder to do that without engaging with the format that most serious knowledge still lived in.

One of the first books I picked up was Thinking Fast and Slow by Daniel Kahneman. I’d watched a YouTube video about cognitive biases and wanted to understand the topic properly. So I kept reading.

It’s the kind of book that makes you metacognitive about your own reasoning. You finish it and realize you’ve been operating with a flawed model of your own mind. Taking my time with it, sitting with the ideas, letting them build on each other over hundreds of pages. That’s what made it stick. The information hit differently when it was conveyed in a format optimized for my comprehension rather than my attention span.

I know this because I also read a blog post that summarized the same ideas. I remember how flat it felt. The same concepts, compressed into a few paragraphs, stripped of the context that made them click. The blog post was informative. The book was a paradigm shift.

That experience changed how I approach learning. In 2020, I read over 60 books. I still read at least one a month. Priors adjusted.

How we read now, in the age of LLMs

It’s now 2026. We have entered a new era of accessible, abundant, and now customizable information. This paradigm shift is to my generation, what the invention of the internet was to the one before me.

I’m starting to notice similar patterns in my learning habits as my 16-year-old self did. I often find myself reading LLM-generated answers, mistaking it for true understanding. The same core problem persists. LLM-generated text trades information transfer quality for speed, just like short-form content.

My methods of learning have changed significantly since I was 16. I’ve become a much more effective researcher from years of parsing through papers, documentation, forums, and code from my time as an engineer, as well as the past two years of working with LLMs.

Although I haven’t been reading as many books, I’ve read so, so much text.

One of the biggest advantages of learning from books was that it forced you to navigate through context like a tree, learning dependencies before building towards core ideas and messages. Interacting with LLMs is like navigating the shortest path through a graph of ideas. You still learn the dependencies for understanding the problem, but only the ones that are strictly necessary. You might learn the topic at hand much faster, but the tradeoff is that you don't build domain-specific knowledge.

An Immediate consequence of this is that more fundamental concepts that would otherwise help you navigate a problem space never get learned. Using photography as an example:

Textbook: You learn the exposure triangle from scratch, how aperture changes depth of field, why shutter speed freezes motion, and you learn about ISO. Photos improve incrementally but require a lot of lessons learned.

ChatGPT: You ask how to take good portraits. It says f/1.8, 1/200s, ISO 400. Your portraits look good.

New problem: You’re shooting a waterfall at midday, and the image keeps blowing out. The first-principles learner reaches for an ND filter immediately because they understand the problem is too much light, not wrong settings. The ChatGPT learner has stuck knowledge for this problem space. It seems that learning from an LLM results in less generalizable lessons for the learner, but it’s much faster. How can we determine when to use an LLM and when to seek domain-specific knowledge using something more long-form?

It’s important to understand the nature of LLMs as opposed to traditional modalities of information like books, papers, etc. The nature of these things influences how we interact with them.

When learning for the sake of solving problems, traditional formats of information had to remain exhaustive and generalizable in order to remain useful. Information needed to be presented in a way that could be applied to many different problem spaces, and the reader was tasked with understanding the breadth of that information to hopefully apply it to future problems.

LLMs are interactive, highly effective retrieval machines, and are getting better at reasoning every day. This changes how we interact with them in a few ways.

• LLMs can perform retrieval: we no longer need to retrieve the information relevant to a problem.

• LLMs can reason: we no longer need to compose and transform information to solve most problems.

• LLMs are mappings: we can have information presented to us in any format we wish. Information can be reworded, transformed into a different modality, summarized, or made more verbose.

All three of the above actions would previously be done by the human, but now can be handled by the LLM. This begs the question: are these critical steps of the learning process that we’re omitting when using LLMs? To which the answer is: sometimes. We will attempt to construct a framework from first-principles that will help us determine whether it’s worth learning the entire breadth of a topic or using the LLM approach.

When shortcuts compound

Our first instinct when learning a new topic is to find the most digestible, concise representation of its ideas. This seems reasonable. If you’re going to pick up a challenging book, reading a summary before you start should help you understand the core concepts better.

But when you read a summary instead of the source, you’re outsourcing three things at once. You’re having the information restructured into an easier format. You’re having conclusions drawn for you based on material you didn’t read. And you’re receiving only the subset of information someone else decided was essential.

These are the same three things an LLM does when you ask it a question. It retrieves, it reasons, it reformats. Summaries and LLMs save a lot of work when it comes to reaching a conclusion. They don’t do much for building real understanding.

The natural question is: when does that tradeoff make sense?

The honest answer is that it makes sense when you only care about the output and not the process. That sounds obvious, but it’s less trivial in practice, because when you have the option to skip the process, almost everything starts to look like it’s not worth your time.

Here is an anecdote from a few weeks ago.

I wanted to start learning more about agents, and upon trying to learn the basics, my reasoning went like this:

“It’s been a while since I’ve used a lot of these Python libraries. I forgot a lot of the functions and arguments. I don’t have much time, and I want to get to the core learnings. I’ll just get AI to write this boilerplate for me, and then I’ll understand the code later.”

“Actually, I haven’t ever run an eval before. I understand how they work, but it would take too long to turn this into code. This isn’t the core thing I’m learning. I’ll just get AI to do it.”

“Actually, this isn’t working. Debugging would take too long, and I’m trying to move on to the next topic. It’s probably just some small bug. I’ll get AI to do it.”

“Actually, I’ll just get AI to write this entire eval script, then I’ll work on understanding it later. I understand it anyway.”

“I don’t understand why the AI wrote the code this way. I could start debugging parts of it, but that would take too long. I’ll get AI to explain it to me.”

“…”

Each step felt like a reasonable shortcut. In aggregate, I’d outsourced the entire learning process and had nothing to show for it.

In the past, we didn’t have the option to skip to the result. When doing work, we had to understand the process to move to the next step. We learned because we were forced to. Now we have a choice, and making that choice well is its own skill.

Your human context window

For LLMs, the context window is the amount of text the model can take as input. It’s a hard limit. Beyond it, the model either refuses the input or its performance degrades.

Humans also have a context window. In some ways it’s much shorter than an LLM’s. In other ways, it’s near infinite.

For humans, your context window is your working memory combined with the knowledge you can quickly retrieve from long-term memory. How you fill it determines how you think.

Historically, academics filled their context window through breadth. They learned topics in a dependency-tree fashion: if A is needed to understand B, you first learn A. Someone considered knowledgeable had knowledge across many domains. They had learned C, D, E, and F, even if those topics were unrelated to each other.

As knowledge became more externalized, through writing systems, the printing press, the internet, and now LLMs, this broad acquisition became less necessary. But one thing it always enabled was the ability to draw connections across domains. This is how humans create new knowledge: by composing concepts that weren’t previously related.

Shannon built information theory by noticing similarities between Boolean algebra and thermodynamics. He borrowed the word “entropy” directly from physics because the math was identical. Boltzmann and Boole had never met, but Shannon had read both of their work. That synthesis didn’t come from targeted retrieval. It came from years of broad reading that happened to deposit the right concepts in the same mind.

Load-bearing knowledge

I’m finding that the set of knowledge worth committing to memory is shrinking as LLMs improve at retrieval and reasoning. But the degree to which humans need to understand the domains they operate in, at a structural level, is becoming far more important.

The way I think about this is to distinguish between load-bearing knowledge and ephemeral knowledge.

Load-bearing knowledge is the kind that compounds. It helps you evaluate whether an LLM’s output is correct. It helps you recognize when something is wrong before you can articulate why. It transfers across problems and accumulates over a career.

Ephemeral knowledge is the kind that’s useful once or in a narrow context. It doesn’t compound. It can be retrieved on demand without much cost.

The distinction is easier to see with examples.

In writing, load-bearing knowledge is how to construct an argument, what makes a sentence land, when to cut. Ephemeral knowledge is AP style rules, the submission format for a specific publication, current SEO best practices. A writer who has internalized the load-bearing knowledge can use an LLM to handle the ephemeral stuff and produce good work. A writer who has only the ephemeral knowledge and relies on an LLM for the rest will produce work that looks correct and says nothing.

In photography, load-bearing knowledge is the exposure triangle and the physics of light. Ephemeral knowledge is the specific camera settings for a specific scene. The photographer who understands light can walk up to a waterfall at midday and immediately know why the image is blowing out. The one who learned settings from ChatGPT is stuck.

In software engineering, load-bearing knowledge is how systems fail, how to reason about state, how to debug methodically. Ephemeral knowledge is the exact API for a library you haven’t used in six months. The engineer with load-bearing knowledge reads AI-generated code and spots the race condition. The one without it merges it.

The pattern holds across domains. Load-bearing knowledge is the kind that lets you think. Ephemeral knowledge is the kind that lets you execute. LLMs are getting very good at supplying ephemeral knowledge on demand, which means the human advantage is increasingly concentrated in the load-bearing kind.

A framework for deciding what to learn

This gives us something concrete to work with. When you encounter a new topic or skill, there are two questions worth asking.

The first: is this knowledge load-bearing or ephemeral? If learning this topic would improve your ability to evaluate, judge, or make decisions across a range of future problems, it’s load-bearing. Learn it deeply. If it’s useful for a specific task and unlikely to transfer, it’s ephemeral. Externalize it.

The second: will skipping the process cost me something I can’t recover later? This is the harder question. My agent-learning anecdote is a good example of getting it wrong. Each individual shortcut seemed fine. The cost was invisible in the moment because it was cumulative. I didn’t lose any single piece of knowledge. I lost the connective tissue between pieces, the kind of understanding you can only build by struggling through the process yourself.

A few heuristics that I’ve found useful:

If you’re entering a new domain, default to depth. The early stages of learning a field are where load-bearing knowledge lives. The exposure triangle. The fundamentals of how systems fail. The basic structure of an argument. These are exactly the things an LLM will happily skip for you, and exactly the things you’ll regret not having later.

If you’re operating in a domain you already understand well, externalize freely. An experienced engineer using AI to generate boilerplate is making a good tradeoff. They have the load-bearing knowledge to evaluate the output. A beginner doing the same thing is borrowing against understanding they haven’t built yet.

If you notice yourself rationalizing shortcuts in a chain, stop. That cascading pattern from my anecdote, where each delegation seemed reasonable in isolation, is a reliable signal that you’ve crossed from externalizing ephemeral knowledge to externalizing load-bearing knowledge. The rationalizations are the tell.

Why we still read

When the cost of producing information approaches zero, the ability to decide which information to internalize and which to discard becomes more valuable than the information itself. That decision is a form of judgment, and judgment comes from load-bearing knowledge.

There is something humans can do right now that LLMs cannot. We can synthesize across massive scales of lived experience. We build heuristics from a lifetime of knowledge that let us make accurate decisions quickly, with very little information. We learn novel, abstract concepts from far less data than any model requires. Shannon didn’t build information theory by querying a retrieval system. He built it because decades of broad reading had deposited the right concepts in his mind, and his mind found the connection.

That kind of synthesis is what deep reading builds. Not the memorization of facts, but the slow accumulation of mental models that eventually collide in productive ways. Every word you read has magnitudes greater leverage than a token provided to an LLM. Not because human attention is scarce, but because the human mind does something with that input that no model yet can: it connects it to everything else you’ve ever learned, and holds that connection for a lifetime.

More from me: https://saadkhalid.com