are superb at rapidly implementing a whole lot of code. Nevertheless, in case you’ve ever labored lots with coding brokers, you’ll discover they begin struggling after some time. Perhaps you’ve spent a couple of days writing code with AI. All the things went completely and quick, and you then begin noticing the duties take longer, and the AI is making increasingly more errors.
It is a clear signal that it is advisable begin refactoring the code. I consider that refactoring your codebase goes to be normal after you’ve applied a whole lot of code with coding brokers. Coding brokers do make errors and don’t write good code. Additionally, in case you don’t comply with finest practices in present code, the AI will proceed not following finest practices within the new code it generates. Thus, it is advisable constantly refactor your repositories.
On this article, I focus on know when it is advisable refactor your code, what the indicators are, and 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 in regards to the matter I’m discussing. Refactoring the code feels like a boring job, and in actuality, it was once a really boring job that you simply needed to do once in a while. 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 may 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 folks 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.
It’s essential 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 vulnerable to errors.
Let me give a selected instance. Let’s say we have now 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. A great code base would guarantee that you’ve a single element that’s referred to 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 implies that a human or AI enhancing the code has to edit the code in a number of totally different locations.
If the code, nevertheless, was written nicely, 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 vulnerable 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 searching for.
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. Should you 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 fairly than later. In fact, working with code that wants refactoring takes extra time and is extra vulnerable to errors, nevertheless it’s additionally very irritating since you’ll discover that you simply begin making adjustments, and the coding brokers should not 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 a whole lot of work has been finished on a repository.
My concept 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 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.
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 attempt to fully get rid of. I consider it’s a pure a part of the evolution of a codebase. It’s best to as an alternative simply embrace the truth that you’ll must carry out refactoring once in a while, and you need to be conscious of the indicators for when it’s best to begin refactoring your code.
Easy methods to refactor code with Claude Code
Now that you already know when it’s best to refactor your codebase, I’ll begin discussing refactor your codebase with Claude Code or any coding agent that you simply want.
There are a couple of easy guidelines that I comply with every time I begin refactoring.
- Use essentially the most superior and high-effort reasoning you’ll be able to. Refactoring is a job 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 nicely, however you don’t need to have a number of refactoring duties operating directly
- If you’re uncertain of the optimum folder construction, examine 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 job you run within the background whereas engaged on different stuff
Often, 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 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 obligatory, 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 a whole lot of time to undergo all the repository, particularly the half I need to refactor, and provide you with an in depth plan on refactor. I do that in plan mode in Claude Code.
I then learn by way of the plan to make sure it’s as I count on. Often, the brokers are higher at refactoring than I’m personally, so I discover that the plans are normally okay on the primary try.
An necessary a part of the immediate that I exploit every 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, after all, work beforehand, and they need to, after all, 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 might say it’s nearly good at performing refactoring work. After I used the setup I described above, I very hardly ever skilled any points, and it nearly all the time had a big enhance in how nicely the coding brokers have been capable of run in my repository.
Merely put: Refactoring code with Claude Code may be very efficient.
Conclusion
On this article, I mentioned 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 know when it is advisable refactor and refactor the code, that are the 2 most necessary 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. It’s best to usually have an agent undergo your code, test if something wants refactoring, and begin refactoring immediately. Often, the agent will be capable of do that totally by itself, and you’ll not must comply with 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 doable 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
