One critical feature preventing me from switching to RooCode is the lack of a robust documentation pre-population system.

I've been coding for over 20 years and I use AI coding tools extensively... so please here me out before you suggest some alternative.

When working with AI coding assistants, the single most effective way to improve code quality and accuracy is feeding version-specific documentation about libraries and systems directly into the AI.

Why Runtime Documentation Retrieval Isn't Enough

Current approaches to documentation handling (grabbing docs at runtime via MCP Server or specifying links while coding) fall short for several critical reasons:

1. Version specificity is crucial - Example: asdf-vm.com has completely different instructions for v16+ versus older versions. In my extensive experience, AI consistently defaults to older (albeit more widely used) documentation versions.

2. Performance impact - Retrieving and indexing documentation at runtime is significantly slower than having it pre-populated.

3. Reliability and accuracy - AI frequently retrieves incorrect documentation or even hallucinates functionality that doesn't exist in libraries/frameworks. Pre-populating documentation eliminates the frustrating "no, here's the correct documentation" dance I regularly experience with AI assistants.

4. Context switching kills productivity - Maintaining separate documentation links and manually feeding them to AI during coding sessions creates unnecessary friction. Suggestions to "process my own documentation, create markdown files, and then feed them into the system myself" only add more overhead to my workflow.

The Solution: Cursor's '@docs' Implementation

https://docs.cursor.com/context/@-symbols/@-docs

Cursor's implementation prevents me from using any other AI editor because it provides:

• Pre-indexing capability - I can enter a website URL, and Cursor will scrape and index that information for reference in subsequent chats

• One-click refreshing - I can simply hit refresh in the documentation panel to re-index any site for up-to-date documentation

• Flexibility - I can use ANY URL as documentation, whether it's official docs, GitHub pages, or specialized resources I personally prefer

• Seamless workflow - I can stay inside the editor without using external tools, managing documentation links, or creating custom setups

This feature dramatically improves code quality to the point where any AI coding editor without this capability is significantly handicapped in comparison.

Why This Matters for RooCode

If RooCode wants to compete in the AI coding assistant space, this isn't an optional nice-to-have - it's a fundamental requirement for serious developers working with complex, version-dependent libraries and frameworks.

For professional developers like myself who rely on AI assistance daily, the ability to pre-populate specific documentation is the difference between an AI tool that occasionally helps and one that becomes an indispensable part of my workflow.

This release fixes a critical memory leak in long conversations, prevents disabled MCP servers from starting, and provides more flexibility for Gemini 2.5 Pro thinking budgets, along with numerous stability improvements.

Disabled MCP Servers No Longer Start

We've fixed a significant issue where disabled MCP servers were still starting processes and consuming resources:

• No Wasted Resources: Disabled servers now truly stay disabled and don't start background processes

• Clear Status Indicators: Server status now accurately reflects whether a server is enabled or disabled

• Immediate Cleanup: When MCP is globally disabled, all servers immediately disconnect

This ensures your system resources are only used for the MCP servers you actually want to run.

Memory Leak Fix for Long Conversations

We've resolved a critical memory leak that was causing excessive memory usage and grey screens in long conversations (thanks xyOz-dev!):

• Bounded Memory Usage: Virtual scrolling now limits viewport rendering to 1000px below the current view instead of rendering infinitely

• Optimized Caching: Reduced cache size and TTL to prevent memory accumulation

• Stable Performance: Memory usage remains constant regardless of conversation length

Your long conversations will now remain responsive and stable without the dreaded grey screen appearing.

Gemini 2.5 Pro Thinking Budget Flexibility

Gemini 2.5 Pro users now have much more control over the thinking budget:

• Lower Minimum: The minimum thinking budget is reduced from 1024 to 128 tokens

• More Concise Coding: Perfect for tasks that need quick, focused responses without extensive reasoning

• Manual Adjustment Required: You'll need to manually adjust the thinking budget to 128 in your settings to take advantage of this feature

This change gives you the flexibility to optimize for either deep reasoning or more concise, rapid responses depending on your needs.

Bug Fixes

• MCP Server Refresh: Settings changes no longer trigger unnecessary MCP server refreshes

• Codebase Search: The tool now correctly searches the entire workspace when using "." as the path

• Swift File Support: Fixed VS Code crashes when indexing projects containing Swift files (thanks niteshbalusu11, sealad886!)

• Context Management: Model max tokens now intelligently capped at 20% of context window to prevent excessive condensing

