Relearning Computers in the Age of AI

I want to start with a small confession.

I’ve been working on dotlottie-rs, the open source Rust runtime behind our animation players at LottieFiles, for about two years. A few months ago, I hit a wall. Not a hard bug. A wall. The kind where you slowly realize the problem isn’t the code in front of you. The problem is that you don’t really understand the machine your code runs on.

I’ve been writing JavaScript for years. I’m not a junior. But sitting there, staring at errors about linking and symbols and things I had never had to think about, I felt something uncomfortable. I didn’t actually know how computers work. I just knew how the browser works. And the browser, it turns out, is a giant program that hides the real machine from you. For years I had been living inside that comfort without even noticing.

That made me a little sad. But it also made me curious.

A pattern that keeps repeating

In the 70s and 80s, programmers wrote assembly. You couldn’t avoid the machine. To write a program you had to understand the CPU, the memory, all of it, from first principles. Then compilers arrived and hid that complexity behind nice languages like C, C++, Java, and later JavaScript. Suddenly the same program could run more or less the same on Intel, on RISC-V, on Windows, on Linux, on macOS. We moved one level up the abstraction, and we stopped needing to know what was underneath.

Now I think history is repeating itself. Programming is slowly becoming prompting an AI to write the high-level code we used to write by hand. One day there may be a generation of engineers who don’t write code in any language at all. They’ll write in plain English, and the real skill will be shaping good prompts.

I’m not here to complain about that. Every abstraction takes something away and gives something back. Assembly programmers lost touch with the machine and gained the power to build bigger things, faster. We’ll lose something too, and gain something else. That’s fine. I won’t argue about it.

But here’s the part I do want to argue about

When producing code becomes cheap, the valuable skill flips.

It’s no longer about typing the code. It’s about judging it. If an AI can write a thousand lines in a second, the bottleneck becomes the human who has to read those lines and ask: is this correct? Is it fast enough? Is it actually built well, or does it just look right?

You can’t answer those questions in plain English. You answer them by knowing what a line of code really does when it reaches the machine. Without that, you’re not an engineer anymore. You’re just one more agent babysitting another agent, hoping for the best.

And low-level knowledge never really went away. It just moved to where it matters most: games, graphics, high-frequency trading, distributed systems. Anywhere latency and throughput decide whether the software wins or dies, someone still has to squeeze every drop out of the machine. The abstraction made us feel like the hardware doesn’t matter. It always mattered. We just stopped looking.

So I decided to relearn, from the bottom

I went back and learned the things the browser had been hiding from me. The compilation process. What linking actually is. The ELF format, symbols, syscalls. CPU architecture, pipelining, branch prediction, SIMD. How IO really works at the system level. Things I had used a thousand times without ever seeing.

I picked C to do it. Not Rust. Rust is a beautiful language, but it’s a brutal place to start learning systems programming. C is simpler and closer to the metal, and honestly it made me understand and appreciate why C++ and Rust even exist. You have to feel the problem before you can appreciate the solution.

I don’t have much time. I’m a father and a full-time developer, and I can’t relearn the entire computer. So I’m only chasing the lessons with the highest return, the ones that actually change how I think.

That’s what this blog is for. I want to learn in public. Writing something down is how I find out whether I really understood it, or only thought I did. So I’ll share each piece as I learn it: to keep myself honest, to look back one day and see how far I’ve come, and maybe to help someone walking the same road.

This is where I’m starting. Let’s see where it goes.