Last Sunday I built an invoice tracker for a friend who runs a small shop. Nothing clever. I described what I wanted, let the AI do the rest, and about forty minutes later it was running. Routes, the database schema, login, even the fiddly error handling I used to be a bit smug about. Worked on the first try.
I should have just felt good about it, and mostly I did. But there was another feeling underneath that I couldn't shake for the rest of the evening. That thing had done, in forty minutes, the stuff I spent most of my twenties learning how to do.
Not "the robots are taking our jobs." Something more specific, and more personal than that. I looked at ten years of work I was proud of and realised I couldn't tell anymore how much of it had ever really been mine.
Quick disclaimer before anyone heads for the comments: I use AI to write code every day now and I'm not giving that up. This isn't that kind of post. But that Sunday made me ask something I'd genuinely never had a reason to ask, because until recently you couldn't take the job apart to look at it. Of everything I call "my skills," which one was actually mine?
Turns out "being a developer" was two jobs, not one
For about ten years I never had to separate them, because you couldn't get good at the second one without grinding through the first.
Call the first one production. Making the thing exist. The language, whatever framework everyone used that year, the APIs you eventually know by heart, wiring one piece to another until an idea turns into something that runs. This is the part bootcamps teach and interviews test. It's what my CV was, basically top to bottom. And it's the part AI is now flat-out better at than me. Which, honestly, fine. It was never the hard part. It just took years to get quick at.
The second one I don't really have a clean word for. Judgment, maybe. It's looking at something that works and knowing, somehow, that it's wrong. Not "does it run" but "is this going to quietly lose someone money in three weeks." Knowing which confident, tidy, all-tests-passing answer you shouldn't trust. Nobody ever put this on my CV. There was no course for it, no cert, no exam. It felt less like a skill and more like a hunch you can't explain to a junior no matter how you try.
AI took the first job completely. And because the two were always tangled together, it feels like it took "being a developer." It didn't. It took production, which was most of what I trained, and it hasn't laid a finger on the judgment, because the judgment was never in the code. It was in me.
So a decade gave me one skill, not ten
This is the part that actually kept me up.
Every skill I'd have bragged about, anything I'd have listed if you asked why I was worth hiring, was production. Recall. The framework, the right flag, the pattern, the clean CRUD. All of it gone in an afternoon, and done well. Ten years of stacking it up, handed back to everyone for free in a single product update.
Ten years didn't build me ten skills. It built one. The other nineteen I was renting from a supplier who just took them back.
The one thing that didn't get taken was the judgment. And here's what gets me: I'd never once counted it as a skill. It felt like taste. It felt like something I was, not something I'd learned. Which is exactly why no course sells it and no interview tests it. You can't really teach the "no."
Everything I was proud of, AI does in an afternoon now. The one thing it can't do was the only thing that was ever mine.
The bug that made it obvious
Let me get specific, because I paid for this one.
Years back I shipped a write path that told the client "got it" before it had actually saved the row. The code was clean. Genuinely clean. It read like someone careful wrote it, because I did. Everything from those ten years was in there: idiomatic, properly typed, tests around it, error handling buttoned up. By every measure I'd have used at the time, some of the best code I'd written.
Then, one ordinary day, a retry landed at exactly the wrong moment. The "got it" went out, the save never happened, and a paying customer got locked out of their own account with nothing in the logs to say they'd ever been there. Ack before persist.
Here's what stuck with me. None of my ten years caught that. The syntax was perfect. The framework was used correctly. The tests were green. Every one of those rented skills did its job. The only thing that would have saved that customer was the skill I'd never even named: the reflex to look at working code and not trust it, to stop and ask "okay, what happens if this gets retried," to say no to my own clean diff.
The code scored an A on everything AI now beats me at. It failed on the one thing that was mine.
I'm not mourning the other nineteen, to be clear
I'm not about to start hand-writing CRUD to prove a decade meant something. For production, AI is a better developer than I am at 5pm on a Friday, and leaning on it is just correct. Take the scaffold. Take the fix. Ship faster. That part isn't the loss.
The trap is quieter than that. When a tool does all nineteen of your rented skills, the easy conclusion is that you've been made pointless, when the truth is closer to the opposite. It cleared away everything that was never really the point and left you standing on the one thing that was. And if you can't tell which skill was the real one, you'll spend the next ten years defending the nineteen it already took, instead of getting better at the one it can't.
So, a few things I actually do now.
I rewrite the CV around the "no." Not "expert in [framework]" — the machine is an expert in that too. The line worth writing is the judgment call: the bug I didn't trust when it looked fine, the design I killed, the confident diff I overruled and turned out to be right about.
I keep the muscle warm on purpose. Before I accept anything the AI hands me, I make myself say one sentence out loud: "here's how this loses money." I'm wrong most of the time. Doesn't matter. The rep is the distrust, not the catch.
And I stopped measuring myself in output. Lines, tickets, features shipped. Those are the machine's numbers now, and racing it on them is just volunteering to be a slower model. The only score that's still mine is the disasters I saw coming that it didn't.
And this is more or less why I build the way I do
One level up, same logic.
I work on an agent platform, and the whole industry right now wants to cheer for the thing that produces. Look how much it ships. But a thing that produces is just doing the skill that stopped being scarce. Endless production is endless output that nobody has actually vouched for. The scarce thing was never the code. It was someone looking at the code and saying no, which is the one skill a decade left me with.
So I don't let the thing that writes the code be the thing that signs off on it. There's an author that produces, all nineteen rented skills, cheap and endless. There's a separate skeptic whose entire job is to distrust the output and try to break it, the "no" given its own seat. And there's a human who owns the call, because that was always the only part that was ours. Author, skeptic, human. That's the whole shape of xenition, and it's the same thing the locked-out customer taught me. Producing the thing was always cheap. Knowing it was wrong was the job.
Ten years didn't make me a great producer. AI just proved I never had to be. What it made me, slowly and expensively and one disaster at a time, is someone who can look at something that works and tell it's wrong. That's the one real skill, and it's the only one AI handed back.
Honest question for the comments: of everything you know, which single skill would still be yours if AI could do all the rest tomorrow? The one that isn't syntax, isn't a framework, isn't just recall. 👇
Top comments (1)
Ack-before-persist is the perfect example, because the judgment was invisible in review too: the code read clean, tests were green, and the lie lived between the API promise and the durable state. Two habits that make judgment auditable: (1) turn durability contracts into tests — one test that fails whenever a response returns before commit, so "acked before saved" can never pass CI twice; (2) when inheriting AI-generated code, review the failure story instead of the happy path: what happens when the retry lands at exactly the wrong moment? If the answer needs a paragraph, that\u2019s the part you can\u2019t rent from a supplier. The Sunday invoice app is fine — it\u2019s the three-weeks-later silent bug that ten years were actually for.