How many tabs do you have open right now? Probably more than one. You’re context-switching constantly — between Slack, your editor, a browser, maybe a doc you were halfway through reading. We’ve all just accepted that’s how knowledge work goes.
But when it comes to AI coding assistants? Most of us are working like it’s 2019. One task. One conversation. Wait for it to finish. Then move on to the next thing.
Five bugs are sitting in your backlog, completely independent of each other, each just waiting their turn. The AI isn’t the bottleneck. The workflow is.
I want to show you a different way of working — running multiple AI coding agents at the same time, in parallel — and why it actually changes things more than you’d expect.
The tool: Conductor by Melty Labs
The tool I’ve been spending time with is called Conductor, built by Melty Labs, a YC S24 company. Their origin story is brilliant. They described their early attempt at this as trying to clone their repo into three directories and running Claude in each of them — functional, but chaotic.
Conductor solves that properly. You point it at a GitHub repository, create workspaces, and each workspace spins up an agent in its own git worktree — an isolated copy of your codebase that shares version history but lets each agent make independent changes. One agent fixes a login bug. Another sorts out a broken form. A third works on an API issue. All at the same time, none of them getting in each other’s way.
The demo
To test this properly I built a simple React task manager app — you can add tasks, check them off, filter by status — and seeded four bugs across four different files.
The Add button does nothing when you click it. The checkboxes don’t toggle. The Active and Completed filters show the wrong tasks. And the count in the header is always wrong, showing total tasks instead of remaining ones.
Normally I’d work through these one at a time. Open a conversation, explain the context, wait, review, move on. Four separate cycles.
Instead I set up four workspaces in Conductor — one per bug. Each one spins up its own isolated environment. I give each agent its task, and they all start running at the same time.
Then I made a coffee.
Four diffs came back ready. The Add button fix was one line — onClick had been commented out on the button element. The toggle fix was also one line — it was passing the task’s array index instead of its ID, so it was always toggling the wrong item. The filter fix swapped two conditions that were the wrong way round. And the header fix changed one expression so it counts incomplete tasks instead of all of them.
Every fix was exactly what you’d expect. Clean, reviewable in seconds. Total time including reviews — about ten minutes.
Subscribe to the Medium newsletter
You can watch the full walkthrough here: [link to video]
The mental shift
None of those were difficult bugs. But that’s not the point. The workflow felt completely different. It reminded me of the first time I set up a proper CI pipeline. The individual steps don’t run any faster — it’s the orchestration that changes everything.
When you’re working with a single AI assistant, you’re in a familiar focused flow — almost like pair programming. You’re thinking about implementation details, going back and forth, it feels collaborative.
With parallel agents, that changes. You’re not really writing code anymore. You’re directing. You’re thinking about what can start right now, what needs to wait for something else, what can run alongside what. The skill stops being about coding faster and starts being about understanding what can happen simultaneously.
The first time I tried this it felt chaotic. Like trying to cook dinner, answer emails, and fix something on your phone all at once. But once it clicks, it starts to feel less like pair programming and more like delegation. You set the direction, you check the outputs, you keep things moving.
There’s also something genuinely useful here around exploration. Want to try two different approaches to a refactor? Spin up two agents and let them race. Review both diffs and pick the winner. Conductor even has a multi-model mode where you can run Claude and Codex on the same prompt side by side and compare how they approach it — which is useful for making architectural decisions.
The trade-offs
These tools are young, and parallel workflows come with real costs that don’t always get mentioned.
Setup friction is real. Git worktrees don’t carry over untracked files like your .env or node_modules, so every new workspace needs some bootstrapping. It’s not a dealbreaker, but it’s overhead worth accounting for.
Token costs multiply fast. Conductor itself is free — you pay your own API costs directly. But four simultaneous agents means four times the token usage. Worth keeping an eye on, especially early on.
You’re still the quality gate. The human bottleneck doesn’t disappear — it just shifts. Instead of waiting for one agent to finish, you’re now reviewing more things. Without some discipline in your review process, things can get messy.
And context doesn’t carry over between sessions. Every new workspace is a blank slate. The agent has no idea about your coding conventions, past decisions, or the quirks in your codebase that everyone on the team just knows about. You can mitigate this with a CLAUDE.md file or solid project documentation — but it’s always overhead worth factoring in.
A note on security
Conductor is a closed-source tool asking for read/write access to your GitHub repositories. That’s a significant level of trust. It sparked a fairly heated discussion on Hacker News when it launched. To the team’s credit, they moved quickly — they shipped fine-grained GitHub App permissions and their docs now clearly state that chat history stays local and they don’t access your conversation content. How comfortable you are with that depends on your own security posture.
If you need full source transparency, open-source alternatives like Claude Squad and Crystal are worth looking at.
Where this is heading
The future of AI-assisted development probably isn’t about waiting for models to get smarter. It’s about learning to work differently — knowing which tasks can run in parallel, breaking problems down effectively, and being honest about when the coordination overhead isn’t worth it.
Conductor is free to get started. You just need your own API key. Try it at conductor.build.
Top comments (0)