coding agents sequentially and not in multiple runs in parallel, you’re losing out. One of the key benefits of coding agents is that you can start completing work in parallel, something that was never really possible before when working on software engineering tasks.
However, when I start running a lot of parallel coding sessions, it’s often difficult to keep track. You need specialized techniques to easily keep an overview of all the sessions that you’re running, quickly catch up on conversations when coming back to them, and so on.
This infographic highlights the main contents of this article. I’m discussing how to effectively run a lot of coding agents in parallel, highlighting why it’s a difficult challenge and different techniques that I apply. Image by ChatGPT.
Why it’s hard to run coding agents in parallel
First, I want to cover why it is challenging to run coding agents in parallel. To a certain extent, this should be quite self-explanatory. Before LLMs, software engineers and programmers would naturally only work on one task at a time. The simple reason was that if you tried multi-tasking on software engineering tasks, you would just end up being less effective. The reason is that software engineering tasks are often more complex and require your full attention. If you try to do other stuff at the same time, the performance on all tasks will likely suffer.
However, that game has changed quite a bit, as you don’t really write all of the code yourself anymore. At least in my opinion, you shouldn’t be writing all of the code yourself anymore, because coding agents should be writing the code for you. As a programmer, you should now act as a manager of coding agents, instead of writing code yourself.
However, if you’re a manager of coding agents, you naturally have to handle coding agents performing different tasks. Performing tasks in parallel by nature requires the tasks not to be connected to each other. This then again presents the same challenge as before, where you’re working on programming tasks in parallel, and you need to keep a lot of context in your working memory, and you need to be able to, for example
- Answer your coding agent whenever it asks you a question.
- Test the coding agent implementation after it’s done. You need to know what to test, how to test it, and how to ensure the coding agent did what it was supposed to do.
How to effectively run many parallel coding agents
In this section, I’ll cover some specific techniques that I use and apply daily to effectively run a lot of parallel coding agents.
Agents view in Claude Code
This image shows the agent view in Claude Code. It’s a simple terminal view where you have each of the different tasks you’re working on as a single line, and where Claude clearly marks which tasks are just running in the background and which tasks need input from you. This makes it a lot easier to keep an overview of a lot of agents compared to having one terminal tab or pane per agent running in a task. Image by the author.
A more effective technique you can apply to easily have a more comprehensive overview of your agents is to use an agent view. For example, the agent view available in Claude Code. A lot of different providers have different ways of presenting this. I know Warp, the terminal, has also recently introduced a new way to view a lot of different agents.
The good thing about the agent view is that, as you can see in the image above, you don’t have to full-screen each conversation you have with an agent. It simply becomes a single line, which you can press enter on if you want more details on it. If not, it will simply be a task running in the background, and it will ask you for input whenever any of the Claude sessions are asking for input from you.
I think this is a pretty effective way to work, since you can easily have a lot of different coding sessions running at once without it being confusing which agent is running, which agent needs input, and so on. You can activate the agents view in Claude Code with:
claude agents
Alert when the coding agent needs input
This image shows what my Warp terminal looks like when Claude Code instances need input from me. You can see the star between the Claude Code symbol and the title of each tab, which represents that the session needs input from me. If that star is not present, the process is just running in the background, and I don’t need to interact with it. Image by the author.
Another important thing you can do is to be alerted whenever coding agents need input. Of course, if you use agent mode, you could have this, as it is clearly marked out for you whenever a coding agent needs input from you. However, if you don’t like the agent’s view or want to use something else, there are different options.
In the image above, you see how I have different Claude Code sessions running in different terminal tabs. The tab includes a star between the title of the tab and the Claude Code icon if it needs input. This is a very simple way for me to see which terminal tabs I need to do something with and which tabs are just running in the background.
Another thing you can do is to also have an audio signal whenever an agent needs input from you. You can, for example, implement this by utilizing hooks in Claude Code, which are processes that run at certain points in time. A hook can, for example, be triggered every time Claude needs input from you, and you can connect this hook to an audio signal that plays, so it informs you whenever one of your coding agents needs input.
Activate recaps
This image shows the recap feature from Claude Code. The recap is simply a summary of what you were trying to do in a specific thread and what your goals were. This allows you to quickly catch up on context again, which is super useful when working with agents in parallel. Image by ChatGPT.
Recaps are another incredibly powerful feature that you can use to effectively run a lot of parallel coding agents. A common issue when running a lot of agents is that it’s hard to pick up on the context for a particular agent.
Again, let’s say you have five agents running in parallel. You first deal with agent 1 and tell it what to do, and so on, then you spin up agents 2, 3, 4, and 5. At that time, it’s probably been 10 minutes since you interacted with the first agent, or more, and then you need to quickly pick up on the context again: what were you doing with that first agent, and what were you trying to achieve, and so on. This can be quite difficult if you don’t have a recap or similar, but this is where the recap feature in Claude Code is very useful.
The recap feature, as you can see in the image above, is simply a piece of text right above the input field for the user. It summarizes what you were doing in this thread and what you were trying to achieve. You can simply read that text, and you will quickly pick up on the context again and be able to interact with your agent.
New tabs or split panes
This image shows a split pane where I have multiple Claude Code instances running. Split panes are incredibly powerful because they allow you to watch multiple coding agents at the same time without having to click to switch between them. My setup is that I typically have one tab per repository I’m working in, and within that tab I split the pane so I can have an overview of all of them at the same time. Image by ChatGPT.
The last technique I wanna cover in this article is new tabs or split panes. I highly recommend you work with a terminal view or some other platform that allows you to split panes when working with coding agents.
The image above shows an example of a split pane. If you work in the Warp terminal, you can press Command+D on your Mac, and it will split the current view horizontally so that you have two terminals you are working on. This is super powerful because it allows you to quickly have an overview of two agents at the same time, which I find very useful.
There are probably a lot of providers of terminals and other coding agents set up that allow you to have this split pane setup, but I highly recommend that you find one that works well for you.
Furthermore, the way I like to work is that I have one new tab if I’m working in different folders, so I have one tab per folder. If I’m working on multiple agents within that folder, I split the panes.
This allows me to quickly get an overview of my coding agents working in different repositories.
Conclusion
In this article, I’ve discussed how to keep an overview of parallel coding sessions. I discuss different techniques that I apply to effectively run a lot of agents in parallel and still keep a good overview of all of them. I believe the future of programmers is that they will be coding agent orchestrators. You will be a manager of AI agents. You should just immediately start working on mastering the art of working with coding agents in parallel and managing a lot of them, as I believe this will be an incredibly important skill in the future if you are working as a programmer.
👋 Get in Touch
👉 My free eBook and Webinar:
🚀 10x Your Engineering with LLMs (Free 3-Day Email Course)
📚 Get my free Vision Language Models ebook
💻 My webinar on Vision Language Models
👉 Find me on socials:
💌 Substack
🔗 LinkedIn
🐦 X / Twitter
Instagram Engineering
Shopify Engineering