I’ve been thinking about how we actually learn difficult things—not the neat, chapter-by-chapter progression that textbooks suggest, but the real, messy way it happens.

For years, I tried to teach myself to code. Starts and stops. Tutorials abandoned halfway through. Concepts that seemed to make sense in isolation but refused to connect to anything else. I’d pick it up, get frustrated, quit. Come back months later, try a different approach, get stuck somewhere new, quit again.

It felt like failure. But looking back, something was happening that I couldn’t see at the time.

The night sky

Imagine you’re looking at a dark sky, overcast and washed out by light pollution. Every so often, a single star peeks through the clouds. You see it alone—bright, but isolated. What does it connect to? Where does it belong? You have no idea.

Then another star appears, somewhere else entirely. No apparent relationship to the first.

Over time, more stars emerge. They’re scattered, seemingly random. But gradually—and this is the part that matters—you start to notice that some of them are closer together than others. Clusters begin to form. You start to see shapes.

Eventually, if you keep looking, entire constellations come into focus. The stars were always there, in relationship to each other. You just couldn’t see the pattern until you had enough points of light.

This is how learning actually works

I call this chaos comprehension: the understanding that emerges from accumulating ideas before you can see how they connect.

When you’re learning something complex—a new codebase, a programming language, a domain you’ve never worked in—you’re collecting stars. Each concept, each piece of syntax, each pattern you encounter is a point of light. In the moment, it might feel disconnected. Useless, even. You don’t know what it relates to because you don’t have enough other stars to see the constellation yet.

This is the part where most people quit. The chaos feels like confusion. The lack of clear progress feels like failure.

But it isn’t failure. It’s accumulation.

The nonlinear truth

Learning isn’t linear. It’s not a steady climb from ignorance to mastery. It’s more like this: you wander through fog, picking up glowing stones and stuffing them in your pockets. You don’t know why. You just know they seem important. Then one day, you pull them out and realize they fit together. They were pieces of the same map all along.

Every time I quit learning to code and came back, I wasn’t starting over. I was adding stars. The loops and variables I half-learned years ago were still there, waiting for the later concepts that would give them meaning. The frustration I felt wasn’t evidence that I couldn’t learn—it was evidence that I was in the chaos phase, before comprehension.

For the learners and the joiners

If you’re in the middle of learning something hard, I want you to know: the confusion is the process. The scattered, disconnected feeling isn’t a sign that you’re doing it wrong. It’s a sign that you’re collecting stars.

And if you’ve just joined a new team, staring at a codebase that makes no sense, wondering how anyone could possibly hold all of this in their head—same thing. You’re in the fog, picking up glowing stones. Trust that the constellation is forming, even if you can’t see it yet.

Keep collecting. Keep looking up.

The stars will connect.