I like a good magic trick. Always have. But I've always been just as drawn to the reveal—to understanding what's actually happening behind the curtain.
Behind every piece of magic is something concrete. A technique, a bit of science, a rational explanation. But until you see it, until you recognize the mechanism, it looks like pure magic. Something beyond comprehension. Something that suspends your disbelief.
There's a tendency to do the same thing with technology. When something new shows up that we don't fully understand, it feels like magic. And the problem with that is we start attributing magic—and intelligence—to things that are increasingly woven into how we live and work.
A pattern I keep seeing
I've been building for the web for a long time. Long enough to watch the same pattern play out over and over. Something new arrives. The industry races to adopt it. The tooling churns. People feel overwhelmed, convinced they're falling behind.
I wrote about this back in 2015, when the JavaScript ecosystem was exploding with new frameworks every few months and the anxiety about "keeping up" was everywhere. My advice then was simple: when in doubt, focus on the core.
Learn CSS over any sort of tooling around CSS. Learn JavaScript instead of React or Angular or whatever other library seems hot at the moment. Learn HTML. Learn how browsers work. Learn how connections are established over the network.
A year later, I wrote about the way we chase tools instead of understanding the problems those tools solve. The most valuable skill isn't mastering the framework of the moment. It's understanding the fundamentals well enough to know whether that framework is even the right choice.
And in 2018, when a Twitter poll showed that most developers didn't understand how the CSS cascade works, I argued that these "unessential" fundamentals are actually essential. I have never once regretted taking the time to learn more about the tools I use. Never. I always pick something up that makes me better at the work.
The throughline across a decade of thinking about this: abstractions come and go, the fundamentals do not.
Same pattern, bigger stakes
Right now, we're in the middle of the biggest version of this pattern I've ever seen. Large language models have exploded across the industry. Companies are making massive bets to shove AI into everything—sales, support, coding, design, strategy. If there's a task that could be made more productive, someone somewhere is trying to make AI do it.
But there's a staggering gap between how much we're using AI and how well we understand it. The term "artificial intelligence" itself doesn't help—it lends a mystique the technology hasn't earned. We're moving so fast that we've skipped past understanding what it is we're actually using.
The result: AI gets crammed into everything. The quality varies wildly depending on how it's applied. And most people have no framework for understanding why. When it works, it feels like magic. When it doesn't, it feels like the magic is broken. Neither reaction is useful.
The thing I've noticed is this: understanding how something operates is an important part of not being owned by it. That argument has been made about code, and it applies here too. When you understand at least the basic mechanics, you're less likely to blindly trust whatever it puts in front of you.
Partly for me, partly for you
I'll be honest: I'm building this partly for myself. Like everyone else, I've felt at the mercy of this whirlwind. Technology is moving faster than any of us can keep up with, and that's not a comfortable place to be—especially for something I'm using every day to do my work. If I'm going to rely on something that heavily, I want to understand what it's doing and why.
But this is also for anyone else who feels the same way. I'm concerned about how fast we've adopted AI as an industry and as a society. It feels Wild West because it is Wild West. We aren't taking the time to understand what we're using or what the implications are. We're just racing forward, iterating on a moving target, weaving it into business-critical infrastructure and the technologies we depend on to live our lives.
I don't think slowing down is going to happen. But understanding the fundamentals—that's something maybe a resource like this can help with.
Deliberate tradeoffs
When I was doing performance consulting, I talked a lot about deliberate tradeoffs. It's fine to make a tradeoff—as long as it's a conscious one. You can choose to load that heavy JavaScript bundle, but you should know what it costs your users and decide that the benefit is worth it.
The same principle applies here. It's fine to use AI—it can be genuinely useful. But you should understand what it's actually doing, where its outputs come from, why it gets things wrong, and what you're giving up when you rely on it. Those are deliberate tradeoffs. What we're doing right now, as an industry, is mostly not that. It's mostly just racing blindly towards a finish line that hasn't been defined.
What this site is for
The goal here is straightforward: demystify AI. Not hype it. Not dismiss it. Just make it clearer what this so-called intelligence actually is—how it works, why it does what it does, where it falls short, and what tradeoffs come with using it.
Every concept has something you can play with. Every explanation tries to make the abstract concrete. The format is interactive because I believe you understand things better when you can poke at them—adjust a parameter, see a consequence, build an intuition.
This isn't comprehensive by an stretch of the imagination, but it's a starting point. Learning the fundamentals has never failed me, and I don't expect it to fail here either.