Robert Brennan
Robert Brennan has been writing software for 15 years, with a focus on natural language processing and developer tools. He is currently the CEO of All Hands AI, the company behind OpenHands (formerly OpenDevin), a fully autonomous AI developer. Previously he was VP of Product Development at Fairwinds, ran a startup called Datafire, and worked as a Senior Software Engineer at Google.
Today's coding agents excel at small, atomic tasks—the sort of things that can be done in a single commit. But large-scale refactoring projects like migrating from Java 8 to Java 25, porting C++ codebases to Rust, or breaking apart monoliths remain challenging. These tasks typically take months of engineering effort, yet they seem highly automatable.
Recent advances in LLMs and developer tooling are changing this. While agents can't one-shot massive refactors, with proper decomposition and human oversight, we can shrink months-long projects to days.
After 18 months building AI-assisted refactoring tools at OpenHands, I've observed that most teams underestimate what's possible with current agent capabilities. The key breakthrough isn't in the agents themselves—it's in how we decompose and coordinate large-scale tasks.
Three factors make this approach viable today: agents can handle full development loops (writing, testing, debugging), we've developed effective task decomposition strategies, and we've learned that 80-90% automation with human checkpoints outperforms attempts at 100% automation.
At DevCon, I'll share the complete framework we've developed for managing parallel agent workflows on enterprise refactoring projects. But first, let me address the common misconceptions that prevent teams from adopting this approach.
The conventional approach treats large refactors as monolithic tasks. This fails because agents, like junior developers, need clear, bounded work that can be validated independently.
Our solution uses dependency analysis to identify independent components. For a Java version migration, instead of "port the entire codebase," we create tasks like "update deprecated ArrayList declarations in the user service package and ensure tests pass." Each task becomes a single commit or pull request.
Managing multiple agents requires a structured branching strategy. We create a rolling integration branch (e.g., v1-refactor) where each agent works on a sub-branch (v1-refactor/component-a). Agents create PRs into the integration branch—not main—allowing human review before merging.
This workflow handles merge conflicts naturally (agents resolve them) while maintaining quality control through human checkpoints. The result: I can review and merge 10-15 agent PRs in the time it takes to manually refactor a single component.
For complex projects, we've developed the Refactor SDK with three core components:
- Task decomposition tools that automatically identify independent codebase sections
- Fixers and verifiers that define how code should be changed and validated
- Progress tracking for monitoring agent status across parallel workflows
The SDK includes dependency analysis tools that break codebases into manageable pieces based on directory boundaries and inter-component dependencies. The Refactor SDK is still in private beta, but if you are faced with a large refactoring task, please contact us. We’d be happy to learn more about your use case.
I’ve only scratched the surface here, but I’m excited to delve deeper in my upcoming presentation. I'll be presenting “Managing Fleets of Coding Agents with OpenHands” on November 19th at DevCon NYC. If you're dealing with large refactoring backlogs that consume months of engineering time, this session will show you how to complete them in significantly less time using proven agent coordination strategies.
Register at ainativedev.io/devcon