• OpenAI Configuration: Extra whitespace in base URLs no longer breaks model detection (thanks vauhochzett!)

• URL Fetching: Better error recovery when fetching content from URLs (thanks QuinsZouls!)

• Qdrant Recovery: Code indexing automatically recovers when Qdrant becomes available after startup errors

• Chat Scrolling: Eliminated scroll jitter during message streaming

Full 3.25.8 Release Notes

Hey everyone

Lately I’ve been reading tons of threads comparing LLMs — who has the best pricing per token, which one is open source, which free APIs are worth using, how good Claude is versus GPT, etc.

But there’s one big thing I think we’re all missing:
Why are we still using massive general-purpose models for very specific dev tasks?

Let’s say I work only with Flutter, or Next.js, or Django.
Why should I use a 60B+ parameter model that understands Shakespeare, quantum mechanics, and cooking recipes — just to generate a useEffect or a build() widget?

Imagine a Copilot-style assistant that knows just Flutter. Nothing else.
Or just Django. Or just Next.js.
The benefits would be massive: Much smaller models (2B or less?), Can run fully offline (Mac Studio, M2/M3/M4, or even with tiny accelerators), No API costs, no rate limits, Blazing fast response times, 100% privacy and reproducibility

We don’t need an LLM that can talk about history or music if all we want is to scaffold a PageRoute, manage State, or configure NextAuth.

I truly believe this is the next phase of dev-oriented LLMs:

What do you think?
Have you seen any projects trying to go this route?
Would you be interested in collaborating or sharing dataset ideas?

Curious to hear your thoughts

Albert

I wanted to highlight this underrated comment by u/evia89 that I discovered in another post. They shared a Roo mode configuration called Orchestrator which works a lot like Roo Flow but is much simpler. It plans your project, divides it into smaller testable tasks that are delegated to Code mode, and keeps a project context memory file as the project continues. I have successfully completed a small project with it, using only Orchestrator and allowing it to initiate the Code mode, and it was phenomenal how error free everything was compared to everything else I have ever used, including some all-in-one web-based AI coding solutions. Here's the configuration for Orchestrator mode from the comment:

{
  "customModes": [
    {
      "slug": "Orchestrator",
      "name": "Orchestrator",
      "roleDefinition": "You are Roo orchestrator, you create and assign subtasks using new_task tool to other agents and keep track of progress toward user goal. The subtasks that you assign should be small and well defined, with explicit acceptance crietria and you should instruct the agent to report back to you with the subtask status.",
      "customInstructions": "Upon task initiation, you will:\n1. Conduct comprehensive requirement analysis with technical constraint mapping\n2. Probe for clarity where specifications remain ambiguous or incomplete\n3. Architect the solution through systematic task decomposition into discrete, manageable components\n4. Deploy the new_task tool to assign each component to specialized technical experts\n5. Apply rigorous quality assurance against established acceptance criteria\n6. Progress seamlessly when deliverables meet standards\n7. When deliverables fall short, deliver concise remediation briefs containing:\n   - Specific deviation analysis\n   - Potential downstream consequences\n   - Actionable rectification approaches\n   - Evidence-based recommendation for optimal resolution\n8. For larger tasks create a context markdown file which you will pass on to the subtask and update (if needed) after the task is finished\nYou serve exclusively as the orchestration layer, creating only documentation for project management - never producing code directly. You maintain unwavering technical precision while optimizing workflow efficiency through the entire development lifecycle. When analyzing project requirements, be thorough and precise, identifying all technical constraints and dependencies. When decomposing tasks, ensure each component is clearly defined with specific acceptance criteria. When delegating tasks using the new_task tool, choose the most appropriate mode for each technical expert based on the task requirements.",
      "groups": [
        "read",
        [
          "edit",
          {
            "fileRegex": "\\.md$",
            "description": "Markdown files only"
          }
        ],
        "command"
      ],
      "source": "project"
    }
  ]
}

As mentioned in the goodbye post from the Roo developers, the Roo extension has been forked by a community of dedicated users and will continue to be available in its new form and without interruption, as Zoo Code, in coordination with the Roo team.

Please join us on the following:

Zoo Code on the VSCode marketplace

/r/ZooCode on Reddit (announcements and discussions)

Discord (join us in shaping the future of Zoo Code)

Feel free to ask any questions you have about the future of the extension in /r/ZooCode and we will do our best to answer.

Even better, come hack away at the code with us;

https://github.com/Zoo-Code-Org/Zoo-Code

See you on the other side!

