I've been a devoted user of AI tools in software development for years. My journey started with the ChatGPT desktop app, led through Perplexity for research, and eventually landed at Claude.AI Desktop. Alongside all of this, I was using Continue.dev with Anthropic API keys in my beloved JetBrains IDEs. As a long-time JetBrains enthusiast, I had reached my comfort zone — until April 2025 changed everything.
"The team is already using VSCode and Roo Code," they said about the new project. For me, that meant: goodbye JetBrains, hello VSCode. A switch I would never have made voluntarily, but one that would become a turning point in my AI-assisted development. Roo Code was completely new to me. While I had been maintaining my own custom prompts in Continue.dev and had my personal preferences set up in Claude.AI, I now had to learn an entirely new system from scratch.
What started as a necessary evil quickly evolved into a fascinating journey of discovery. I began systematically extending Roo Code and built up an extensive collection of modes. My first order of business was transferring my proven development preferences from Claude.AI into Roo Code's code mode. Years of habits shouldn't go to waste. The ADR Creator mode emerged from collaboration with colleagues on the new project — we needed a structured way to document architecture decisions. My custom prompt for commit messages from Continue.dev found its way into a dedicated Roo Code mode, as did my proven code review prompt. Why abandon workflows that actually work?
The Spark
While I was steadily expanding my mode collection and continuously refining the global instructions, a conversation with my colleague Thomas Blank stuck with me: "I've built out my Roo Code modes into a development team." That idea wouldn't leave me alone.
In late July, I discovered Thomas Oppelt's "Agent Consultant" mode in our GitHub organization. That was the spark I needed.
Theoretical Foundations
This vision didn't emerge in a vacuum. During my research into multi-agent systems, I had stumbled upon interesting prior work:
- "Boomerang Tasks" for structured task delegation between agents
- SPARC (Structured Problem-solving And Reasoning Chain) for systematic problem-solving
- "claude-flow" for workflow orchestration between AI instances
These approaches showed me both the possibilities and limitations of distributed AI systems. My goal was to unite these theoretical concepts into a practical, production-ready system.
The Vision: A Complete Agile Software Development Team
First, I discussed the necessary roles of an agile software development team with Claude 4. After several iterations, we agreed on an initial role list:
- Team Lead as coordinator and delegator
- Full-Stack Developer as versatile all-rounder
- Backend and Frontend Developer as specialists
- UX/UI Designer as user experience architect
- DevOps Engineer as deployment specialist
- QA Engineer as quality guardian
- Technical Architect as system designer
- Security Engineer as security expert
- Code Reviewer as quality analyst
Building with the Agent Consultant
Armed with the role list, I instructed Thomas Oppelt's Agent Consultant mode to create this team for me. Its specialization in Roo Code mode optimization made it the perfect tool for this task.
Additional roles that emerged during development:
- Git Specialist — evolved from my existing commit message mode
- Debug Specialist and Tech Educator — adaptations of Roo Code's standard "debug" and "ask" modes
- Documentation Writer — for professional documentation
- Content Writer — for marketing and content creation
This role distribution combined proven multi-agent research with agile development principles. The scientific foundations ensured coordinated collaboration and systematic task distribution. At the same time, clear responsibilities without overlap and specialized expertise guaranteed optimal practical results.
Each mode received precisely defined tools and restrictions. This ensures focus and prevents scope creep. My approach was to transform these theoretical frameworks into a practical, production-ready system capable of doing real development work.
The Development Phase in Numbers
What followed was an intensive development phase, reflected in impressive statistics:
- 118 commits in just 3 active days
- 36.4% refactoring commits for code quality
- 28.0% documentation commits for systematic knowledge
- 0.8% bug fix rate with high initial quality
- 100% Conventional Commit compliance
Day-by-day breakdown:
- Day 1: 55 commits with massive system architecture development
- Day 2: 42 commits for handover system and extended modes
- Day 3: 21 commits for finalization and optimization
The Result: A Functioning Agile Team
The heart of the system is an 8-member standard team that covers 90% of all development scenarios:
Standard Team:
- Team Lead for project coordination
- Technical Architect for system design
- Full-Stack Developer for end-to-end development
- Code Reviewer for quality assurance
- QA Engineer for testing and quality control
- Debug Specialist for problem solving
- Tech Educator for knowledge transfer
- Documentation Writer for documentation
Additional Experts for special requirements:
- Backend and Frontend Developer for specialized development
- DevOps Engineer for infrastructure and deployment
- Security Engineer for security analysis
- UX/UI Designer for user experience
- Git Specialist for version control
- Content Writer for content creation
The system functions through a sophisticated handover mechanism:
Core Components:
- Template-based handoffs for complete context transfer
- Autonomous execution for independent work by each mode
- Quality gates for consistent results
- Escalation mechanisms for complex tasks
Rule Hierarchy for conflict resolution:
- System Integrity — core functionality and safety
- Task Continuity — task completion through escalation
- Mode Boundaries — respected areas of expertise
- Quality Gates — standards and validation
- Efficiency — performance and resource optimization
The Learnings: What I Learned Along the Way
Specialization beats generalization. Instead of a "jack of all trades," specialized modes with clear responsibilities work significantly better. Each mode has its expertise and stays in its lane.
Structured handoffs are essential. The handover system was the key to success. Without clear templates and complete context transfer, the team wouldn't function.
Quality over speed. This is evident in the high refactoring rate of 36.4%. Continuous improvement of structure is more important than rapid feature development.
Documentation is investment, not overhead. 28% of all commits were documentation. This investment pays off through better understandability and easier maintenance.
Team Lead as single point of entry. Always start with the Team Lead. They analyze, plan, and delegate optimally to the specialists.
Real-World Practice: How the Team Works Day to Day
In practice, these insights are confirmed daily. The theoretical foundations from "Boomerang Tasks" and SPARC have proven to be a solid basis. However, only the concrete implementation in Roo Code shows how these concepts really work in a productive development environment.
The combination of clear role definitions, structured handover processes, and continuous quality control creates a robust framework for AI-assisted software development.
Typical Workflows
The system shows its flexibility across different use cases:
New Web Application:
Complex Enterprise Applications:
Bug Investigations:
Continuous Evolution
The system isn't static. The TODO list shows further improvements:
- MCP tool integration for specialized tools
- Extended modes for special use cases
- Optimization of handover templates
- Agent Consultant reviews for continuous improvement
Conclusion
What started as a forced switch from JetBrains to VSCode evolved into the creation of one of the most structured AI development systems I've ever used.
The numbers speak for themselves:
- 15 specialized modes for different development tasks
- >95% task completion rate through structured escalation
- Zero information loss on handovers via template system
- 118 commits in 3 active days for intense but structured development
The paradigm shift:
Instead of individual AI tools that I have to coordinate manually, I now have a self-organizing team:
- Automatic expertise identification for every task
- Structured collaboration through clear handover processes
- Integrated quality assurance through review mechanisms
- Continuous learning through feedback loops
I still haven't become a VSCode fan and would switch back to JetBrains in a heartbeat. But Roo Code doesn't exist for JetBrains IDEs (yet) — so VSCode remains my workspace for now.
Sometimes the best innovations come through detours we would never have taken voluntarily.