Learning After the Fact

For most of the history of building things — software, in particular — learning came first and building came second. You studied a language, understood its syntax and idioms, absorbed the mental model of how a computer executes instructions, and only then were you equipped to build. This wasn't just tradition; it was necessity. The cost of getting something wrong was high, feedback loops were slow, and there was no shortcut around understanding. You had to be sure before you started, because you couldn't easily undo a bad foundation or explore ten different directions in an afternoon.

This sequencing had a quiet but significant consequence: it shrank the scope of what any one person could attempt. If learning had to precede building, and learning takes time and effort, then the size of what you could build was capped by how much you'd already learned. Beginners built toy programs. Only after years of study did someone attempt something ambitious. The gate wasn't creativity or ambition — it was the prerequisite of knowledge. And because iteration was expensive, both learning and building demanded a kind of upfront certainty. You picked a language carefully. You planned an architecture carefully. Mistakes were costly enough that caution was rational.

AI changes the order of operations. Increasingly, people build first and learn the underlying mechanics as they go — prompting a model to generate a working piece of software, then asking why it works, what a particular function does, or why one approach was chosen over another. The output exists before the understanding does, and understanding follows as a kind of reverse-engineering of something already in hand. This isn't a lesser way of learning; it's arguably a more natural one.

Consider how children actually learn. A toddler doesn't study the physics of balance before attempting to walk, and a kid doesn't learn grammar rules before speaking a first sentence. They act, fail, adjust, and only much later — if ever — learn the formal theory behind what they've already been doing intuitively for years. Doing comes first; the abstraction is retrofitted, and often optional.

This is also, if we're honest, how most people actually learned computers. Almost nobody read a manual cover to cover before touching a keyboard. People clicked around, broke things, Googled the error message, and built a working mental model through contact with a system rather than through a preceding curriculum. The formal explanation, when it came, made sense of something already partially understood through use.

What AI has done is make this build-first mode viable for far more complex things than clicking around a desktop. You can now generate a working web app, a data pipeline, or a small model without first mastering the language it's written in — and then, because it already works, use that working artefact as the object of study. The scope of what you can attempt is no longer bounded by what you've already learned, because the AI can meet you at the ambition you're reaching for and let learning catch up afterward.

The deeper shift is in what iteration costs. When learning and building were coupled, and iteration was expensive, both had to be preceded by certainty — you needed to be sure before you began. When building is cheap and fast, certainty can come after the fact, distilled from something that already exists rather than assembled in advance of it. That's not a loss of rigour. It's rigour arriving in a different order — and it's arguably closer to how learning has always worked for anything we picked up by doing rather than by studying first.