Seven months ago, I lost the job I’d held for more than six years. Days later, my mother had a stroke. It was a stretch where the things I’d assumed were solid, a career, a sense of being useful, the health of the people I love, turned out to be a lot less fixed than I’d been telling myself.
The timing had a particular sting to it. The industry I’d spent eight years in, shipping React, React Native, and Node.js to a couple million users, was busy deciding that engineers like me were becoming optional, and the reason had a name I’d come to resent: AI.
I was a critic, and a confident one. I had the whole case memorized: it hallucinates, it’s a stochastic parrot, it’s a plagiarism machine with good PR, it can’t actually reason. I’d say these things to friends and family with the certainty of a man who had never once sat down and built with the thing he was dismissing. Which was the problem. I was criticizing from the cheap seats.
I’ve always thought there are two kinds of critics, the ones who’ve done the reading and the ones who haven’t, and only one of them is worth your time. I’ve always tried to be the first kind. Somewhere in the middle of that bad year I caught myself being the second: loud about something I understood mostly from headlines and other people’s hot takes. If I was going to write AI off, the least I could do was write it off from the inside, after actually building something with it.
So I started reading. I skipped the framework tutorials and went straight for the mechanics: how a transformer actually moves information around, why a temperature setting changes what comes out the other end, what an embedding is really storing.
I built small things and watched them break in oddly specific ways, and patching them back together was more satisfying than I wanted it to be. The resentment slowly started to fade. Once I actually had my hands in it, what I found was a problem nobody has fully cracked yet, which is the thing that got me into engineering to begin with.
Before I wrote software for a living, I taught. A few years of it, in two languages. Working with these models kept dragging me back to that, because the mechanics were the same.
You can’t order one of these models around; you set things up so the answer you want is the easy one for it to give. It will be confidently, cheerfully wrong, and a good part of the job is building for the moments it’s wrong. The same request works or fails depending on how you phrase it. You never get certainty back, you get a spread of likely outcomes, and the craft is in nudging that spread in your favor. Every one of those was a Tuesday for me once. A room of thirty students, no two of them handing you the same thing twice, all of them responding to how you set up the room far more than to anything you demanded of them. I’d spent years getting good at pulling reliable work out of minds that are unreliable by design, and that turns out to be a huge fraction of what working with an LLM actually is. The thing I’d been afraid of was a problem I’d already spent ten years building a gut instinct for.
Once I saw it that way, the rest came easily. I went looking for the course I wanted to take and couldn’t find it; most of what’s out there is shallow courses that walk you through basic examples that don’t go very deep. So I built it myself, and then I did the thing every teacher does on reflex: I wrote it all down for the next person. That became AI Deep Dives, an open series where I put each piece of AI engineering back together from scratch, no frameworks, with the tradeoffs and the failure modes left out in the open where you can actually see them.
Then I built things that had to work. The first few were toys, just to get the shape of the problem into my hands. After those came three that are now hosted and running. One of them, askrepo, answers plain-English questions about a codebase and backs every answer with the exact file and line it came from; building it was how I learned to ship an LLM product end to end. Another reads the day’s news against an editorial rubric I wrote and sends out a calm good-news digest every night, running entirely on a GPU in my apartment, which is how I learned to run and measure a model I host myself. The third one pokes holes in the “spec kit” workflow every company is scrambling to adopt right now, using gated phases and a checker that catches missing coverage on its own; it’s my attempt at getting a pack of AI agents to build software without quietly cutting corners. One taught me to build, one to run, one to keep the whole thing honest.
There’s no tidy lesson here where losing my job turns out to have been a blessing. It wasn’t. But it did back me into doing something I’d been too comfortable to do on my own, which was to sit down with the thing I was afraid of and learn it well enough to have earned an opinion about it. The opinion I’ve landed on is that it’s the most interesting engineering problem I’ve touched in years, and that the eight years I spent shipping to real users are exactly what make me useful at the boring, load-bearing half of it: the cost, the caching, the evaluation, the dozen unglamorous things wrapped around the model call that decide whether it holds up once real people are using it.
I’m still writing the series, still building in the open, and looking for the next place to do this for real. If it sounds like the jump you’re making too, I’d genuinely like to hear from you.