I have been frustrated with Claude Code lately.
Not because it is bad.
Actually, the problem is almost the opposite.
I am using it so much that I keep hitting the 5-hour usage limit.
Usually, this isn’t a problem for me.
When I work on one project at a time, I rarely reach the limit. I can code for hours without thinking about it.
But my current situation is different.
At my full-time job, I am currently working on two fairly large projects at the same time.
One is a migration from Webflow to Astro + Sanity.
The other is a completely new web app.
For both projects, I use Claude Code because my company provides Claude for employees.
And now I can hit the 5-hour limit within roughly an hour of working.
At first, I thought:
“Why am I using so much Claude?”
Then I realized something.
Maybe the problem isn’t just the limit.
Maybe it is the way I code now.
from code.claude.com
Before AI, I actually wrote the code
Before AI coding agents became part of my workflow, I coded more or less like everyone else.
I opened the documentation.
I searched Stack Overflow.
I looked for examples.
I watched YouTube videos when I needed to understand something.
I searched GitHub repositories.
Then I wrote the code myself.
If something didn’t work, I debugged it.
If I didn’t understand something, I researched it.
The actual implementation was my responsibility.
AI changed that completely.
Today, I probably write only around 2–5% of the code manually.
The other 95–98% is written by AI.
And I don’t mean I use AI for autocomplete.
I mean I can give Claude Code a task and let it handle almost the entire implementation.
For example, instead of manually building a feature, I can describe what I want.
Claude reads the project.
It looks at the existing code.
It creates the files.
It implements the feature.
It runs tests.
It finds problems.
It fixes them.
I review the result and tell it what to change.
Then it does another iteration.
I use a more structured version of this in my workflow for turning AI conversations into plans, GitHub Issues, and isolated worktrees.
This is incredibly productive.
But there is a side effect I didn’t think about.
I am becoming less hands-on with my own code
When I wrote the code myself, I naturally understood more of it.
I knew why a particular function existed.
I knew how different parts of the application connected.
I remembered the decisions I made while implementing something.
When something broke, I was already familiar with the code because I had written it.
With AI doing almost all of the implementation, that relationship changes.
I can still understand the code.
But I don’t always understand it as deeply.
Sometimes I look at an implementation and think:
“Okay, this works. But I probably wouldn’t have written it this way.”
And when something breaks, my first reaction is increasingly:
“Claude, can you debug this?”
Instead of immediately opening the code and figuring it out myself.
That is a strange feeling.
This shift has even changed what I want from a code editor, because I spend more time reviewing and iterating than typing code myself.
The application is still my responsibility.
But I am not necessarily the person writing most of it anymore.
AI didn’t eliminate research either
One thing I still do manually is research.
This is especially important with frameworks and libraries that change quickly.
AI doesn’t always know the latest version of a library.
Sometimes its knowledge is outdated.
Sometimes it gives me an answer that was correct six months ago but is no longer correct today.
So I still open the official documentation.
I check the current version.
I read the migration guide.
I verify the API.
And sometimes I take that documentation and give it back to the AI.
“Here. This is the current documentation. Use this.”
So even though I am almost completely AI-driven for implementation, I still need to keep doing some of the traditional developer work myself.
And honestly, I think that’s important.
AI can write the code.
But I still need to know whether the code is based on the right information.
Then there is the 5-hour limit
This brings me back to my original frustration.
When I only work on one project, I rarely hit the limit.
But now I have two large projects running in parallel.
And because AI is doing almost all of the implementation, I can move through tasks very quickly.
That means more prompts.
More code generation.
More iterations.
More debugging.
More context to manage, which is why I started saving useful session state instead of carrying entire AI conversations forward.
More tool calls.
More AI usage.
And suddenly, a limit that I almost never noticed before becomes a serious constraint.
It creates an interesting situation.
Before AI, one of my biggest limitations was how fast I could write code.
Now, sometimes my limitation is how fast I can consume AI.
The better AI gets at implementing things, the more tempting it becomes to let it handle everything.
And the more you let it handle everything, the more dependent your workflow becomes on having enough AI usage available.
The hidden cost of fully coding with AI
I still think AI coding is incredible.
I don’t want to go back to manually writing every piece of code.
It would be hard to justify that after experiencing how much faster I can move with an agent.
But I also don’t think “let AI write 100% of the code” is free.
There is a hidden cost.
A 2025 Microsoft Research survey of 319 knowledge workers found that higher confidence in generative AI was associated with less critical thinking, while AI shifted effort toward verification and task stewardship. The research was not specific to programming, but it reflects the tension I feel in my own work.
You can become less familiar with your own implementation.
You can become more dependent on AI for debugging.
You can spend less time thinking through the implementation yourself.
And eventually, you may start treating the AI as the actual programmer and yourself as the person giving instructions.
That doesn’t necessarily make you a worse developer.
But it does change what being a developer feels like.
I think this is one of the most interesting things about AI coding that we don’t talk about enough.
The question is no longer just:
“Can AI write the code?”
It clearly can.
The more interesting question is:
“What happens to the developer when AI writes almost all of the code?”
I’m still figuring that out myself.
For now, I am happy to let AI do most of the implementation.
But I also want to make sure I don’t completely lose the ability — or the habit — to understand and write the code myself.
Because there is a difference between not needing to write code and not knowing how the code works.
And I don’t want those two things to become the same.
If you enjoyed this post and want to support more writing like it, you can support my work.