The Agentic Coding Paradox: From Impostor Syndrome to the Height of My Power

I don't really write code by hand anymore and I'm building things further and further outside anything I'd honestly call my wheelhouse. Much to my surprise instead of that making me feel like more of an impostor than I used to, it has done the opposite. I am, right now, at the height of my power. And I know it.

I like saying that. I like that it sounds like something a cartoon villain would say right before the space laser starts firing. But I really do mean it. I can sit down and build almost anything I can think of. I know it and it has stopped surprising me when it works. But by everything I used to believe about my own craft, I have not earned the right to feel this way at all.

Where the Impostor Syndrome Came From

Let's start with my self-perceived deficiencies, because they are the foundation on which this realization is built.

I am not a formally trained programmer. I have a psychology degree not a CS degree. So I don't have the "DSA" fundamentals that most of my peers have. As a result I can't do LeetCode or the algorithm interview with the whiteboard-a-red-black-tree ritual. I don't know that stuff and at this point it's almost a badge of honor that I don't. I have never once, in a real job, needed to hand-roll a sorting algorithm. When I need one, I call the one that ships in the platform, written by somebody far smarter than me. That's not a hole in my knowledge, it's how all real software gets built. Every serious program you've ever used is mostly other people's code. The interview dance that pretends otherwise is measuring the wrong thing, and some (most?) of the people conducting those interviews know it. But knowing it's a garbage measure never fully killed the feeling for me.

I'm self-taught, and self-teaching comes with its own low hum of impostor syndrome: you can be completely sure the gate is fake and still feel "less than" in a room full of people who walked through it. I made my peace with it by throwing out everyone else's scoreboard. A degree and fluency in algorithms are an external standard. Clear it and people assume you're an expert on sight, before you've ever shipped a line of code for them. I was never going to clear that one, so I built my own, and I made it brutal. I don't let myself claim I'm proficient (let alone an expert) at something until I've put in years of real work in it, until I've been burned enough times that nothing about it surprises me anymore. I sidestepped the respect a credential grants for free, and what I got instead was worth more: certainty. When I clear my own bar, I know it cold. Tell me I can't do something and I'll prove you wrong. That standard is the whole reason the impostor syndrome never actually won.

What I Thought Would Happen

But now let's throw coding with AI into the mix. As I've previously written, I was originally very opposed to AI in all forms, especially for coding. Long story short, I saw using AI to write code as weakness or a crutch. In time, I came to embrace it as the force multiplier it actually is. But by the same token (see what I did there?) I honestly would have expected it to intensify my impostor syndrome for the very reason that it takes away the years of grinding inside a stack before I feel that I can build something real in it. By the only rule I've ever trusted, I've got no business calling myself proficient at anything I'm building today. But in fact it did the opposite.

The Proof Is a System I Never Would Have Built

Heavy Headlines is my heavy metal news app. For a long time it was, honestly, a fancy RSS reader. It read a bunch of metal blogs and showed you the posts.

It is not that anymore. I built a publishing pipeline behind it. It ingests press releases from record label and PR feeds and emails, and an LLM rewrites them into original articles under the Heavy Headlines banner, so I can run my own content with a cleaner, less intrusive ad experience instead of just pointing at everyone else's. The other half ingests the metal blog world and calls out to an LLM to classify every piece of content into genres so I can actually give people a targeted feed instead of an undifferentiated firehose.

That's the high-level description. The reality underneath is a three-stage orchestrated pipeline where nothing publishes until the whole batch has been grouped, so a cluster of coverage about one story shows up in the app fully formed instead of dribbling in one card at a time. There's a rewrite-and-classify step where the model gathers evidence through a research loop before it commits, governed by a formal state machine with a contract written in plain English, and the rule in that repo is that if the code and the English sentence ever disagree, the sentence wins and the code is the bug. There's a dedup layer, grouping under a database advisory lock so two runs can't fight, a publish phase completely decoupled from grouping so any crash costs one cycle and never a half-published mess, and it self-heals on the next tick. There's an eval harness and a suite of integration tests that actually exercise the state machine, not the "can I parse hardcoded JSON into an object" garbage that passes for test coverage most places. There's actually quite a bit more to it than this but for the sake of brevity I won't go into more detail.

And this publishing pipeline isn't the only system like this I've built in the past year. It's just the one worth walking you through here because it's the one that looks like a job. It's the kind of thing a client would actually hire someone to build, in a stack I had no business touching a year ago. I would never have considered building that before. Partly because the LLM piece literally wasn't possible yet. But mostly because it's built in Node and TypeScript, and my backend comfort zone is the LAMP stack, which nobody's building sophisticated systems in anymore (or maybe just the cool kids aren't). If somehow I had been pitched that as a paid project, I would have looked at that spec, in that stack, and passed. Now I would take that on as paid work tomorrow and tell you, to your face, that I can do it for any product and not just mine.

Confidence, Not Bravado

I've asked myself whether "I can build anything" is confidence or bravado, because I'd mock a vibe coder for saying it. The difference, I think, is where the feeling comes from. Bravado is confidence borrowed from the tool. The AI does something impressive and you feel powerful by association. What I feel comes from the part of the job the AI never touches. Hand me a problem and I can see the whole system: where it'll break and where it won't hold up under real load. I could do that a decade ago too.

What I had wrong was believing that was the soft, secondary skill, the stuff wrapped around the real prize, which I thought was deep mastery of a specific language/stack. I had it completely backwards. The systems sense was the prize the whole time, and the language is the part I can now hand to an LLM. I never saw it clearly because I'd never built something so complex in a stack I hadn't worked in for years. My recent projects have put me into that exact situation over and over, and every time, the thing that carried me was the architecture in my head, not the syntax under my fingers.

Hand that same AI to someone with a year of experience and they'll get a demo that looks great in the meeting and explodes the first time it meets real users. Either way the tool (AI) is the same. What I bring to it is thirty years of watching systems break. It's what tells me what to demand from the thing, and when it's quietly lying to me. The AI can't supply that part. For thirty years I mistook the pain for the value. Learning a language the old way hurt: months of syntax and quirks and undocumented sharp edges. And because it hurt, I assumed the hurt was the point, that the suffering was where the expertise lived. It wasn't. The suffering was just the cover charge for getting into a new language, and the AI covers it for me now.

Syntax is converging. Strip out a few outliers like Python (whose syntax I still can't stand) and modern languages are close enough that moving between them is a translation problem, not a re-education. The specific keywords, whatever framework is trending this month: none of it is where the value lives. The value is knowing how to assemble those pieces into something correct, safe, fast, and secure. That's systems engineering, and you only get it one way: shipping things for decades and watching enough of them break to learn why.

Nobody teaches that in a four-year program and you can't install it with a Claude skill.

The Height of My Power

So no, I'm not an expert in backend TypeScript development the way I'm an expert in iOS, but I've stopped needing to be. For as long as I've done this, I refused to call myself proficient at anything until I'd put in the years, grinding inside a stack until nothing about it could surprise me. I don't hold myself to that anymore. Not because I lowered the bar, but because I can clear it another way now: thirty years of systems experience is enough to take a problem into a stack I've never lived in, put an LLM on the code, and come out the other side with something genuinely good.

And that is the paradox. I assumed that leaning on AI to write the code would make me feel like less of an engineer. Instead it showed me I'd spent decades underrating myself, filing my best skill under "obvious" and my most replaceable one under "hard-won expertise." I have more range now than I've ever had, and it's a pretty incredible feeling. The LLM writes code in whatever language the job needs. But deciding what to build, how to build it, and whether it's any good is still entirely on me.