FRONTEND IN THE AGENT ERA
What happened to the codebase, what happened to my skills, and the data I wish I had read before starting.
Some time ago, on a project I already rolled off, I gave an AI coding agent write access to a production codebase. Not a pet project, not a demo for a talk. A real React app with real users and real deadlines.
I would love to tell you it went like in the launch videos. It didn’t. And it also didn’t go like the doom threads promise, where everything burns and we all lose our jobs by Christmas.
What actually happened was weirder than both stories, and more useful. This is the version I would have wanted to read before starting.
Some context first, in case you don’t write frontend every day. Agents stopped being autocomplete a while ago. The current generation reads your repo, runs your tests, fixes its own failures and opens pull requests while you sit in a meeting. In the latest Stack Overflow survey, 84% of developers said they use or plan to use AI tools, and more than half of the professionals use them daily.
So my question was never “are these tools good”. That debate is over, adoption already answered it. My question was more personal than that: what happens to your codebase, to your skills, and to your idea of what you are for, when you let a machine do the typing for months?
The Honeymoon, and the Tuesday It Ended
The first weeks felt like a cheat code. I described a component, something like a filterable table with sticky headers and keyboard navigation, and a terminal agent scaffolded it in minutes, tests included.
Stuff that used to eat entire afternoons became background tasks. Migrating a form flow to another validation library. Hunting a flaky test that only failed on CI. Writing Storybook stories for twenty components nobody had documented in years.
I kicked off the agent, went for a coffee, and came back to a green pull request with a polite description. My velocity, if you measure it in closed tickets, almost doubled that first month.
I told my lead we should buy licenses for the whole team. I posted the classic “this changes everything” message in the team channel. I believed, completely.
And to be fair with my past self, I wasn’t wrong about what these tools can do. I was wrong about the price, because the bill doesn’t show up in any dashboard. It just arrives later.
Mine arrived on a random Tuesday. I opened a file the agent had touched in four different tickets and had the strangest feeling of my career: I did not recognize my own codebase.
We had a modal component in the shared folder. Accessible, tested, themed, used all over the app. It had been there for years doing its one job well.
The agent, across four tickets in three weeks, had built four new modals from scratch. It never imported the shared one. It wrote a full component every time, almost identical, copied and pasted with small changes. Each one worked, and each one was a small lie about how our codebase was organized.
Nothing failed. No test broke and the build stayed green. That is the worst part, because this kind of code is not wrong, it is “almost right”, and almost right makes no noise. It passes review on a Friday at 5pm and waits.
I’m not the only one obsessed with that phrase. In the same Stack Overflow survey, 66% of developers said their biggest frustration is AI solutions that are almost right but not quite, and 45% said debugging AI code takes longer than they expected. When I kept auditing I found more: duplicated fetch logic, three different date formatting helpers, and a catch block silently swallowing errors.
I started reviewing agent PRs with a paranoia I never applied to human teammates. And I went looking for data, because I needed to know if this was happening only to me.
What the Data Says (I Wish I Had Read It Earlier)
It is not only me, not even close. GitClear analyzed 623 million code changes written between 2023 and 2026, and the numbers look exactly like my codebase felt.
Code duplication went up 81%. Copy and paste inside commits went up 41%. Error handling that hides failures instead of managing them grew 47%, so my silent catch block has a lot of company out there.
The number that actually scared me is the refactoring one. Refactoring collapsed from 21% of changed lines in 2022 to less than 4% today. As an industry, we became about five times more likely to paste a near copy of existing code than to reuse or reshape what is already there.
My four modals were not an accident. They were the statistical norm, repeating itself in millions of repos at the same time.
Then there is the productivity data, which has a plot twist. METR ran a randomized study with experienced developers working on repos they knew well, and with AI tools they turned out 19% slower on real tasks. The twist is that they believed they had been around 20% faster.
I recognized myself in that number immediately. Closing tickets feels fast when you are not the one typing.
To be clear, none of these studies say the tools are useless, and that is not my point either. What they say is that the costs are real, that they hide very well, and that almost nobody is measuring them at the moment they are being created.
And still, everybody keeps using this. The DORA 2025 report puts AI adoption around 90% of developers, while Stack Overflow found that only 3% highly trust the output. Almost everyone uses it, almost nobody trusts it, and living inside that contradiction is basically the job now.
The Skills That Started to Fade
Nobody warned me about the atrophy. Around month three I caught myself asking the agent for things I used to do on autopilot. Reshaping an array, a CSS grid detail, a debounced search hook I had written from memory a dozen times.
It was not that I could no longer do them. It was that the part of my brain that did them was training less, and some silent accountant in my head had decided the effort was no longer worth it.
In frontend this decay is extra sneaky, because a lot of our craft lives in details that agents get plausibly right. Spacing, focus management, animation timing. Accessibility attributes that look fine in the diff and are broken in a screen reader.
An agent will hand you a modal that looks correct and traps keyboard focus almost correctly. If your instinct went dull, that “almost” ships to production, and a screen reader user finds it for you.
The scary part is that this atrophy is completely silent. There is no error message for it, no failing test, just a small hesitation where there used to be muscle memory. I mentioned it to other devs and most of them had noticed the same thing, always saying it in the same low voice, like a confession.
But one skill grew a lot while the others faded: judgment. Reading a diff and feeling something is off before being able to explain why. Knowing which tasks to delegate and which ones to keep for myself. Writing down, with precision, how the codebase is supposed to work.
I used to get paid mostly for my hands. Now I get paid mostly for my criteria. The uncomfortable part, and I have no answer for this one, is that my criteria was built during all those years of typing, and I honestly don’t know how someone starting their career today is supposed to build theirs.
What Actually Works for Me Now
I did not quit the agents. I changed the deal, and these five rules took my setup from cool demo to something I trust on a normal Tuesday.
One: the context file is the job now. Every serious agent reads a memory file in the repo, CLAUDE.md, AGENTS.md, whatever flavor you use. Mine documents the shared components, the folder structure, the naming conventions, and a blunt list called “things you must never duplicate”.
Writing that file forced us to make our implicit conventions explicit, and we discovered we disagreed on half of them. The four modals thing never happened again.
Two: small diffs or nothing. I stopped accepting huge pull requests from agents for the same reason I distrust them from humans, nobody really reviews a thousand lines. One ticket, one focused change, reviewed line by line. Boring, and it works.
Three: the agent writes, but it never decides. Architecture, error handling strategy, what depends on what. Those decisions are mine, made before the agent starts, because every time I let it decide implicitly I got code that was confident, plausible, and incompatible with everything around it.
Four: one hour without AI, almost every day. I write some code by hand on purpose, like a pianist playing scales. It sounds silly, and it is the only thing I found that keeps my instinct sharp enough to catch the almost right output.
Five: measure outcomes, not output. My closed tickets went up during the honeymoon and the rework went up too, silently. Now I watch how often code touched by the agent gets modified again within two weeks, the same churn signal GitClear tracks industry wide. When that spikes, my process is broken, not the model.
The Question Nobody Asks Out Loud, and Where I Landed
There is a quieter thing under all this workflow talk, and leaving it out would be lying. Some nights, watching an agent do in nine minutes something that would have taken me two days a few years ago, a cold little question shows up: what exactly am I for?
I stopped pretending the question is stupid. I also stopped letting it spiral, because months of daily evidence point to a concrete answer.
The agent is an incredible producer of code and a terrible owner of it. It does not know the redesign got cancelled in a meeting that never reached any document. It does not know Safari users are a huge part of the revenue, or that the “temporary” feature flag from 2024 is load bearing.
It also holds no grudge against complexity, and holding grudges against complexity is half of engineering. Every line still needs a person whose name shows up in the incident review when things explode at 2am. That person is not, and cannot be, the agent.
The developers that worry me are not the ones refusing AI, and not the ones hugging it either. They are the ones delegating the understanding together with the typing. The typing was never the valuable part, we just needed a machine that types faster than all of us to make that obvious.
So, where did I land? If you write frontend and feel excitement and fear at the same time, that is the correct reading of the situation. The hype and the backlash are both true at once, and that is exactly why this moment feels so confusing.
Use the agents. Refusing them at this point is bad for your career, plain and simple. But use them like a senior manages a brilliant contractor with zero context: clear briefs, small deliverables, hard review, and the important decisions always on your side of the table.
Today I am faster than I was, for real this time, not honeymoon fast. That codebase ended up healthier than it was in month two, even if the scars from that period are still visible in the git history. My work looks less like typing and more like editing, directing and deciding.
And I understand my own value better than I did before a machine forced me to define it. The models got very good at writing code. That was never the same thing as being good at software. That difference is where we work now, and I like it more than the place we left behind.
If your experience with agents was similar, or completely different, please let us know. Especially the failures. We learn more from those.
