AI Has Made Me Faster, But Has It Made Me Worse?
AI has made me faster. A lot faster. But recently, I caught myself doing something that made me wonder whether that speed is coming at a cost.
I’ve been a front-end developer for roughly 20 years, and these days I use AI to write most of my code.
I’m still thinking through architecture, making technical decisions, reviewing what gets generated, and deciding what actually belongs in the codebase.
But I’m doing far less of the actual coding than I used to.
And every once in a while, I notice something that makes me wonder…
“Am I becoming a better developer, or am I just getting better at using AI?”
When I Realized Something Had Changed
Recently, I was working on some animations in an Angular project.
I was using AI to help with the implementation, and it generated some CSS using a property that I knew was relatively new.
My immediate reaction was…
“Is this actually supported by all the browsers we need to support?”
A few years ago, I probably would have known the answer already.
I probably would have opened caniuse.com, checked the support table, and moved on.
But I would’ve also been the one intentionally reaching for it to build out the solution myself.
This time, I just asked the AI.
It told me the browser support was good, gave me some statistics, and I accepted the answer.
That was the moment where I stopped and thought…
“Wait… am I getting worse at this?”
Not because the AI gave me a bad answer. It didn’t.
The uncomfortable part was that I didn’t really feel the need to verify it myself.
I’m Learning Different Things Now
Web development has always required us to keep learning.
When I started, my focus was heavily on HTML and CSS. Then JavaScript became a bigger part of my work. Then frameworks like Angular became central to what I was doing.
There was always something new to understand.
That part hasn’t changed.
What has changed is where a lot of my attention goes.
I still care about browser APIs, Angular features, CSS, performance, accessibility, and all the normal things that come with front-end development.
But now I’m also spending a lot of time trying to understand AI tools.
Which models are better for which tasks?
How should I structure a prompt?
How much context should I give it?
Should I let it make a larger change or break the problem into smaller pieces?
When should I trust it, and when should I push back?
Those are development skills now too, whether we like it or not.
And because AI is changing so quickly, there’s a lot to keep up with.
Am I Actually Getting Worse?
I think this is where the question gets more complicated.
If you asked me whether I’m becoming better at manually writing code, the answer is probably no.
I’m doing less of it.
So I’m sure there are things I could once recall immediately that I now might have to look up (or ask AI).
But I don’t think that automatically means I’m becoming worse as a developer.
Because at the same time, I’m getting better at other parts of development.
I’m spending more time thinking about the shape of the solution before any code gets written.
I’m reviewing implementations more critically.
I’m deciding what should change, what shouldn’t change, and whether the code AI generated actually solves the problem in the right way.
And sometimes AI shows me something I genuinely wouldn’t have thought of myself.
It might find an edge case I missed.
It might use an approach that is cleaner than the one I had in mind.
It might introduce me to an API or technique I haven’t used before.
When that happens, I’m still learning.
Just in a different way.
AI as a Pair Programmer
That’s probably the best way I can describe how I use AI today.
It feels a lot like pair programming.
Except instead of sitting next to another developer and taking turns writing code, I’m describing the problem, reviewing the implementation, correcting mistakes, and refining the solution.
Sometimes the AI gets it wrong.
Sometimes it misunderstands what I’m asking.
Sometimes it generates something way more complicated than it needs to be.
And I have to recognize that and fix it.
Other times, it produces something better than what I would have written myself.
That doesn’t make me feel like I’ve lost control.
I still decide what gets used.
I still decide how much of the problem I want AI to handle.
Sometimes I ask it for a tiny change.
Sometimes I let it build out a larger feature.
Sometimes I reject the whole thing and start over.
The tool is powerful, but I’m still responsible for the result.
This Is Probably Very Different for Junior Developers
I also think experience changes this conversation quite a bit.
I’ve spent two decades writing code, debugging bad solutions, making architectural mistakes, refactoring things I thought were good ideas at the time, and learning what tends to go wrong.
That experience gives me a pretty good filter for evaluating what AI produces.
Someone at the beginning of their career doesn’t have that yet.
And I think that’s what makes this moment especially difficult for junior developers.
They need to build that experience.
They need to struggle through problems.
They need to write things that don’t work and understand why they don’t work.
They need to learn what good code looks like.
But at the same time, they’re entering an industry where they’re probably going to be expected to use AI.
The bigger challenge is figuring out how junior developers can use AI without skipping the learning that eventually gives them good judgment.
I’m not sure we’ve figured that out yet.
Maybe the Job Is Just Changing
For a long time, being a good developer meant knowing how to translate a solution into code.
That still matters today.
But I’m not convinced it will matter in exactly the same way forever.
If AI keeps improving, I wouldn’t be surprised if we spend less time thinking about the mechanics of writing code and more time thinking about the system around it.
What should we build?
How should it behave?
How should the pieces fit together?
What are the tradeoffs?
What could go wrong?
Is the implementation actually correct?
Is it maintainable?
Does it solve the right problem?
Those questions aren’t going away just because AI can generate code.
If anything, they may become more important.
So yes, in some ways I may be losing some manual coding sharpness.
But I’m also gaining new skills, learning from AI-generated solutions, and spending more time on parts of development that I think are becoming increasingly important.
That doesn’t feel like becoming worse as a developer.
It feels like becoming a different kind of developer.
And maybe that’s the real question.
Are we actually getting worse at development, or are the skills that define a good developer simply changing?
