They’re nice at implementing a number of code shortly. Nevertheless, should you’ve labored with coding brokers typically, you may discover that they begin to wrestle after some time. Possibly you’ve got spent a number of days writing code with AI. All the pieces was going completely and shortly till you begin noticing that duties are taking longer and the AI is making increasingly errors.
It is a clear signal that it’s essential to begin refactoring your code. After you implement quite a lot of code utilizing coding brokers, I believe refactoring your codebase will change into the norm. Coding brokers make errors and do not write good code. Moreover, in case your current code would not observe finest practices, the AI will not observe finest practices within the new code it generates. Subsequently, it’s essential to frequently refactor your repository.
This text explains methods to know when it’s essential to refactor your code, the indicators, and methods to do it successfully utilizing Claude Code and different coding brokers.
Why refactor your code?
To start with, I at all times need to deal with why you must care in regards to the subject I am discussing. Refactoring your code feels like a tedious activity, however it was a really tedious activity that you simply needed to do every now and then. Only a few years in the past, a human needed to manually go right into a code repository, discover one thing that wanted refactoring, and begin refactoring the code.
This often solely occurs as soon as, proper after making quite a lot of implementations within the code. It’s because the code naturally strikes from an ideal state to a messier state simply as folks work together and work with the codebase. This occurs whether or not people are engaged on it or AI brokers are engaged on the codebase.
Messy code takes longer to implement and is extra error-prone, so you must refactor your code.
Let’s take a concrete instance. Suppose your software implements a chatbot design that enables customers to put in writing to an AI bot and get responses. That is mainly only a chat field area that shows the AI response and the consumer response. An excellent code base will guarantee that there’s a single part referred to as Chat, and this part is utilized in all of the totally different locations within the app that show chat. A poorly designed codebase would end in one model of this chat somewhere else within the app.
This situation happens if you attempt to make modifications to the chat interface. For instance, for example you need to replace the chat field colour or the AI icon. Naturally, you may need to replace this in every single place in your app the place chat is displayed, however which means the human or AI modifying the code might want to edit the code in a number of totally different locations.
Nevertheless, if the code is written correctly, you solely must replace the code in a single place, as it’s the central code that determines how the chat is displayed. That is only a easy instance of how well-written code makes implementation simpler and fewer error-prone.
When to refactor your codebase?
First, let’s discuss when it’s essential to refactor your codebase and what indicators to search for.
Merely put, it’s essential to refactor your code if you begin noticing that your coding agent’s implementation is sluggish and the agent is including bugs throughout implementation. In case you’re seeing issues in surprising locations or in code you did not contact, that is a transparent signal that it’s essential to begin refactoring.
Moreover, it is best to start out refactoring sooner relatively than later. After all, engaged on code that wants refactoring is time-consuming and error-prone, however it can be very irritating since you begin making modifications and understand that the coding agent cannot do what you inform them to do.
It is not fastened when the necessity for refactoring will come up. It would not essentially occur after x days or x traces of code have been written. It is extra one thing that occurs over time. The necessity for refactoring happens after quite a lot of work has been achieved to the repository.
My principle is that this occurs as a result of some small piece of code has began transferring away from its ideally suited state, however this will occur for quite a lot of causes. As you’re employed additional on the identical space of code, the results of drift change into amplified, and after a whilst you discover that the flexibility of coding brokers and people to put in writing code effectively decreases.
After all, this ought to be averted if potential. Nevertheless, I consider that refactoring will not be one thing we should always attempt to get rid of fully. I consider this can be a pure a part of the evolution of the codebase. As a substitute, you must settle for the actual fact that you’ll want to refactor every now and then and concentrate on the indicators of when it’s essential to begin refactoring your code.
The best way to refactor your code utilizing Claude Code
Now that you realize when it’s essential to refactor your codebase, let’s discuss methods to refactor your codebase utilizing Claude Code or your coding agent of selection.
There are some easy guidelines to observe everytime you begin refactoring.
- Use essentially the most superior and easy reasoning potential. Refactoring is a activity that requires quite a lot of intelligence, and you do not need to make errors right here. For instance: Use Claude Code’s Workflow characteristic or GPT-5.5’s xhigh Considering.
- Run just one refactoring in a repository at a time. It is tremendous to refactor whereas different implementations are operating, however you do not need to run a number of refactoring duties on the identical time.
- If you do not know one of the best folder construction, evaluate or give your coding agent entry to a different code repository with a great construction that you simply like and ask them to imitate it.
- Refactoring takes time. Simply use it as a activity to run within the background whilst you do different work
Sometimes, once I begin refactoring my code, I exploit the next settings: Open the Claude code in a brand new worktree within the repository and spin it up with the best accessible effort (Ultracode) for the Claude code.
If you realize what to refactor, give Ultracode and Claude as a lot data as potential about what you are refactoring and why. You may not suppose it’s a necessity to say why, and typically it is not, however I discover this very helpful as a result of the AI understands why I am doing what I am doing and helps me match it with what I need to implement.
Then, give the agent sufficient time to undergo your complete repository, particularly the elements you need to refactor, and give you an in depth plan on methods to refactor it. That is achieved in Claude code’s planning mode.
Then learn the plan and ensure it meets your expectations. Brokers are often higher at refactoring than I personally, so I discover that my plans typically work on the primary strive.
An essential a part of the prompts you at all times use when performing refactoring is to inform your mannequin to implement the assessments it must run earlier than and after. After all, the assessments ought to work beforehand, and every thing ought to work once more when the assessments are full. This helps the mannequin validate its conduct and be sure that no new bugs are launched when performing refactorings.
I’ve carried out quite a lot of refactorings utilizing Claude Code, and I can say that it is close to good with regards to performing refactoring duties. Once I used the setup described above, I encountered only a few issues, and normally it tremendously improved how nicely the coding agent ran inside the repository.
Merely put, refactoring your code utilizing Claude Code is extremely efficient.
conclusion
On this article, you discovered methods to refactor your code utilizing Claude Code. We defined why you must take note of refactoring and highlighted the way it will increase the effectivity of coding brokers in implementing it in code repositories. Subsequent, we defined methods to know when it’s essential to refactor and methods to refactor your code. These are the 2 most essential factors to find out about refactoring.
When utilizing AI and coding brokers, I consider that code refactoring ought to happen repeatedly inside the code repository. You typically must have an agent have a look at your code, see if something wants refactoring, and begin refactoring straight away. Brokers can often do that fully on their very own and do not want a lot follow-up, however it’s very simple to do. This should be achieved repeatedly to make the coding agent as efficient as potential inside the repository.
👋 contact
👉 My free e-books and webinars:
🚀 10x your engineering with an LLM (free 3-day email course)
📚 Get your free Vision Language Models eBook
💻 My webinar on visual language models
👉 Discover me on social:
💌 substack
