AI makes me a better engineer and a worse one, at the same time, and I don't think that's a contradiction I get to resolve. This page is the honest version of that — not the reassuring one that belongs on AI Stance, the odd one, filed here because it's still evidence of how I think, just about myself instead of a system.
The muscle that stops firing
There is a specific, small motion your hand used to make. You needed to loop over a list and pull out the third field, and your fingers just did it — for (User u : users) { String email = u.getEmail(); ... } — before you'd finished deciding to write it. That motion is a callus, built by writing the same fifteen lines of boilerplate a thousand times until your hands stopped asking your brain for permission.
AI does that loop faster and more reliably than you do. So you stop doing it. So the callus goes soft.
This isn't really about typing speed - I'm still a lousy typist, look at your fingers most of the time. It's about the loop itself: write, get it wrong in a small way, notice, fix, internalize. That loop is where the calluses come from, and it's also where a huge amount of quiet, unglamorous understanding gets built — the kind you can't point to as a specific fact you learned, because it was never a fact. It was a rep.
And most days, none of that matters at all.
The muscle that gets stronger
Here's the part that isn't a simple complaint. The reps you're not doing anymore are the cheap ones. What's left is judgment — is this the right chunk of the problem to hand off, does this generated approach actually fit the codebase's existing shape, is this abstraction going to be a liability in eight months. That's a different skill, and it gets more exercise now, not less, because you're not spending your attention on syntax.
I generate the same nine-layer backend template for every new entity in this codebase — domain, DTOs, entity, mapper, repository, two service layers, controller, changeset (see REST API Architecture for the real thing). I could still write every layer by hand. But the fact that I don't, most days, means the hours I do spend are spent on the layer that actually varies: what does this entity mean, what should be validated, where does this diverge from the last nine entities that looked almost the same. The boilerplate reps I'm not doing bought back the reps that matter.
So both things are true in the same sentence. The skill that erodes and the skill that sharpens are not the same skill, and the second one is arguably the one you were being paid for the whole time.
Where this actually bites
It doesn't bite while you're shipping. It bites in exactly two rooms.
Explaining the code to a client. They ask why a field is nullable, or why this endpoint validates in the service layer instead of the controller, and the honest answer used to be muscle memory made me do it that way, and here's why the muscle memory is right. If AI wrote that layer, the muscle memory isn't yours — you have to reconstruct the reasoning after the fact instead of reciting it, and reconstructed reasoning sounds different in a room. Slower. More careful, if you're doing it right. Thinner, if you're not.
A technical interview. Nobody hands you a model in the room. You get a whiteboard, a blank editor, and a stranger watching your hands not move the way they used to. I've forgotten how to write a recursive function or balance a B-tree from scratch — despite having almost never needed either, unassisted, in twenty-five years of actual jobs. This is the one place the erosion is measured directly, with nothing to offset it — which is exactly why it's worth practicing the un-assisted version on purpose, the way a pilot still hand-flies approaches on a clear day even though the autopilot is better at it. It's also, I'll admit, a reason I think the format rewards people who are good at live tests more than it rewards people who are good at the job — an unpopular opinion, and probably a self-serving one, but I don't think it's wrong.
What I actually do about it
Not abstinence. Abstinence is its own kind of unseriousness — refusing a tool that measurably works, to preserve a skill for its own sake, is a worse trade than the one it's trying to avoid.
- I still write the hard 20% by hand, on purpose, often after the model has already offered an answer — specifically so the callus that matters (design judgment, not boilerplate) doesn't go soft either.
- I explain generated code before it ships, not after a client asks. If I can't say why a line is the way it is, per AI Stance, it doesn't go in — which forces the reconstruction to happen on my schedule, not in front of someone billing me for the meeting.
- I don't let the easy reps disappear entirely. Some boilerplate I still type by hand, occasionally, the way you'd still do long division sometimes even with a calculator in your pocket — not because it's efficient, but because the day you actually need it unassisted shouldn't be the first time in two years you've done it.
The honest summary
Using AI well doesn't make you a better version of the engineer you were. It makes you a different engineer — weaker in a specific, narrow way, and stronger in a broader one, and the trade is worth it right up until the moment someone asks you to prove it live. Anyone telling you it's a clean win in every room hasn't been in the room where it isn't.