For the past year or so, I've relied pretty heavily on AI coding assistants for most of my day-to-day work.
At any given time, I usually have Codex, Claude Code, and GitHub Copilot all running different tasks across different projects. One agent is refactoring a component. Another is checking an API route. Another is trying its best to understand some ancient corner of a codebase that I probably wrote at 1:00 AM three years ago.
And honestly, it still feels kind of magical.
You type a three or four sentence prompt, hit enter, and a few minutes later a webpage appears with more or less the correct logic. Maybe not perfect. Maybe not production-ready. Maybe with one import that absolutely does not exist.
But still.
That page would normally take me a few hours to build by hand. So even when the result needs review, cleanup, or a stern talking-to, it’s hard to deny how impressive the whole thing is.
I don’t think AI coding assistants are perfect, and I definitely don’t see a future where senior engineers are obsolete. In my experience, a meaningful percentage of agent responses still come back wrong, incomplete, over-engineered, or confidently pointed in the wrong direction.
But the bigger issue I’ve been noticing lately is not just correctness.
It’s speed.
Agents are getting slower.
They are still faster than me on plenty of tasks. But they are no longer always fast in the way they felt fast a year ago.
Bigger context windows, more memory, larger models, tool calls, higher token costs, and extended reasoning modes all collide to increase latency. What used to take two or three minutes can now take ten, fifteen, or twenty.
And most of us are strangely okay with that.
Because at least we didn’t have to type it.
That has been my big realization. I don’t hate coding. I’ve been doing it for over 20 years and I still enjoy solving hard problems. But long stretches of repetitive boilerplate have started to feel less like “engineering” and more like transcription work.
There is a massive difference between the mental energy required to solve a complex problem and the physical energy required to set up yet another REST API.
I’ll gladly spend hours reviewing specs, thinking through edge cases, and designing a workflow that actually makes sense for the business. But ask me to build another landing page, wire up another form, or type out another set of nearly identical CRUD endpoints, and suddenly that task finds its way to the bottom of my to-do list.
Most of my workday is not spent wrestling with novel algorithms. It’s spent writing boilerplate, setting up basic API endpoints, adjusting UI components, moving data around, and connecting pieces that I already understand.
That is the friction I want to avoid.
When I use an agent, I’m not outsourcing the thinking. I’m outsourcing the manual labor of getting the thinking onto the screen.
I still architect the solution. I still decide what needs to exist. I still review the diff, test the behavior, and clean up the weird choices. I just don’t want to get carpal tunnel typing the same patterns over and over again.
But lately, I’ve noticed something stranger.
I now reach for an agent even when I know I could make the change myself faster.
I’ll need to update a React component. Maybe it’s a copy change. Maybe it’s a small design tweak. Maybe it’s one prop, one class name, or one conditional render.
I know exactly where the file is. I know exactly what needs to change. I could jump into VS Code and fix it in two minutes.
But instead, I find myself opening Codex.
Codex can find the file eventually. It can take my vague command and usually produce a workable result. And even if it gets it wrong the first time, I can steer it back into place.
Which leads to the weird bargain we’re all quietly making:
We are perfectly willing to wait 15 minutes for an agent to write a block of code just so we don’t have to spend 10 minutes typing it ourselves.
And the stranger part is that this often feels rational.
Because it’s not really about laziness. It’s about cognitive load.
When you are actively typing code, your brain is fully engaged. You are thinking about syntax, imports, brackets, naming, formatting, state, props, types, errors, and the ten other tiny details required to make software behave.
Your brain is on.
But when the agent is running, your brain gets to step away. You can alt-tab. You can check Hacker News. You can grab coffee. You can pretend you are “letting the machine work” while you drift into some other little pocket of the internet.
Reviewing a 50-line diff feels cheaper than writing those 50 lines from scratch, even when the clock says the manual route would have been faster.
We have collectively decided that editing is more comfortable than writing.
And honestly, I get it.
Editing gives you something to react to. Writing forces you to create the thing from nothing. Even when the thing is simple, there is still a tiny activation cost. The empty file, the blank function, the first import, the first decision.
The agent removes that little moment of resistance.
But this trade-off comes with a subtle cost.
By outsourcing the trivial stuff, we are slowly replacing flow state with micro-breaks.
We are trading the momentum of active, hands-on coding for the passive observation of a terminal spinner.
That sounds harmless until you realize what actually happens during those waits. You don’t just sit there patiently, maintaining full context like some kind of enlightened monk of productivity.
You wander.
You check messages. You read a headline. You open a tab. You skim a thread. You remember another task. You forget what you were doing.
By the time the agent finishes, the code may be ready, but your mental map is gone.
It’s the classic XKCD “my code is compiling” excuse, reborn for the LLM era.
Via: XKCD
The old joke was that compiling gave developers permission to stop working for a minute.
The new version is pretty much the same.
Except now it doesn’t just happen when the code is compiling. It happens when the code is being written for us. And that is a very different kind of interruption.
A 10-minute block of focused typing keeps you inside the problem. You may be doing manual work, but you are still moving through the codebase. You are touching the files, seeing the structure, remembering the decisions, and keeping the feature alive in your head.
A 15-minute agent run is an open invitation to context-switch.
And once you switch context, getting back is not free.
That may be the real hidden cost of slow AI coding agents. Not the wait itself, but the mental reset required after the wait.
The productivity loss is not just:
“Codex took 15 minutes.”
It’s:
“Codex took 15 minutes, during which I mentally left the feature, checked three unrelated things, forgot one edge case, and now need five more minutes to remember what I was doing.”
At that point, the math starts to get weird.
Maybe the solution is not to abandon agents. That would be silly. They are too useful. They are incredible for the genuine slogs: tedious migrations, repetitive boilerplate, large refactors, test scaffolding, schema changes, and all the annoying glue work that no one dreams of doing when they first learn to code.
But we probably need to get better at drawing the line.
If a change takes less than five minutes by hand, maybe we should just write the damn code.
If you know exactly where the file is, exactly what needs to change, and exactly how to do it, opening a prompt window may not be saving you time. It may just be letting you avoid the small discomfort of starting.
And that distinction matters.
Because saving effort is good. Avoiding friction is good. Protecting mental energy is good.
But constantly stepping away from the code has a cost too.
The more we use agents for every tiny task, the more we train ourselves out of staying with the work. We stop building momentum. We stop following the thread. We stop living inside the codebase and start managing a queue of little outsourced requests.
That may be fine for some kinds of work. But for deep engineering, there is still value in keeping your hands on the keyboard and your head inside the problem.
So the next time you find yourself staring at an empty prompt box, ready to describe a simple React prop change or a minor CSS tweak, pause for a second.
Ask yourself what you are actually trying to save.
Are you saving cognitive energy?
Are you avoiding tedious boilerplate?
Are you delegating a boring but well-defined task?
Or are you just avoiding the physical act of typing?
If it’s the latter, close the prompt window, open the file, and make the change.
AI agents are incredible force multipliers, but only when they help us move faster without pulling us out of the work.
The tool is supposed to remove friction.
If the spinner becomes the workday, we’ve just invented a very expensive loading screen.