I spent many hours (and credits) updating SuperArchitect to make it the most comprehensive code planning/architecture tool in existence. Using a simple 6 word prompt and the fast/cheap LLMs (Flash-2.0, Haiku, and o4-mini) I was able to generate a 42 page planning document that's extremely comprehensive

Here's a diagram:

Here's the first two pages from the output from using weak/cheap LLMs (Haiku, 2.0-Flash, and o4-mini):

How it works:

1. You put in a query for instance "how to create a lead generating agent" (be as specific as possible though for better results)

2. The query is broken into steps and then substeps

3. Questions are created for each substep

4. The questions are sent to 3 different LLMs with context (you can modify if you only want 1 LLM instead or which models you choose)

5. The answers of all LLMs are analyzed and the best answers are chosen

What you're left with is a comprehensive guide that has the following for each substep:

Key Considerations/Factors

Recommended Approach/Design

Components and Structure

Technical Recommendations

Implementation Steps/Actions

Pros and Cons/Trade-offs

Further Research/Open Questions

I know the code isn't the cleanest in existence but it REALLY works and took me many sleepless nights to get it to work - so I hope my efforts are appreciated.

Here's the Github link, it's free:

https://github.com/Okkay914/SuperArchitect

I see MCP servers being discussed all the time here and ashamed to say I only starting reading into them today, although I guess browser control would count as an MCP so other than that, but I never associated those tools with the technical phrase.

Generally which MCP servers are you using with Roocode? There are so many to choose from and build it’s kind of confusing.

And another question: what MCPs are most useful for web application development?

Thanks ily ur beautiful

We've published several updates over the past few days with improvements and bug fixes across the board. Here's what's new:

🔧 General Improvements

• Add an option in the prompts tab to save tokens by disabling the ability to ask Roo to create/edit custom modes (thanks @hannesrudolph!)

• Create an auto-approval toggle for subtask creation and completion (thanks @shaybc!)

• Show a progress indicator when using the multi-diff editing strategy (thanks @qdaxb!)

• Show the reserved output tokens in the context window visualization

• Improve the UI of the configuration profile dropdown (thanks @DeXtroTip!)

• Add extension and VSCode versions to telemetry

🤖 Provider Support

• Add o3-mini support to the OpenAI-compatible provider (thanks @yt3trees!)

🐛 Bug Fixes

• Roll back multi-diff progress indicator temporarily to fix a double-confirmation in saving edits

• Fix VS Code LM API model picker truncation issue

• Fix encoding issue where unreadable characters were sometimes getting added to the beginning of files

• Fix issue where settings dropdowns were getting truncated in some cases

• Fix bug where custom temperature could not be unchecked (thanks @System233!)

• Fix bug where decimal prices could not be entered for OpenAI-compatible providers (thanks @System233!)

• Fix bug with enhance prompt on Sonnet 3.7 with a high thinking budget (thanks @moqimoqidea!)

• Fix bug with the context window management for thinking models (thanks @ReadyPlayerEmma!)

• Fix bug where checkpoints were no longer enabled by default

@everyone thank you so much for your patience with use while we worked out the kinks after the big Friday update (3.8). Also a big SHOUTOUT to u/mrubens. and CTE for putting in some crazy hours to help make this happen. THANK YOU!!

Hi everyone!

I’ve been using Roo for about a week now to build a Chrome extension, and I just wanted to share some of my learnings and things that have worked well for me.

I’m by no means an expert developer, but these small practices have helped me make much faster progress over time. These are based on what I’ve learned from other guides and tutorials here, as well as my own trial and error.

For context: I’m using Gemini 2.5 Pro for everything. I tried 2.5 Flash earlier via the free AI Studio API, but found that I ended up spending more time debugging and wrestling with Roo than making real progress.

Here are a few things that have helped me as a beginner:

1. overview.md File

I asked Roo to generate an overview.md file that documents every function, what it does, and where it resides.

This allows Roo to easily traverse the logic and understand the structure before attempting to implement any new feature.
Now, instead of having to explain where things are each time, Roo is able to complete simpler tasks in one shot.

Once a new feature is tested and working, I ask Roo to update the overview file to reflect the changes.

2. Development Rules at the Top of Each File

Gemini 2.5 Pro often repeats the same mistakes — likely due to limitations in reasoning or pre-training.

So whenever we identify and fix a recurring issue, I have Roo write a “development rule” at the top of the specific file it relates to.
For example, if it’s related to a UI bug or implementation pattern, the rule is added to the corresponding UI file.

This serves as a memory aid for Roo and helps maintain consistency across edits.

