are superb at rapidly implementing numerous code. Nevertheless, when you’ve ever labored quite a bit with coding brokers, you’ll discover they begin struggling after some time. Perhaps you’ve spent a number of days writing code with AI. All the things went completely and quick, and then you definately begin noticing the duties take longer, and the AI is making an increasing number of errors.
It is a clear signal that you might want to begin refactoring the code. I consider that refactoring your codebase goes to be normal after you’ve carried out numerous code with coding brokers. Coding brokers do make errors and don’t write excellent code. Additionally, when 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 might want to constantly refactor your repositories.
On this article, I talk about how one can know when you might want to refactor your code, what the indicators are, and how one can do it successfully utilizing Claude Code or different coding brokers.
Why refactor your code?
Initially, I at all times prefer to cowl why it’s best to care in regards to the subject I’m discussing. Refactoring the code appears like a boring process, and in actuality, it was a really boring process that you simply needed to do from time to time. Just some 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 could sometimes occur as soon as, simply after numerous 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 could 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 susceptible to errors.
Let me give a particular instance. Let’s say we’ve a chatbot design implementation in your software the place customers can write to an AI bot and get a response again. That is principally only a chat field subject the place you present the AI responses and the person responses. A very good code base would guarantee that you’ve got a single part that’s known as chat, and this part 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’d need to replace this in every single place within the app the place you show a chat, however that implies 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’d solely should replace the code in a single single location as a result of that’s a centralized code for the way the chat ought to look. That is only a easy instance of how well-written code could make implementations simpler and fewer susceptible to errors.
When to refactor your codebase
Firstly, I’ll cowl when it’s best to refactor your codebase and what indicators you ought 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 while you begin noticing the brokers creating extra bugs throughout an implementation. In the event you see points showing in sudden 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 quite than later. After all, working with code that wants refactoring takes extra time and is extra susceptible to errors, however it’s additionally very irritating since you’ll discover that you simply begin making modifications, and the coding brokers will not be 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 strains of code written. It’s extra of one thing that simply occurs over time. The necessity for refactoring merely occurs after numerous work has been completed on a repository.
My principle is that this occurs as a result of some small piece of code begins to float away from the perfect state, which might occur for a lot of totally different causes. Additional work on this identical space of the code will amplify the results of the drift, and after some time, will probably be noticeable when the coding brokers or people are much less capable of write the code there successfully.
After all, it’s best to attempt to keep away from this as a lot as you possibly can; nevertheless, I do consider that refactoring shouldn’t be one thing it’s best to try to fully remove. 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 should carry out refactoring from time to time, and you ought 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 one can refactor your codebase with Claude Code or any coding agent that you simply choose.
There are a number of easy guidelines that I observe at any time when I begin refactoring.
- Use probably the most superior and high-effort reasoning you possibly can. Refactoring is a process that requires numerous intelligence, and also you don’t need to make errors right here. For instance: Use the workflows characteristic 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
- If you’re not sure of the optimum folder construction, examine or give the coding agent entry to a different code repository with 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 exploit the next setup: I open my Claude Code in a brand new worktree within the repository, and I spin it up with the very best effort obtainable in Claude Code, which is Ultracode.
If I do know what to refactor, I inform Ultracode and Claude as a lot data as potential on what to refactor and why to refactor it. You may suppose that mentioning the why isn’t needed, and in some instances, 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 numerous time to undergo your complete repository, particularly the half I need to refactor, and provide you with an in depth plan on how one 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 often okay on the primary try.
An necessary a part of the immediate that I exploit at any time when I carry out refactoring is that I inform the mannequin to implement assessments that it ought to run earlier than and after. The assessments ought to, in fact, work beforehand, and they need to, in fact, all work once more when it’s completed. This helps the mannequin confirm its work and guarantee it doesn’t introduce any new bugs when performing refactoring.
I’ve carried out numerous refactoring utilizing Claude Code, and I might say it’s nearly excellent at performing refactoring work. Once I used the setup I described above, I very not often skilled any points, and it nearly at all times had a big improve in how effectively the coding brokers had been capable of run in my repository.
Merely put: Refactoring code with Claude Code may be very efficient.
Conclusion
On this article, I mentioned how one 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 one can know when you might want to refactor and how one can refactor the code, that are the 2 most necessary factors it’s best to know on the subject of 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, verify if something wants refactoring, and begin refactoring straight away. Normally, the agent will have the ability to do that totally by itself, and you’ll not should observe up a lot with it, however it is vitally easy to do. It’s one thing it’s best to constantly do to make coding brokers as efficient as potential in your repository.
👉 My free eBook and Webinar:
🚀 10x Your Engineering with LLMs (Free 3-Day E-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
