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.
I was using AI to help with the implementation, and it generated some CSS using a property that I knew was relatively new.
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.
It told me the browser support was good, gave me some statistics, and I accepted the answer.
The uncomfortable part was that I didn’t really feel the need to verify it myself.
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.
I still care about browser APIs, Angular features, CSS, performance, accessibility, and all the normal things that come with front-end development.
If you asked me whether I’m becoming better at manually writing code, the answer is probably no.
So I’m sure there are things I could once recall immediately that I now might have to look up (or ask AI).
I’m spending more time thinking about the shape of the solution before any code gets written.
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.
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.
Other times, it produces something better than what I would have written myself.
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.