are wonderful at shortly implementing a whole lot of code. Nonetheless, should you’ve ever labored so much with coding brokers, you’ll discover they begin struggling after some time. Perhaps you’ve spent a couple of days writing code with AI. The whole lot went completely and quick, and you then begin noticing the duties take longer, and the AI is making an increasing number of errors.
This can be a clear signal that you want to begin refactoring the code. I consider that refactoring your codebase goes to be commonplace after you’ve applied a whole lot of code with coding brokers. Coding brokers do make errors and don’t write good code. Additionally, should you don’t observe finest practices in present code, the AI will proceed not following finest practices within the new code it generates. Thus, you want to constantly refactor your repositories.
On this article, I talk about how you can know when you want to refactor your code, what the indicators are, and how you can do it successfully utilizing Claude Code or different coding brokers.
Why refactor your code?
Initially, I all the time prefer to cowl why it’s best to care concerning the subject I’m discussing. Refactoring the code seems like a boring process, and in actuality, it was a really boring process that you simply needed to do every so often. Only a few years in the past, people needed to manually go into the code repository to search for what wanted to be refactored and begin refactoring the code.
This might usually occur as soon as, simply after a whole lot of implementations within the code, as a result of code naturally drifts away from an ideal state right into a messier state just by individuals interacting with the codebase and dealing on it. This occurs even when people are engaged on it or if AI brokers are engaged on the codebase.
You’ll want to refactor your code as a result of if the code is messy, it merely takes extra time to do implementations, and also you’re extra liable to errors.
Let me give a selected instance. Let’s say we’ve got a chatbot design implementation in your software the place customers can write to an AI bot and get a response again. That is mainly only a chat field area the place you present the AI responses and the person responses. code base would guarantee that you’ve got a single element that’s known as chat, and this element is utilized in all of the totally different locations within the app the place you show the chat. A poorly designed code base would have one model of this chat per totally different location within the app.
The issue then happens when you need to make a change to the interface of the chat. For instance, you need to replace the colour of the chat field or the icon of the AI. Naturally, you’ll need to replace this everywhere within the app the place you show a chat, however that signifies that a human or AI modifying the code has to edit the code in a number of totally different locations.
If the code, nevertheless, was written effectively, you’ll solely must replace the code in a single single location as a result of that’s a centralized code for a way the chat ought to look. That is only a easy instance of how well-written code could make implementations simpler and fewer liable to errors.
When to refactor your codebase
Firstly, I’ll cowl when it’s best to refactor your codebase and what indicators you need to be in search of.
To place it merely, it’s best to refactor your code when the coding brokers have gotten slower at making implementations and once you begin noticing the brokers creating extra bugs throughout an implementation. If you happen to see points showing in surprising locations, or in code you didn’t contact, it’s a clear signal that it’s best to begin refactoring.
Moreover, I like to recommend you begin refactoring earlier slightly than later. In fact, working with code that wants refactoring takes extra time and is extra liable to errors, however it’s additionally very irritating since you’ll discover that you simply begin making modifications, and the coding brokers aren’t capable of do precisely what you inform them to do.
There’s by no means a set time when this want for refactoring is available in. It doesn’t essentially occur after x quantity of days or x quantity of traces of code written. It’s extra of one thing that simply occurs over time. The necessity for refactoring merely occurs after a whole lot of work has been finished on a repository.
My principle is that this occurs as a result of some small piece of code begins to float away from the best state, which may occur for a lot of totally different causes. Additional work on this similar space of the code will amplify the consequences of the drift, and after some time, it will likely be noticeable when the coding brokers or people are much less capable of write the code there successfully.
In fact, it’s best to attempt to keep away from this as a lot as you’ll be able to; nevertheless, I do consider that refactoring just isn’t one thing it’s best to try to fully eradicate. I consider it’s a pure a part of the evolution of a codebase. You must as a substitute simply embrace the truth that you’ll must carry out refactoring every so often, and you need to be conscious of the indicators for when it’s best to begin refactoring your code.
The way to refactor code with Claude Code
Now that you understand when it’s best to refactor your codebase, I’ll begin discussing how you can refactor your codebase with Claude Code or any coding agent that you simply choose.
There are a couple of easy guidelines that I observe each time I begin refactoring.
- Use probably the most superior and high-effort reasoning you’ll be able to. Refactoring is a process that requires a whole lot of intelligence, and also you don’t need to make errors right here. For instance: Use the workflows function from Claude Code, or xhigh pondering on GPT-5.5
- Solely carry out one refactoring at a time in your repository. It’s okay to refactor whereas doing different implementations as effectively, however you don’t need to have a number of refactoring duties working directly
- In case you are uncertain of the optimum folder construction, evaluate or give the coding agent entry to a different code repository with a superb construction that you simply like, and inform it to mimic that
- Refactoring takes time. Simply have it as a process you run within the background whereas engaged on different stuff
Normally, once I begin refactoring code, I take advantage of the next setup: I open my Claude Code in a brand new worktree within the repository, and I spin it up with the best effort accessible in Claude Code, which is Ultracode.
If I do know what to refactor, I inform Ultracode and Claude as a lot data as doable on what to refactor and why to refactor it. You may assume that mentioning the why isn’t vital, and in some circumstances, it’s not, however I discover it actually helpful as a result of then the AI is knowing why I’m doing what I’m doing, which helps it align with what I need to implement.
I then give the agent a whole lot of time to undergo the whole repository, particularly the half I need to refactor, and give you an in depth plan on how you can refactor. I do that in plan mode in Claude Code.
I then learn by the plan to make sure it’s as I count on. Normally, the brokers are higher at refactoring than I’m personally, so I discover that the plans are normally okay on the primary try.
An vital a part of the immediate that I take advantage of each time I carry out refactoring is that I inform the mannequin to implement exams that it ought to run earlier than and after. The exams ought to, in fact, work beforehand, and they need to, in fact, all work once more when it’s finished. This helps the mannequin confirm its work and guarantee it doesn’t introduce any new bugs when performing refactoring.
I’ve carried out a whole lot of refactoring utilizing Claude Code, and I’d say it’s virtually good at performing refactoring work. After I used the setup I described above, I very not often skilled any points, and it virtually all the time had a major improve in how effectively the coding brokers have been capable of run in my repository.
Merely put: Refactoring code with Claude Code could be very efficient.
Conclusion
On this article, I mentioned how you can refactor code utilizing Claude Code. I mentioned why it’s best to care about refactoring, highlighting the way it could make your coding brokers far more efficient at implementations within the code repository. I then coated how you can know when you want to refactor and how you can refactor the code, that are the 2 most vital factors it’s best to know with regards to refactoring.
With AI and coding brokers, I consider refactoring code is one thing it’s best to merely do constantly in your code repository. You must usually have an agent undergo your code, test if something wants refactoring, and begin refactoring instantly. Normally, the agent will be capable of do that absolutely by itself, and you’ll not must observe up a lot with it, however it is extremely easy to do. It’s one thing it’s best to constantly do to make coding brokers as efficient as doable in your repository.
👉 My free eBook and Webinar:
🚀 10x Your Engineering with LLMs (Free 3-Day Electronic mail Course)
📚 Get my free Imaginative and prescient Language Fashions e-book
💻 My webinar on Imaginative and prescient Language Fashions
👉 Discover me on socials:
💌 Substack