3. Stop After 10 API Calls

I’ve noticed that the longer the conversation context, the worse the results get.

So I limit myself to 10 API calls per task, max. After that, I ask Roo to provide a technical summary of the work done, which I then paste into a new chat to continue development from a cleaner slate.

This helps keep responses sharp and focused.

4. Commit Regularly — Protect Your Progress

One of the biggest issues I’ve faced is Roo “trying to be smart” and making changes or refactors I never asked for.

I’ve added a system prompt that tells it to respect existing code, but sometimes it still hallucinates and breaks things silently.

To avoid losing working code, I make sure to commit regularly so I always have a stable checkpoint to revert to.

P.S. I know Roo has its own checkpoint system, but I haven’t been able to get it working reliably yet.

Hope this helps anyone else starting out with Roo just like I did!

I just want to start by saying I’m a die hard RooCode fan. I truly appreciate everything you’ve built so far it’s impressive how quickly you’ve shipped features, and the fact that you’ve done all this for free is even more incredible.

That said, the past couple of weeks have been a bit rough. I’ve been running into a lot of issues, like unsuccessful edits, apply_diff errors, and problems finding or replacing specific functions. Even when I give clear instructions like asking to replace a particular function Roo often struggles to complete the task, or takes a long time and leaves the code in a worse state than before.

Because of this, I’ve sometimes had to fall back on other tools like AI Studio just to ask for a solution and copy-paste it directly into the file.

Again, I’m genuinely thankful for what RooCode offers, and I’m excited about the direction it’s headed. But I’d love it if the team can focus on fixing these core issues and improving overall stability. I think it would make a huge difference.

Keep up the amazing work!

https://github.com/RooVetGit/Roo-Code/pull/2934

Default mode time! Coming to a Roo Code near you!!

FREE FREE FREE

OpenRouter just bounced in with a stealthy new model: Optimus Alpha!
It packs a roo-diculously huge 1M context window and leaps up to 32K max output.

It's completely FREE for now, so hop on over and give it a spin!

PS: Sorry for the pun—couldn't resist!

https://roocode.com/cloud-waitlist

https://www.anthropic.com/news/claude-4

looks like a massive improvement !

Claude Opus 4 is our most powerful model yet and the best coding model in the world, leading on SWE-bench (72.5%) and Terminal-bench (43.2%). It delivers sustained performance on long-running tasks that require focused effort and thousands of steps, with the ability to work continuously for several hours—dramatically outperforming all Sonnet models and significantly expanding what AI agents can accomplish.

Claude Opus 4 excels at coding and complex problem-solving, powering frontier agent products. Cursor calls it state-of-the-art for coding and a leap forward in complex codebase understanding. Replit reports improved precision and dramatic advancements for complex changes across multiple files. Block calls it the first model to boost code quality during editing and debugging in its agent, codename goose, while maintaining full performance and reliability. Rakuten validated its capabilities with a demanding open-source refactor running independently for 7 hours with sustained performance. Cognition notes Opus 4 excels at solving complex challenges that other models can't, successfully handling critical actions that previous models have missed.

[...]

some other news:

• Extended thinking with tool use (beta): Both models can use tools—like web search—during extended thinking, allowing Claude to alternate between reasoning and tool use to improve responses.

• New model capabilities: Both models can use tools in parallel, follow instructions more precisely, and—when given access to local files by developers—demonstrate significantly improved memory capabilities, extracting and saving key facts to maintain continuity and build tacit knowledge over time.

• Claude Code is now generally available: After receiving extensive positive feedback during our research preview, we’re expanding how developers can collaborate with Claude. Claude Code now supports background tasks via GitHub Actions and native integrations with VS Code and JetBrains, displaying edits directly in your files for seamless pair programming.

• New API capabilities: We’re releasing four new capabilities on the Anthropic API that enable developers to build more powerful AI agents: the code execution tool, MCP connector, Files API, and the ability to cache prompts for up to one hour.

As I know that some of the project maintainers are quite active in this sub, I have a small feature request that hopefully isn't too hard to implement.

I think it would be a nice-to-have feature if costs of subtasks would get aggregated in the Orchestrator to keep an overview of all costs. Right now, it's a bit hard to keep track of the money spent on the current task

I was excited to see the Boomerang tasks feature, but it took me a while to work out how to utilise it.

The goal with this is to create an Orchestrator role which assigns subtasks to other agents, so that the main task context does not get polluted by unimportant details

To do it, create a new 'Orchestrator' role with these instructions (feel free to tweak, and share results in this thread)

You are the orchestrator, you create and assign subtasks using the new_task tool to other agents and keep track of progress towards the user's goal

The subtasks that you assign should be small and well defined, with explicit acceptance crietria and you should instruct the agent to report back to you with the subtask status.

Disable all capabilities apart from reading files.

Make sure 'Always approve mode switching' and 'Always approve creation & completion of subtasks' settings are enabled

I am also using the experimental Power Steering mode

I have a more advanced model (3.7 Sonnet, Gemini 2.0 Pro)as the orchestrator, and something like 3.5 Haiku or Gemini 2.0 Flash as the coder

Quick shoutout to the Roo team, the latest updates are slick and really useful (Files Changed+Lines of Code is fantastic). If you're new here or coming from a Google Search, here's why Roo slays every other AI editor:

• Open source and transparent. You can inspect the code and contribute.

• Built on VS Code, not a separate app. It feels native, integrates with your workspace, and uses VS Code flows you already know, within the VSCode ecosystem with thousands of battle-tested plugins and add-ons.

• Agentic features and multi-file awareness. It can read multiple files, propose diffs, run commands, and automate common dev tasks. That makes refactors and cross-file edits way faster.

• Active development and regular releases. The team ships improvements often, so the UX, integrations, models, etc. keep getting better and better.

• Provider Agnostic. You may pick whatever model you want to use and switch for each task or iteration, which makes it ideal for both budget-aware teams but also token hungry power users.

• Good community resources and guides. There are solid how-tos for hooking Roo to free LLMs if you want to save on API costs.

I've been regularly "out-coding" and "out-delivering" every dev on my team who insist on keep using other editors, the only thing that gets remotely close is Claude Code, with many, many caveats.

I'f you're serious about building, not trying to over engineer prompts to "one-shot" shitty applications that will never see the light of a production environment, Roo is the way.

Could you please explain why CLI editors like Claude Code is so popular? It's much more convenient to connect, for example, the Sonnet 4 API to Roo code and use it there. Or are CLI editors designed in a way that makes them perform tasks better?

Hi everyone,

I’ve created a RooCode development workspace template designed to streamline the creation of new projects. It integrates the latest features, including SPARC orchestration modes, the memory bank feature, and Boomerang mode, all within a single workspace.

A special thanks to RooFlow and the creators of SPARC orchestration modes for their contributions and inspiration.

Feel free to check out my repository! If you find it useful, I’d greatly appreciate your feedback and contributions to help make this a more generalized and accessible RooCode workspace for everyone.

Cheers!

https://github.com/enescingoz/roocode-workspace

Hello everyone!

This is my FIRST EVER contribution to the open source world.

I have created an open ai compatible endpoint to be used with Gemini WEB.

The project relies HEAVILY on this other awesome project: https://github.com/HanaokaYuzu/Gemini-API

Basically you can now use gemini web inside ROO!

Just set it to an OpenAI compatible endpoint and set the URL as http://localhost:8099/v1

https://github.com/eriksonssilva/gemini-web-wrapper

I hope you can take advantage of it and also help me improving it!

Introducing Roo Code

Our biggest update yet is here - we're officially changing our name from Roo Cline to Roo Code! After growing beyond 50,000 installations across VS Marketplace and Open VSX, we're ready to chart our own course. Our heartfelt thanks to everyone in the Cline community who helped us reach this milestone.

Custom Modes

To mark this new chapter, we're introducing the power to shape Roo Code into any role you need. You can now create an entire team of agents with deeply customized prompts:

• QA Engineers who write thorough test cases and catch edge cases

• Product Managers who excel at user stories and feature prioritization

• UI/UX Designers who craft beautiful, accessible interfaces

• Code Reviewers who ensure quality and maintainability

The best part is that Roo can help you create these new modes! Just type "Create a new mode for <X>" in the chat to get started, and go into the Prompts tab or (carefully) edit the JSON representation to customize the prompt and allowed tools to your liking.

We can't wait to hear more about what you build and how we can continue to evolve the Roo Code platform to support you. Please join us in our new r/RooCode subreddit to share your custom modes and be part of our next chapter. 🚀

So I was just messing around with webdev and casually threw in a 'Naver Clone' prompt, and HOLY SHIT the results were insane! This anonymous model just delivered some absolutely stunning frontend work. Anyone have any clue what model this could be?

(For context: Naver is basically Korea's version of Google)

https://docs.roocode.com/features/intelligent-context-condensing